vino/rocket
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

cleaned up the interface. time to give the code-structure a big overhaul.

Browse Source
This commit is contained in:
Erik Faye-Lund 2008-02-14 22:05:18 +00:00
parent 366f34ba9d
commit 60a835fa35
13 changed files with 312 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
client.cpp
View File

@ -1,6 +1,7 @@
#include <stdio.h>
#include "network.h"
#include "syncdataclient.h"
#include "syncdevice.h"
int main(int argc, char *argv[])
{
@ -27,7 +28,7 @@ int main(int argc, char *argv[])
SyncDataClient syncData(serverSocket);
SyncTrack &track = syncData.getTrack("test");
SyncTrack &track2 = syncData.getTrack("test2");
// SyncTrack &track2 = syncData.getTrack("test2");
puts("recieving...");
bool done = false;

77
example.cpp Normal file
View File

@ -0,0 +1,77 @@
#include <stdio.h>
#include "sync/device.h"
#if 0
class BassTimer : public sync::Timer
{
public:
BassTimer(HSTREAM stream, float bpm) : stream(stream)
{
rowRate = bpm / 60;
}
// BASS hooks
void pause() { BASS_ChannelPause(stream); }
void play() { BASS_ChannelPlay(stream, false); }
float getTime() { return BASS_ChannelBytes2Seconds(stream, BASS_ChannelGetPosition(stream)); }
float getRow() { return getTime() * rowRate; }
void setRow(float pos) { BASS_ChannelSetPosition(stream, BASS_ChannelSeconds2Bytes(stream, row / rowRate)); }
bool isPlaying() { return (BASS_ChannelIsActive(stream) == BASS_ACTIVE_PLAYING); }
private:
HSTREAM stream;
float rowRate;
};
#else
#include <cmath>
class NullTimer : public sync::Timer
{
public:
NullTimer() : paused(true), row(0) {}
void pause() { paused = true; }
void play() { paused = false; }
float getRow()
{
if (!paused) return row++;
else return row;
}
void setRow(float row) { row = int(floor(row)); }
bool isPlaying() { return !paused; }
private:
bool paused;
int row;
};
#endif
#include <memory>
int main(int argc, char *argv[])
{
// BassTimer timer(stream, 120.0f);
NullTimer timer;
std::auto_ptr<sync::Device> syncDevice = std::auto_ptr<sync::Device>(sync::createDevice("sync", timer));
if (NULL == syncDevice.get())
{
printf("wft?!");
return -1;
}
sync::Track &track = syncDevice->getTrack("test");
// timer.play();
while (1)
{
float row = timer.getRow();
if (!syncDevice->update(row)) break;
printf("%2.2f: %2.2f \r", row, track.getValue(row));
}
return 0;
}

33
sync/device.h Normal file
View File

@ -0,0 +1,33 @@
#ifndef SYNC_H
#define SYNC_H
#include <string>
#include "track.h"
namespace sync
{
class Timer
{
public:
virtual ~Timer() {};
virtual void pause() = 0;
virtual void play() = 0;
virtual float getRow() = 0;
virtual void setRow(float pos) = 0;
virtual bool isPlaying() = 0;
};
class Device
{
public:
virtual ~Device() {}
virtual Track &getTrack(const std::string &trackName) = 0;
virtual bool update(float row) = 0;
};
Device *createDevice(const std::string &baseName, Timer &timer);
}
#endif /* SYNC_H */

61
sync/device_client.cpp Normal file
View File

@ -0,0 +1,61 @@
#include "device.h"
#include "../network.h"
#include "../syncdataclient.h"
using namespace sync;
class ClientDevice : public Device
{
public:
ClientDevice(SOCKET serverSocket, Timer &timer) : syncData(serverSocket), timer(timer) {}
~ClientDevice();
Track &getTrack(const std::string &trackName);
bool update(float row);
private:
SyncDataClient syncData;
Timer &timer;
};
ClientDevice::~ClientDevice()
{
}
Track &ClientDevice::getTrack(const std::string &trackName)
{
return syncData.getTrack(trackName);
}
bool ClientDevice::update(float row)
{
return !syncData.poll();
}
Device *sync::createDevice(const std::string &baseName, Timer &timer)
{
if (false == initNetwork())
{
printf("noes 1!\n");
return NULL;
}
struct hostent *myhost = gethostbyname("localhost");
struct sockaddr_in sain;
sain.sin_family = AF_INET;
sain.sin_port = htons(1338);
sain.sin_addr.s_addr= *( (unsigned long *)(myhost->h_addr_list[0]) );
// connect to server
SOCKET serverSocket = serverConnect(&sain);
if (INVALID_SOCKET == serverSocket)
{
printf("noes 2!\n");
return NULL;
}
Device *device = new ClientDevice(serverSocket, timer);
return device;
}

57
sync/track.cpp Normal file
View File

@ -0,0 +1,57 @@
#include "track.h"
using namespace sync;
#include <cmath>
#include <cstddef>
float Track::getValue(float time) const
{
if (keyFrames.size() == 0) return 0.0f;
int currRow = int(floor(time));
// find bounding keyframes
KeyFrameContainer::const_iterator upper = keyFrames.upper_bound(currRow);
KeyFrameContainer::const_iterator lower = upper;
lower--;
// bounds check
if (lower == keyFrames.end()) return upper->second.value;
if (upper == keyFrames.end()) return lower->second.value;
float delta = upper->second.value - lower->second.value;
// lerp, bitch
float d = (time - lower->first) / (upper->first - lower->first);
return lower->second.value + delta * d;
}
bool Track::isKeyFrame(size_t row) const
{
return keyFrames.find(row) != keyFrames.end();
}
const Track::KeyFrame *Track::getKeyFrame(size_t row) const
{
KeyFrameContainer::const_iterator iter = keyFrames.find(row);
if (iter == keyFrames.end()) return NULL;
return &iter->second;
}
void Track::deleteKeyFrame(size_t row)
{
keyFrames.erase(row);
}
void Track::setKeyFrame(size_t row, const KeyFrame &keyFrame)
{
keyFrames[row] = keyFrame;
}
size_t Track::getFrameCount() const
{
if (keyFrames.empty()) return 0;
KeyFrameContainer::const_iterator iter = keyFrames.end();
iter--;
return iter->first;
}

35
sync/track.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef SYNC_TRACK_H
#define SYNC_TRACK_H
#include <map>
namespace sync
{
class Track
{
public:
struct KeyFrame
{
KeyFrame() : lerp(false) {}
KeyFrame(float value) : value(value), lerp(false) {}
float value;
bool lerp;
};
float getValue(float time) const;
bool isKeyFrame(size_t row) const;
const KeyFrame *getKeyFrame(size_t row) const;
size_t getFrameCount() const;
void deleteKeyFrame(size_t row);
void setKeyFrame(size_t row, const KeyFrame &keyFrame);
void setKeyFrame(size_t row, const float value);
// private:
typedef std::map<size_t, struct KeyFrame> KeyFrameContainer;
KeyFrameContainer keyFrames;
};
}
#endif // SYNC_TRACK_H

82
syncdata.h
View File

@ -7,79 +7,7 @@
#include <exception>
#include <cmath>
class SyncTrack
{
public:
struct KeyFrame
{
KeyFrame() : lerp(false) {}
KeyFrame(float value) : value(value), lerp(false) {}
float value;
bool lerp;
};
float getValue(float time)
{
if (keyFrames.size() == 0) return 0.0f;
int currRow = int(floor(time));
// find bounding keyframes
KeyFrameContainer::const_iterator upper = keyFrames.upper_bound(currRow);
KeyFrameContainer::const_iterator lower = upper;
lower--;
// bounds check
if (lower == keyFrames.end()) return upper->second.value;
if (upper == keyFrames.end()) return lower->second.value;
float delta = upper->second.value - lower->second.value;
// lerp, bitch
float d = (time - lower->first) / (upper->first - lower->first);
return lower->second.value + delta * d;
}
bool isKeyFrame(size_t row) const
{
return keyFrames.find(row) != keyFrames.end();
}
const KeyFrame *getKeyFrame(size_t row) const
{
KeyFrameContainer::const_iterator iter = keyFrames.find(row);
if (iter == keyFrames.end()) return NULL;
return &iter->second;
}
void deleteKeyFrame(size_t row)
{
keyFrames.erase(row);
}
void setKeyFrame(size_t row, const KeyFrame &keyFrame)
{
keyFrames[row] = keyFrame;
}
void setKeyFrame(size_t row, const float value)
{
setKeyFrame(row, KeyFrame(value));
}
size_t getFrameCount() const
{
if (keyFrames.empty()) return 0;
KeyFrameContainer::const_iterator iter = keyFrames.end();
iter--;
return iter->first;
}
// private:
typedef std::map<size_t, struct KeyFrame> KeyFrameContainer;
KeyFrameContainer keyFrames;
};
#include "sync/track.h"
class SyncData
{
@ -91,11 +19,11 @@ public:
size_t index = actualTracks.size();
tracks[name] = index;
actualTracks.push_back(new SyncTrack());
actualTracks.push_back(new sync::Track);
return index;
}
SyncTrack &getTrack(const std::basic_string<TCHAR> &name)
sync::Track &getTrack(const std::basic_string<TCHAR> &name)
{
size_t index = getTrackIndex(name);
assert(index >= 0);
@ -104,7 +32,7 @@ public:
return *actualTracks[index];
}
SyncTrack &getTrack(size_t track)
sync::Track &getTrack(size_t track)
{
assert(track >= 0);
assert(track < tracks.size());
@ -120,6 +48,6 @@ public:
typedef std::map<const std::basic_string<TCHAR>, size_t> TrackContainer;
// typedef std::map<const std::basic_string<TCHAR>, SyncTrack> TrackContainer;
TrackContainer tracks;
std::vector<SyncTrack*> actualTracks;
std::vector<sync::Track*> actualTracks;
};

4
syncdataclient.cpp
View File

@ -1,7 +1,7 @@
#include "syncdataclient.h"
#include "network.h"
SyncTrack &SyncDataClient::getTrack(const std::basic_string<TCHAR> &name)
sync::Track &SyncDataClient::getTrack(const std::basic_string<TCHAR> &name)
{
TrackContainer::iterator iter = tracks.find(name);
if (iter != tracks.end()) return *actualTracks[iter->second];
@ -20,7 +20,7 @@ SyncTrack &SyncDataClient::getTrack(const std::basic_string<TCHAR> &name)
const char *name_str = name.c_str();
send(serverSocket, name_str, name_len, 0);
SyncTrack *track = new SyncTrack();
sync::Track *track = new sync::Track();
/* todo: fill in based on the response */
actualTracks.push_back(track);

4
syncdataclient.h
View File

@ -6,9 +6,9 @@ class SyncDataClient : public SyncData
public:
SyncDataClient(SOCKET serverSocket) : serverSocket(serverSocket) {}
SyncTrack &getTrack(const std::basic_string<TCHAR> &name);
sync::Track &getTrack(const std::basic_string<TCHAR> &name);
bool poll();
private:
std::map<int, SyncTrack*> serverRemap;
std::map<int, sync::Track*> serverRemap;
SOCKET serverSocket;
};

28
synceditdata.h
View File

@ -11,7 +11,7 @@ class SyncEditData : public SyncData
public:
SyncEditData() : SyncData() {}
void sendSetKeyCommand(int track, int row, const SyncTrack::KeyFrame &key)
void sendSetKeyCommand(int track, int row, const sync::Track::KeyFrame &key)
{
if (INVALID_SOCKET == clientSocket) return;
if (clientRemap.count(track) == 0) return;
@ -46,12 +46,12 @@ public:
class InsertCommand : public Command
{
public:
InsertCommand(int track, int row, const SyncTrack::KeyFrame &key) : track(track), row(row), key(key) {}
InsertCommand(int track, int row, const sync::Track::KeyFrame &key) : track(track), row(row), key(key) {}
~InsertCommand() {}
virtual void exec(SyncEditData *data)
{
SyncTrack &t = data->getTrack(this->track);
sync::Track &t = data->getTrack(this->track);
assert(!t.isKeyFrame(row));
t.setKeyFrame(row, key);
@ -60,7 +60,7 @@ public:
virtual void undo(SyncEditData *data)
{
SyncTrack &t = data->getTrack(this->track);
sync::Track &t = data->getTrack(this->track);
assert(t.isKeyFrame(row));
t.deleteKeyFrame(row);
@ -69,7 +69,7 @@ public:
private:
int track, row;
SyncTrack::KeyFrame key;
sync::Track::KeyFrame key;
};
class DeleteCommand : public Command
@ -80,7 +80,7 @@ public:
virtual void exec(SyncEditData *data)
{
SyncTrack &t = data->getTrack(this->track);
sync::Track &t = data->getTrack(this->track);
assert(t.isKeyFrame(row));
oldKey = *t.getKeyFrame(row);
t.deleteKeyFrame(row);
@ -90,7 +90,7 @@ public:
virtual void undo(SyncEditData *data)
{
SyncTrack &t = data->getTrack(this->track);
sync::Track &t = data->getTrack(this->track);
assert(!t.isKeyFrame(row));
t.setKeyFrame(row, oldKey);
@ -99,19 +99,19 @@ public:
private:
int track, row;
SyncTrack::KeyFrame oldKey;
sync::Track::KeyFrame oldKey;
};
class EditCommand : public Command
{
public:
EditCommand(int track, int row, const SyncTrack::KeyFrame &key) : track(track), row(row), key(key) {}
EditCommand(int track, int row, const sync::Track::KeyFrame &key) : track(track), row(row), key(key) {}
~EditCommand() {}
virtual void exec(SyncEditData *data)
{
SyncTrack &t = data->getTrack(this->track);
sync::Track &t = data->getTrack(this->track);
// store old key
assert(t.isKeyFrame(row));
@ -125,7 +125,7 @@ public:
virtual void undo(SyncEditData *data)
{
SyncTrack &t = data->getTrack(this->track);
sync::Track &t = data->getTrack(this->track);
assert(t.isKeyFrame(row));
t.setKeyFrame(row, oldKey);
@ -135,7 +135,7 @@ public:
private:
int track, row;
SyncTrack::KeyFrame oldKey, key;
sync::Track::KeyFrame oldKey, key;
};
class MultiCommand : public Command
@ -215,9 +215,9 @@ public:
}
}
Command *getSetKeyFrameCommand(int track, int row, const SyncTrack::KeyFrame &key)
Command *getSetKeyFrameCommand(int track, int row, const sync::Track::KeyFrame &key)
{
SyncTrack &t = getTrack(track);
sync::Track &t = getTrack(track);
SyncEditData::Command *cmd;
if (t.isKeyFrame(row)) cmd = new EditCommand(track, row, key);
else cmd = new InsertCommand(track, row, key);

20
synctracker2.cpp
View File

@ -67,7 +67,7 @@ static LRESULT CALLBACK setRowsDialogProc(HWND hDlg, UINT message, WPARAM wParam
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
}
return FALSE;
}
@ -114,7 +114,7 @@ static LRESULT CALLBACK biasSelectionDialogProc(HWND hDlg, UINT message, WPARAM
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
}
return FALSE;
}
@ -163,12 +163,12 @@ static LRESULT CALLBACK mainWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARA
case WM_SETFOCUS:
SetFocus(trackViewWin); // needed to forward keyboard input
break;
case WM_SETROWS:
printf("rows: %d\n", int(lParam));
trackView->setRows(int(lParam));
break;
case WM_BIASSELECTION:
trackView->editBiasValue(float(lParam));
break;
@ -283,13 +283,14 @@ int _tmain(int argc, _TCHAR* argv[])
SyncEditData syncData;
syncData.clientSocket = INVALID_SOCKET;
#if 0
SyncTrack &camXTrack = syncData.getTrack(_T("cam.x"));
SyncTrack &camXTrack2 = syncData.getTrack(_T("cam.x"));
camXTrack.setKeyFrame(1, 2.0f);
camXTrack.setKeyFrame(4, 3.0f);
printf("%p %p\n", &camXTrack, &camXTrack2);
SyncTrack &camYTrack = syncData.getTrack(_T("cam.y"));
SyncTrack &camZTrack = syncData.getTrack(_T("cam.z"));
@ -313,6 +314,7 @@ int _tmain(int argc, _TCHAR* argv[])
float time = float(i) / 2;
printf("%f %d - %f\n", time, camXTrack.isKeyFrame(i), camXTrack.getValue(time));
}
#endif
ATOM mainClass = registerMainWindowClass(hInstance);
ATOM trackViewClass = registerTrackViewWindowClass(hInstance);
@ -426,13 +428,13 @@ int _tmain(int argc, _TCHAR* argv[])
// setup remap
syncData.clientRemap[serverIndex] = clientIndex;
const SyncTrack &track = *syncData.actualTracks[serverIndex];
const sync::Track &track = *syncData.actualTracks[serverIndex];
SyncTrack::KeyFrameContainer::const_iterator it;
sync::Track::KeyFrameContainer::const_iterator it;
for (it = track.keyFrames.begin(); it != track.keyFrames.end(); ++it)
{
int row = int(it->first);
const SyncTrack::KeyFrame &key = it->second;
const sync::Track::KeyFrame &key = it->second;
syncData.sendSetKeyCommand(int(serverIndex), row, key);
}

4
synctracker2.vcproj
View File

@ -192,6 +192,10 @@
>
</File>
<File
RelativePath=".\sync\track.cpp"
>
</File>
<File
RelativePath=".\trackview.cpp"
>
</File>

18
trackview.cpp
View File

@ -263,7 +263,7 @@ void TrackView::paintTracks(HDC hdc, RECT rcTracks)
// InvertRect(hdc, &fillRect);
const SyncTrack &track = *syncData->actualTracks[trackIter->second];
const sync::Track &track = *syncData->actualTracks[trackIter->second];
bool key = track.isKeyFrame(row);
/* format the text */
@ -317,7 +317,7 @@ void TrackView::paintTracks(HDC hdc, RECT rcTracks)
struct CopyEntry
{
int track, row;
SyncTrack::KeyFrame keyFrame;
sync::Track::KeyFrame keyFrame;
};
@ -343,13 +343,13 @@ void TrackView::editCopy()
for (int track = selectLeft; track <= selectRight; ++track)
{
int localTrack = track - selectLeft;
const SyncTrack &t = syncData->getTrack(track);
const sync::Track &t = syncData->getTrack(track);
for (int row = selectTop; row <= selectBottom; ++row)
{
int localRow = row - selectTop;
if (t.isKeyFrame(row))
{
const SyncTrack::KeyFrame *keyFrame = t.getKeyFrame(row);
const sync::Track::KeyFrame *keyFrame = t.getKeyFrame(row);
assert(NULL != keyFrame);
CopyEntry ce;
@ -647,9 +647,9 @@ void TrackView::editEnterValue()
{
if (editString.size() > 0)
{
SyncTrack &t = syncData->getTrack(editTrack);
sync::Track &t = syncData->getTrack(editTrack);
SyncTrack::KeyFrame newKey;
sync::Track::KeyFrame newKey;
if (t.isKeyFrame(editRow)) newKey = *t.getKeyFrame(editRow); // copy old key
newKey.value = float(_tstof(editString.c_str())); // modify value
@ -672,7 +672,7 @@ void TrackView::editDelete()
SyncEditData::MultiCommand *multiCmd = new SyncEditData::MultiCommand();
for (int track = selectLeft; track <= selectRight; ++track)
{
SyncTrack &t = syncData->getTrack(track);
sync::Track &t = syncData->getTrack(track);
for (int row = selectTop; row <= selectBottom; ++row)
{
if (t.isKeyFrame(row))
@ -705,12 +705,12 @@ void TrackView::editBiasValue(float amount)
SyncEditData::MultiCommand *multiCmd = new SyncEditData::MultiCommand();
for (int track = selectLeft; track <= selectRight; ++track)
{
SyncTrack &t = syncData->getTrack(track);
sync::Track &t = syncData->getTrack(track);
for (int row = selectTop; row <= selectBottom; ++row)
{
if (t.isKeyFrame(row))
{
SyncTrack::KeyFrame newKey = *t.getKeyFrame(row); // copy old key
sync::Track::KeyFrame newKey = *t.getKeyFrame(row); // copy old key
newKey.value += amount; // modify value
// add sub-command