void SpaceNavigatorPluginForm::SetEnableSpaceNavigator( bool enable )
{
vrOSGWidget* osgWidget = vrOSGWidget::getMGLW(-1);
if(enable)
{
// add this class to the VRED loop
addLoop();
osgWidget->getNavigator().setMode(vrNavigator::WALK);
if(osgWidget->getNavigator().getCameraZUp())
_heightOverZero = osgWidget->getNavigator().getFrom().z();
else
_heightOverZero = osgWidget->getNavigator().getFrom().y();
}
else
{
// sub this class to the VRED loop
subLoop();
osgWidget->getNavigator().setMode(vrNavigator::TRACKBALL);
}
EnableCheckBox->setChecked(enable); // for command line
}
Parents::Parents(GobEngine *vm, const Common::String &seq, const Common::String &gct,
const Common::String &childName, uint8 house, const Font &font,
const byte *normalPalette, const byte *brightPalette, uint paletteSize) :
SEQFile(vm, seq),
_gct(0), _house(house), _font(&font),
_paletteSize(paletteSize), _normalPalette(normalPalette), _brightPalette(brightPalette) {
// Load sounds
for (int i = 0; i < kSoundCount; i++)
_vm->_sound->sampleLoad(&_sounds[i], SOUND_SND, kSound[i]);
// Load GCT
Common::SeekableReadStream *gctStream = _vm->_dataIO->getFile(gct);
if (gctStream) {
_gct = new GCTFile(*gctStream, _vm->_rnd);
delete gctStream;
} else
error("Parents::Parents(): Failed to open \"%s\"", gct.c_str());
_gct->setArea(17, 18, 303, 41);
_gct->setText(1, childName);
_gct->selectLine(2, _house);
_gct->selectLine(4, _house);
for (uint i = 0; i < kLoopCount; i++)
_loopID[i] = addLoop(kLoop[i][0], kLoop[i][1], kLoop[i][2]);
}
SwitchPlugin::SwitchPlugin(void)
: vrModuleBase("Switch", NULL, VRED_MSG_SELECTED_NODE),
_mainWidget(NULL)
{
_mainWidget = new SwitchPluginForm(vrController::getModuleManager(), "SwitchPluginForm");
vrController::getModuleManager()->add("Switch", _mainWidget);
addLoop();
}
void UContainerTag::menu(QMenu &menu)
{
QMenu *m;
if(isIndependent())
{
m=menu.addMenu("Insert within");
}else
m=&menu;
m->addAction(" - Insert -")->setEnabled(false);
m->addAction("Condition",this,SLOT(addCondition()));
m->addAction("Traverse",this,SLOT(addTraverse()));
m->addAction("Loop",this,SLOT(addLoop()));
m->addAction("Break loop",this,SLOT(addBreak()));
m->addAction("Continue loop",this,SLOT(addContinue()));
m->addAction("Function call",this,SLOT(addFunction()));
m->addAction("Variable assign",this,SLOT(addAssign()));
m->addAction("Return",this,SLOT(addReturn()));
m->addAction("Python command",this,SLOT(addExec()));
m->addAction("Comment",this,SLOT(addComment()));
}
/* orthoEdges:
* For edges without position information, construct an orthogonal routing.
* If doLbls is true, use edge label info when available to guide routing,
* and set label pos for those edges for which this info is not available.
*/
void
orthoEdges (Agraph_t* g, int doLbls)
{
sgraph* sg;
maze* mp;
int n_edges;
route* route_list;
int i, gstart;
Agnode_t* n;
Agedge_t* e;
snode* sn;
snode* dn;
epair_t* es = N_GNEW(agnedges(g), epair_t);
cell* start;
cell* dest;
PointSet* ps;
textlabel_t* lbl;
if (Concentrate)
ps = newPS();
#ifdef DEBUG
{
char* s = agget(g, "odb");
char c;
odb_flags = 0;
if (s && (*s != '\0')) {
while ((c = *s++)) {
switch (c) {
case 'c' :
odb_flags |= ODB_CHANG; // emit channel graph
break;
case 'i' :
odb_flags |= (ODB_SGRAPH|ODB_IGRAPH); // emit search graphs
break;
case 'm' :
odb_flags |= ODB_MAZE; // emit maze
break;
case 'r' :
odb_flags |= ODB_ROUTE; // emit routes in maze
break;
case 's' :
odb_flags |= ODB_SGRAPH; // emit search graph
break;
}
}
}
}
#endif
if (doLbls) {
agerr(AGWARN, "Orthogonal edges do not currently handle edge labels. Try using xlabels.\n");
doLbls = 0;
}
mp = mkMaze (g, doLbls);
sg = mp->sg;
#ifdef DEBUG
if (odb_flags & ODB_SGRAPH) emitSearchGraph (stderr, sg);
#endif
/* store edges to be routed in es, along with their lengths */
n_edges = 0;
for (n = agfstnode (g); n; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e; e = agnxtout(g,e)) {
if ((Nop == 2) && ED_spl(e)) continue;
if (Concentrate) {
int ti = AGID(agtail(e));
int hi = AGID(aghead(e));
if (ti <= hi) {
if (isInPS (ps,ti,hi)) continue;
else addPS (ps,ti,hi);
}
else {
if (isInPS (ps,hi,ti)) continue;
else addPS (ps,hi,ti);
}
}
es[n_edges].e = e;
es[n_edges].d = edgeLen (e);
n_edges++;
}
}
route_list = N_NEW (n_edges, route);
qsort((char *)es, n_edges, sizeof(epair_t), (qsort_cmpf) edgecmp);
gstart = sg->nnodes;
PQgen (sg->nnodes+2);
sn = &sg->nodes[gstart];
dn = &sg->nodes[gstart+1];
for (i = 0; i < n_edges; i++) {
#ifdef DEBUG
if ((i > 0) && (odb_flags & ODB_IGRAPH)) emitSearchGraph (stderr, sg);
#endif
e = es[i].e;
start = CELL(agtail(e));
dest = CELL(aghead(e));
if (doLbls && (lbl = ED_label(e)) && lbl->set) {
}
else {
if (start == dest)
addLoop (sg, start, dn, sn);
else {
addNodeEdges (sg, dest, dn);
addNodeEdges (sg, start, sn);
}
if (shortPath (sg, dn, sn)) goto orthofinish;
}
route_list[i] = convertSPtoRoute(sg, sn, dn);
reset (sg);
}
PQfree ();
mp->hchans = extractHChans (mp);
mp->vchans = extractVChans (mp);
assignSegs (n_edges, route_list, mp);
if (setjmp(jbuf))
goto orthofinish;
assignTracks (n_edges, route_list, mp);
#ifdef DEBUG
if (odb_flags & ODB_ROUTE) emitGraph (stderr, mp, n_edges, route_list, es);
#endif
attachOrthoEdges (g, mp, n_edges, route_list, &sinfo, es, doLbls);
orthofinish:
if (Concentrate)
freePS (ps);
for (i=0; i < n_edges; i++)
free (route_list[i].segs);
free (route_list);
freeMaze (mp);
}
/*******************************************************************
Submits all relevant run information to the run table
*******************************************************************/
bool commitSimulation( Simulation* s )
{
// do nothing if database is not configured
if( DB::connectionInfo.dbname == "" ){
return true;
}
// set up thread-dependent db connection
QSqlDatabase* db;
dbLock.lock();
if( !dbStore.contains(QThread::currentThreadId()) ){
db = new QSqlDatabase();
*db = QSqlDatabase::addDatabase("QMYSQL", QString::number(QThread::currentThreadId()));
db->setHostName(DB::connectionInfo.host);
db->setDatabaseName(DB::connectionInfo.dbname);
db->setUserName(DB::connectionInfo.user);
db->setPassword(DB::connectionInfo.password);
dbStore.insert(QThread::currentThreadId(), db);
// make sure the database exists and the credentials are good
if( !db->open() ){
qCritical() << "Could not open database";
return false;
}
}
else {
db = dbStore[QThread::currentThreadId()];
}
dbLock.unlock();
// prepare queries
QSqlQuery testState(*db), addState(*db), addSim(*db), updateSim(*db);
QSqlQuery addLoop(*db), incrementLoop(*db), termLoopFromState(*db);
testState.prepare(
"SELECT COUNT(state_def) AS count, loop_id, sim_id FROM states "
"WHERE state_def=:id;");
addState.prepare(
"INSERT INTO states (state_def, next_state, stepnum, sim_id, loop_id) "
"VALUES (:statedef, :nextstate, :stepnum, :simid, :loopid);");
addSim.prepare(
"INSERT INTO simulations (sim_id, length) VALUES (:simid, :length);");
updateSim.prepare(
"UPDATE simulations SET final_state=:final, term_loop_id=:termloopid "
"WHERE sim_id=:id;");
addLoop.prepare(
"INSERT INTO loops (loop_id, length, instance_cnt) "
"VALUES (:loopid, :length, 0);");
incrementLoop.prepare(
"UPDATE loops SET instance_cnt=instance_cnt+1 WHERE loop_id=:id;");
termLoopFromState.prepare(
"SELECT simulations.term_loop_id AS termloop FROM states JOIN simulations "
"ON states.sim_id=simulations.sim_id WHERE states.state_def=:id;");
State* i;
State* initial = s->getInitialState();
ull loopState = 0;
bool loopFlag = false;
// make sure the simulation has been run
if( initial == NULL || initial->next == NULL ){
qCritical() << "Cannot commit an incomplete simulation.";
return false;
}
// lock simulation
//QMutexLocker locker( &DB::simLock );
// start transaction
db->transaction();
// loop over states
for( i = initial; i!=NULL; i = i->next )
{
// check if current state is in the db
testState.bindValue( ":id", QVariant(i->pack()) );
if( !testState.exec() ){
qCritical() << "Cannot query state table!" << endl
<< testState.lastError().text();
db->rollback();
return false;
}
testState.first();
// if state IS NOT in db
if( testState.record().value("count").toInt() == 0 )
{
// initial state is fresh
if( i == initial )
{
// commit new simulation entry
addSim.bindValue(":simid", QVariant(initial->pack()));
addSim.bindValue(":length", QVariant(s->getTotalLength()));
if( !addSim.exec() ){
qCritical() << "Cannot add new simulation to database!" << endl
<< addSim.lastError().text();
db->rollback();
return false;
}
}
// state is the start of the loop
if( *i == *(s->getLoopState()) )
{
// set the loop id flag for future commits
loopFlag = true;
loopState = i->pack();
// create new entry in the loop table
addLoop.bindValue(":id", QVariant(loopState));
addLoop.bindValue(":length", QVariant(s->getLoopLength()));
if( !addLoop.exec() ){
qCritical() << "Cannot add new loop to database!" << endl
<< addLoop.lastError().text();
db->rollback();
return false;
}
}
// commit state to db
addState.bindValue(":statedef", QVariant(i->pack()));
addState.bindValue(":nextstate", QVariant(i->next->pack()));
addState.bindValue(":stepnum", QVariant(i->stepNum));
addState.bindValue(":simid", QVariant(initial->pack()));
addState.bindValue(":loopid", loopFlag ? QVariant(loopState) : QVariant() );
if( !addState.exec() ){
qCritical() << "Cannot add new state to database!" << endl
<< addState.lastError().text();
db->rollback();
return false;
}
}
// state IS in db
else
{
// initial state has already been checked
if( i == initial )
{
// our work here is done
db->rollback();
return true;
}
// get the db state's loop id
ull termLoop = 0;
if( testState.record().value("loop_id").isNull() )
{
// join a non-loop state
termLoopFromState.bindValue(":id", QVariant(i->pack()));
if( !termLoopFromState.exec() ){
qCritical() << "Cannot retrieve terminal loop from state!" << endl
<< termLoopFromState.lastError().text();
db->rollback();
return false;
}
termLoop = termLoopFromState.record().value("termloop").toLongLong();
}
else
{
// join a loop state
termLoop = testState.record().value("loop_id").toLongLong();
}
// update simulation table with merger point and term loop id
updateSim.bindValue(":final", QVariant(i->pack()));
updateSim.bindValue(":termloopid", QVariant(termLoop));
updateSim.bindValue(":id", QVariant(initial->pack()));
if( !updateSim.exec() ){
qCritical() << "Cannot update sim with terminal info!" << endl
<< updateSim.lastError().text();
db->rollback();
return false;
}
// increment term loop instance count
incrementLoop.bindValue(":id", termLoop);
if( !incrementLoop.exec() ){
qCritical() << "Cannot increment loop instance count!" << endl
<< incrementLoop.lastError().text();
db->rollback();
return false;
}
// default case: break, complete the transaction, return true
// includes self-looping state case
break;
} // end state presence branch
} // end state loop
// commit transaction
db->commit();
// unlock simulation
//locker.unlock();
return true;
}
void LoopMachine::setPreset(const char* const presetFilename) {
// std::cout << "MPD: CPP: LoopMachine::setPreset: setting looper preset to: " << presetFilename << std::endl;
File presetFile(presetFilename);
File presetDir = presetFile.getParentDirectory();
var preset = JSON::parse(presetFile);
// std::cout << "MPD: CPP: LoopMachine::setPreset: preset json: " << preset.toString() << std::endl;
auto& obj = *preset.getDynamicObject();
jassert(&obj != nullptr);
// std::cout << "MPD: CPP: LoopMachine::setPreset: preset name: " << obj.getProperty("preset").toString()
// << "; created by: " << obj.getProperty("createdBy").toString() << ", orig bpm: "
// << obj.getProperty("origBpm").toString() << std::endl;
fixedBpmTransport.setBpm(obj.getProperty("origBpm"));
var groups = obj.getProperty("groups");
for (int i = 0; i < groups.size(); i++) {
var group = groups[i];
auto& obj = *group.getDynamicObject();
String groupName = obj.getProperty("name");
// std::cout << "MPD: CPP: LoopMachine::setPreset: adding loops for " << groupName << std::endl;
var loops = obj.getProperty("loops");
for (int j = 0; j < loops.size(); j++) {
var sampleInfoObj = loops[j];
auto& sampleInfo = *sampleInfoObj.getDynamicObject();
float gain = sampleInfo.getProperty("gain");
String typeStr = sampleInfo.getProperty("type");
LoopType type = typeStr == "one-shot" ? LoopType::ONE_SHOT : LoopType::LOOP;
int length = type == LoopType::LOOP ? (int) sampleInfo.getProperty("length") : -1;
File sample = presetDir.getChildFile(sampleInfo.getProperty("file").toString());
// std::cout << "MPD: CPP: LoopMachine::setPreset: adding sample: "
// << sample.getFullPathName() << std::endl;
addLoop(groupName, sample, gain, type, length);
}
}
var scenes = obj.getProperty("scenes");
for (int i = 0; i < scenes.size(); i++) {
var scene = scenes[i];
auto& obj = *scene.getDynamicObject();
String name = obj.getProperty("name");
int sceneIx = addScene(name);
var loops = obj.getProperty("loops");
for (int j = 0; j < loops.size(); j++) {
var obj2 = loops[j];
auto& info = *obj2.getDynamicObject();
String group = info.getProperty("group");
int groupIx = groupNameToIx[group];
int loopIx = info.getProperty("loopIx");
addSceneLoop(sceneIx, groupIx, loopIx);
}
}
prepareToPlay(expectedBufferSize, audioEngine.getTransport().getSampleRate());
}
