int main()
{
int i;
if (!rocket_init("data/sync"))
return -1;
for (i = 0; i < sizeof_array(s_trackNames); ++i)
s_tracks[i] = sync_get_track(device, s_trackNames[i]);
for (;;)
{
float row_f;
rocket_update();
row_f = ms_to_row_f(curtime_ms, rps);
printf("current time %d\n", curtime_ms);
for (i = 0; i < sizeof_array(s_trackNames); ++i)
printf("%s %f\n", s_trackNames[i], sync_get_val(s_tracks[i], row_f));
#if defined(WIN32)
Sleep(16);
#else
usleep(16000);
#endif
}
}
static void onEnterCurrentValue()
{
int idx;
struct track_key key;
struct sync_track* track;
struct sync_track** tracks = getTracks();
const int rowPos = getRowPos();
const int activeTrack = getActiveTrack();
if (!tracks)
return;
track = tracks[activeTrack];
if (!track->keys)
{
key.row = rowPos;
key.value = 0.0f;
key.type = 0;
Commands_addOrUpdateKey(activeTrack, &key);
updateNeedsSaving();
return;
}
idx = sync_find_key(track, rowPos);
if (idx < 0)
idx = -idx - 1;
key.row = rowPos;
if (track->num_keys > 0)
{
key.value = (float)sync_get_val(track, rowPos);
key.type = track->keys[emaxi(idx - 1, 0)].type;
}
else
{
key.value = 0.0f;
key.type = 0;
}
Commands_addOrUpdateKey(activeTrack, &key);
updateNeedsSaving();
}
static int drawCurrentValue(int posX, int sizeY)
{
char valueText[256];
float value = 0.0f;
int active_track = 0;
int current_row = 0;
const char *str = "---";
struct sync_track** tracks = getTracks();
active_track = getActiveTrack();
current_row = getRowPos();
if (tracks)
{
const struct sync_track* track = tracks[active_track];
int idx = key_idx_floor(track, current_row);
if (idx >= 0)
{
switch (track->keys[idx].type)
{
case KEY_STEP: str = "step"; break;
case KEY_LINEAR: str = "linear"; break;
case KEY_SMOOTH: str = "smooth"; break;
case KEY_RAMP: str = "ramp"; break;
default: break;
}
}
value = (float)sync_get_val(track, current_row);
}
snprintf(valueText, 256, "%f", value);
Emgui_drawText(valueText, posX + 4, sizeY - 15, Emgui_color32(160, 160, 160, 255));
Emgui_drawBorder(Emgui_color32(10, 10, 10, 255), Emgui_color32(10, 10, 10, 255), posX, sizeY - 17, 80, 15);
Emgui_drawText(str, posX + 85, sizeY - 15, Emgui_color32(160, 160, 160, 255));
Emgui_drawBorder(Emgui_color32(10, 10, 10, 255), Emgui_color32(10, 10, 10, 255), posX + 80, sizeY - 17, 40, 15);
return 130;
}
static LRESULT CALLBACK mainWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
case WM_CREATE:
{
trackViewWin = trackView->create(hInst, hwnd);
InitCommonControls();
statusBarWin = createStatusBar(hInst, hwnd);
if (ERROR_SUCCESS != RegOpenKey(HKEY_CURRENT_USER, keyName, ®ConfigKey))
{
if (ERROR_SUCCESS != RegCreateKey(HKEY_CURRENT_USER, keyName, ®ConfigKey))
die("failed to create registry key");
}
/* Recent Files menu */
mruFileList = RecentFiles(findSubMenuContaining(GetMenu(hwnd), ID_RECENTFILES_NORECENTFILES));
mruFileList.load(regConfigKey);
}
break;
case WM_CLOSE:
attemptQuit();
break;
case WM_DESTROY:
mruFileList.save(regConfigKey);
RegCloseKey(regConfigKey);
regConfigKey = NULL;
PostQuitMessage(0);
break;
case WM_SIZE:
{
int width = LOWORD(lParam);
int height = HIWORD(lParam);
RECT statusBarRect;
GetClientRect(statusBarWin, &statusBarRect);
int statusBarHeight = statusBarRect.bottom - statusBarRect.top;
MoveWindow(trackViewWin, 0, 0, width, height - statusBarHeight, TRUE);
MoveWindow(statusBarWin, 0, height - statusBarHeight, width, statusBarHeight, TRUE);
}
break;
case WM_SETFOCUS:
SetFocus(trackViewWin); // needed to forward keyboard input
break;
case WM_SETROWS:
trackView->setRows(int(lParam));
break;
case WM_BIASSELECTION:
trackView->editBiasValue(float(lParam));
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case ID_FILE_NEW:
fileNew();
InvalidateRect(trackViewWin, NULL, FALSE);
break;
case ID_FILE_OPEN:
fileOpen();
break;
case ID_FILE_SAVE_AS:
fileSaveAs();
break;
case ID_FILE_SAVE:
fileSave();
break;
case ID_EDIT_SELECTALL:
trackView->selectAll();
break;
case ID_EDIT_SELECTTRACK:
trackView->selectTrack(trackView->getEditTrack());
break;
case ID_EDIT_SELECTROW:
trackView->selectRow(trackView->getEditRow());
break;
case ID_FILE_REMOTEEXPORT:
document.sendSaveCommand();
break;
case ID_RECENTFILES_FILE1:
case ID_RECENTFILES_FILE2:
case ID_RECENTFILES_FILE3:
case ID_RECENTFILES_FILE4:
case ID_RECENTFILES_FILE5:
{
int index = LOWORD(wParam) - ID_RECENTFILES_FILE1;
std::wstring fileName;
if (mruFileList.getEntry(index, fileName))
{
loadDocument(fileName);
}
}
break;
case ID_FILE_EXIT:
attemptQuit();
break;
case ID_EDIT_UNDO: SendMessage(trackViewWin, WM_UNDO, 0, 0); break;
case ID_EDIT_REDO: SendMessage(trackViewWin, WM_REDO, 0, 0); break;
case ID_EDIT_COPY: SendMessage(trackViewWin, WM_COPY, 0, 0); break;
case ID_EDIT_CUT: SendMessage(trackViewWin, WM_CUT, 0, 0); break;
case ID_EDIT_PASTE: SendMessage(trackViewWin, WM_PASTE, 0, 0); break;
case ID_EDIT_SETROWS:
{
int rows = int(trackView->getRows());
INT_PTR result = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SETROWS), hwnd, (DLGPROC)setRowsDialogProc, (LPARAM)&rows);
if (FAILED(result))
error("unable to create dialog box");
}
break;
case ID_EDIT_BIAS:
{
int initialBias = 0;
INT_PTR result = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_BIASSELECTION), hwnd, (DLGPROC)biasSelectionDialogProc, (LPARAM)&initialBias);
if (FAILED(result))
error("unable to create dialog box");
}
break;
}
break;
case WM_ROWCHANGED:
{
char temp[256];
snprintf(temp, 256, "%d", lParam );
SendMessage(statusBarWin, SB_SETTEXT, 1, (LPARAM)temp);
}
break;
case WM_TRACKCHANGED:
{
char temp[256];
snprintf(temp, 256, "%d", lParam);
SendMessage(statusBarWin, SB_SETTEXT, 2, (LPARAM)temp);
}
break;
case WM_CURRVALDIRTY:
{
char temp[256];
if (document.num_tracks > 0) {
const sync_track *t = document.tracks[document.getTrackIndexFromPos(trackView->getEditTrack())];
int row = trackView->getEditRow();
int idx = key_idx_floor(t, row);
snprintf(temp, 256, "%f", sync_get_val(t, row));
const char *str = "---";
if (idx >= 0) {
switch (t->keys[idx].type) {
case KEY_STEP: str = "step"; break;
case KEY_LINEAR: str = "linear"; break;
case KEY_SMOOTH: str = "smooth"; break;
case KEY_RAMP: str = "ramp"; break;
}
}
SendMessage(statusBarWin, SB_SETTEXT, 4, (LPARAM)str);
} else
snprintf(temp, 256, "---");
SendMessage(statusBarWin, SB_SETTEXT, 3, (LPARAM)temp);
}
break;
default:
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
return 0;
}
int main(int argc, char *argv[])
{
#ifndef SYNC_PLAYER
bool should_save = false; // whether to save tracks when done.
// don't save unless we actually connect.
#endif
HSTREAM stream;
const struct sync_track *clear_r, *clear_g, *clear_b;
const struct sync_track *cam_rot, *cam_dist;
setup_sdl();
/* init BASS */
if (!BASS_Init(-1, 44100, 0, 0, 0))
die("failed to init bass");
stream = BASS_StreamCreateFile(false, "tune.ogg", 0, 0,
BASS_STREAM_PRESCAN);
if (!stream)
die("failed to open tune");
sync_device *rocket = sync_create_device("sync");
if (!rocket)
die("out of memory?");
#ifndef SYNC_PLAYER
if (sync_connect(rocket, "localhost", SYNC_DEFAULT_PORT))
die("failed to connect to host");
#endif
/* get tracks */
clear_r = sync_get_track(rocket, "clear.r");
clear_g = sync_get_track(rocket, "clear.g");
clear_b = sync_get_track(rocket, "clear.b");
cam_rot = sync_get_track(rocket, "cam.rot"),
cam_dist = sync_get_track(rocket, "cam.dist");
/* let's roll! */
BASS_Start();
BASS_ChannelPlay(stream, false);
bool done = false;
while (!done) {
double row = bass_get_row(stream);
#ifndef SYNC_PLAYER
if (sync_update(rocket, (int)floor(row), &bass_cb, (void *)&stream)) {
if (sync_connect(rocket, "localhost", SYNC_DEFAULT_PORT) == 0)
should_save = true;
}
#endif
/* draw */
glClearColor(float(sync_get_val(clear_r, row)),
float(sync_get_val(clear_g, row)),
float(sync_get_val(clear_b, row)), 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
float rot = float(sync_get_val(cam_rot, row));
float dist = float(sync_get_val(cam_dist, row));
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, 4.0f / 3, 0.1f, 100.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
gluLookAt(sin(rot) * dist, 0, cos(rot) * dist,
0, 0, 0,
0, 1, 0);
glEnable(GL_DEPTH_TEST);
draw_cube();
glPopMatrix();
SDL_GL_SwapBuffers();
BASS_Update(0); /* decrease the chance of missing vsync */
SDL_Event e;
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT ||
(e.type == SDL_KEYDOWN &&
e.key.keysym.sym == SDLK_ESCAPE))
done = true;
}
}
#ifndef SYNC_PLAYER
if(should_save) //don't clobber if user just ran it then hit Esc
sync_save_tracks(rocket);
#endif
sync_destroy_device(rocket);
BASS_StreamFree(stream);
BASS_Free();
SDL_Quit();
return 0;
}
static void toggleMute(void* userData)
{
struct MuteData* data = (struct MuteData*)userData;
// if we have mute data we should toggle back the track to it's old form
if (data->track->muteBackup)
{
int i;
sync_del_key(data->syncTrack, 0);
RemoteConnection_sendDeleteKeyCommand(data->syncTrack->name, 0);
for (i = 0; i < data->track->muteKeyCount; ++i)
{
struct track_key* key = &data->track->muteBackup[i];
sync_set_key(data->syncTrack, key);
RemoteConnection_sendSetKeyCommand(data->syncTrack->name, key);
}
data->track->disabled = false;
free(data->track->muteBackup);
data->track->muteBackup = 0;
data->track->muteKeyCount = 0;
}
else
{
struct track_key defKey;
int i;
size_t keysSize = sizeof(struct track_key) * data->syncTrack->num_keys;
float currentValue = (float)sync_get_val(data->syncTrack, data->row);
data->track->disabled = true;
// No muteBackup, this means that we want to mute the channel
data->track->muteBackup = malloc(keysSize);
data->track->muteKeyCount = data->syncTrack->num_keys;
memcpy(data->track->muteBackup, data->syncTrack->keys, keysSize);
for (i = 0; i < data->syncTrack->num_keys; ++i)
{
int row = data->track->muteBackup[i].row;
sync_del_key(data->syncTrack, row);
RemoteConnection_sendDeleteKeyCommand(data->syncTrack->name, row);
}
defKey.row = 0;
defKey.value = currentValue;
defKey.type = KEY_STEP;
// insert key with the current value
sync_set_key(data->syncTrack, &defKey);
RemoteConnection_sendSetKeyCommand(data->syncTrack->name, &defKey);
}
}
