FuncScopeVariableEnvironment:: FuncScopeVariableEnvironment(const FunctionStatement *func) : m_func(func), m_staticEnv(NULL), m_argc(0), m_argStart(RequestEvalState::argStack().pos()) { const Block::VariableIndices &vi = func->varIndices(); const vector<string> &vars = func->variables(); m_byIdx.resize(vi.size()); Globals *g = NULL; for (int i = vars.size() - 1; i >= 0; i--) { const string &name = vars[i]; Block::VariableIndices::const_iterator it = vi.find(name); ASSERT(it != vi.end()); if (it == vi.end()) continue; const VariableIndex &v = it->second; String sname(name.c_str(), name.size(), AttachLiteral); if (v.superGlobal() != VariableIndex::Normal && v.superGlobal() != VariableIndex::Globals) { if (!g) g = get_globals(); // This is safe because superglobals are real members of the globals // and do not live in an array m_byIdx[v.idx()] = &g->get(sname); } else { Variant &val = m_alist.prepend(sname); m_byIdx[v.idx()] = &val; if (v.superGlobal() == VariableIndex::Globals) { val = get_global_array_wrapper(); } } } }
Shake::Shake(SimInfo* info) : info_(info), maxConsIteration_(10), consTolerance_(1.0e-6), doShake_(false), currConstraintTime_(0.0) { if (info_->getNGlobalConstraints() > 0) doShake_ = true; if (!doShake_) return; Globals* simParams = info_->getSimParams(); currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot(); if (simParams->haveConstraintTime()){ constraintTime_ = simParams->getConstraintTime(); } else { constraintTime_ = simParams->getStatusTime(); } constraintOutputFile_ = getPrefix(info_->getFinalConfigFileName()) + ".constraintForces"; // create ConstraintWriter constraintWriter_ = new ConstraintWriter(info_, constraintOutputFile_.c_str()); if (!constraintWriter_){ sprintf(painCave.errMsg, "Failed to create ConstraintWriter\n"); painCave.isFatal = 1; simError(); } }
FuncScopeVariableEnvironment:: FuncScopeVariableEnvironment(const FunctionStatement *func, int argc) : m_func(func), m_staticEnv(NULL), m_argc(argc), m_argStart(RequestEvalState::argStack().pos()) { const Block::VariableIndices &vi = func->varIndices(); m_byIdx.resize(vi.size()); Globals *g = NULL; for (Block::VariableIndices::const_iterator it = vi.begin(); it != vi.end(); ++it) { const VariableIndex &v = it->second; if (v.superGlobal() != VariableIndex::Normal && v.superGlobal() != VariableIndex::Globals) { if (!g) g = get_globals(); // This is safe because superglobals are real members of the globals // and do not live in an array m_byIdx[v.idx()] = &g->get(String(it->first.c_str(), it->first.size(), AttachLiteral), v.hash()); } else { Variant &val = m_alist.prepend(String(it->first.c_str(), it->first.size(), AttachLiteral)); m_byIdx[v.idx()] = &val; if (v.superGlobal() == VariableIndex::Globals) { val = get_global_array_wrapper(); } } } }
void FittingAnalyzer::Analyze(Trace &trace, const std::string &detType, const std::string &detSubtype, const std::map<std::string, int> & tagMap) { TraceAnalyzer::Analyze(trace, detType, detSubtype, tagMap); if(trace.HasValue("saturation") || trace.empty() || trace.GetWaveform().size() == 0) { EndAnalyze(); return; } Globals *globals = Globals::get(); const double sigmaBaseline = trace.GetValue("sigmaBaseline"); const double maxVal = trace.GetValue("maxval"); const double qdc = trace.GetValue("qdc"); const double maxPos = trace.GetValue("maxpos"); const vector<double> waveform = trace.GetWaveform(); bool isDblBeta = detType == "beta" && detSubtype == "double"; bool isDblBetaT = isDblBeta && tagMap.find("timing") != tagMap.end(); trace.plot(D_SIGMA, sigmaBaseline*100); if(!isDblBetaT) { if(sigmaBaseline > globals->sigmaBaselineThresh()) { EndAnalyze(); return; } } else { if(sigmaBaseline > globals->siPmtSigmaBaselineThresh()) { EndAnalyze(); return; } } pair<double,double> pars = globals->fitPars(detType+":"+detSubtype); if(isDblBetaT) pars = globals->fitPars(detType+":"+detSubtype+":timing"); FitDriver *driver; switch(fitterType_) { case FitDriver::GSL: driver = new GslFitter(isDblBetaT); break; case FitDriver::UNKNOWN: default: EndAnalyze(); return; } driver->PerformFit(waveform, pars, sigmaBaseline, qdc); trace.InsertValue("phase", driver->GetPhase()+maxPos); trace.plot(DD_AMP, driver->GetAmplitude(), maxVal); trace.plot(D_PHASE, driver->GetPhase()*1000+100); trace.plot(D_CHISQPERDOF, driver->GetChiSqPerDof()); delete(driver); EndAnalyze(); }
void initAL(AssocList &al) const { Globals *g = get_globals(); for (int i = 0; i < s_num-1; i++) { al.prepend(s_names[i]) = ref(g->get(s_names[i], s_hashes[i])); } al.prepend("GLOBALS") = get_global_array_wrapper(); }
bool SceneLoader::loadScene() { TiXmlElement *globalElement = root->FirstChildElement("globals"); TiXmlElement *viewElement = root->FirstChildElement("view"); TiXmlElement *illumElement = root->FirstChildElement("illumination"); if(globalElement == NULL){ cout << "> Error: Globals tag not found!\n" << endl; return false; } if(viewElement == NULL){ cout << "> Error: View tag not found!\n" << endl; return false; } if(illumElement == NULL){ cout << "> Error: Illumination tag not found!\n" << endl; return false; } sceneManager = new SceneManager(); cout << "> loading Globals..." << endl; Globals* globals = loadGlobals(globalElement); if(!(sceneManager->setGlobals(globals))){ return false; } cout << "> Globals successfully loaded" << endl << endl; maxLights = globals->getMaxLights(); maxMaterials = globals->getMaxMaterials(); maxTextures = globals->getMaxTextures(); maxObjects = globals->getMaxObjects(); cout << "> loading View..." << endl; if(!(sceneManager->setView(loadView(viewElement)))) return false; cout << "> View successfully loaded" << endl << endl; cout << "> loading Illumination..." << endl; if(!(sceneManager->setIllumination(loadIllumination(illumElement)))) return false; cout << "> Illumination successfully loaded" << endl << endl; cout << "> loading Materials..." << endl; if(!loadMaterials()) return false; cout << "> Materials successfully loaded" << endl << endl; cout << "> loading Textures..." << endl; if(!loadTextures()) return false; cout << "> Textures successfully loaded" << endl << endl; cout << "> loading Objects..." << endl; if(!loadObjects()) return false; cout << "> Objects successfully loaded!" << endl << endl; return true; }
NPT::NPT(SimInfo* info) : VelocityVerletIntegrator(info), etaTolerance(1e-6), chiTolerance(1e-6), maxIterNum_(4) { Globals* simParams = info_->getSimParams(); if (!simParams->getUseIntialExtendedSystemState()) { Snapshot* currSnapshot = info_->getSnapshotManager()->getCurrentSnapshot(); currSnapshot->setThermostat(make_pair(0.0, 0.0)); currSnapshot->setBarostat(Mat3x3d(0.0)); } if (!simParams->haveTargetTemp()) { sprintf(painCave.errMsg, "You can't use the NVT integrator without a targetTemp!\n"); painCave.isFatal = 1; painCave.severity = OPENMD_ERROR; simError(); } else { targetTemp = simParams->getTargetTemp(); } // We must set tauThermostat if (!simParams->haveTauThermostat()) { sprintf(painCave.errMsg, "If you use the constant temperature\n" "\tintegrator, you must set tauThermostat.\n"); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } else { tauThermostat = simParams->getTauThermostat(); } if (!simParams->haveTargetPressure()) { sprintf(painCave.errMsg, "NPT error: You can't use the NPT integrator\n" " without a targetPressure!\n"); painCave.isFatal = 1; simError(); } else { targetPressure = simParams->getTargetPressure(); } if (!simParams->haveTauBarostat()) { sprintf(painCave.errMsg, "If you use the NPT integrator, you must set tauBarostat.\n"); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } else { tauBarostat = simParams->getTauBarostat(); } tt2 = tauThermostat * tauThermostat; tb2 = tauBarostat * tauBarostat; updateSizes(); }
void CLOutputMgr::OutputEntryFunction(Globals& globals) { // Would ideally use the ExtensionMgr, but there is no way to set it to our // own custom made one (without modifying the code). std::ostream& out = get_main_out(); out << "__kernel void entry(__global ulong *result"; if (CLOptions::atomics()) { out << ", __global volatile uint *g_atomic_input"; out << ", __global volatile uint *g_special_values"; } if (CLOptions::atomic_reductions()) { out << ", __global volatile int *g_atomic_reduction"; } if (CLOptions::emi()) out << ", __global int *emi_input"; if (CLOptions::fake_divergence()) out << ", __global int *sequence_input"; if (CLOptions::inter_thread_comm()) out << ", __global long *g_comm_values"; out << ") {" << std::endl; globals.OutputArrayControlVars(out); globals.OutputBufferInits(out); globals.OutputStructInit(out); // Block all threads before entering to ensure the local buffers have been // initialised. output_tab(out, 1); StatementBarrier::OutputBarrier(out); out << std::endl; output_tab(out, 1); out << "func_1("; globals.GetGlobalStructVar().Output(out); out << ");" << std::endl; // If using message passing, check and update constraints to prevent deadlock. if (CLOptions::message_passing()) MessagePassing::OutputMessageEndChecks(out); // Block all threads after, to prevent hashing stale values. output_tab(out, 1); StatementBarrier::OutputBarrier(out); out << std::endl; // Handle hashing and outputting. output_tab(out, 1); out << "uint64_t crc64_context = 0xFFFFFFFFFFFFFFFFUL;" << std::endl; output_tab(out, 1); out << "int print_hash_value = 0;" << std::endl; HashGlobalVariables(out); if (CLOptions::atomics()) ExpressionAtomic::OutputHashing(out); if (CLOptions::inter_thread_comm()) StatementComm::HashCommValues(out); output_tab(out, 1); out << "result[get_linear_global_id()] = crc64_context ^ 0xFFFFFFFFFFFFFFFFUL;" << std::endl; out << "}" << std::endl; }
void CfdAnalyzer::Analyze(Trace &trace, const std::string &detType, const std::string &detSubtype, const std::map<std::string, int> & tagMap) { TraceAnalyzer::Analyze(trace, detType, detSubtype, tagMap); Globals *globals = Globals::get(); unsigned int saturation = (unsigned int)trace.GetValue("saturation"); if(saturation > 0) { EndAnalyze(); return; } double aveBaseline = trace.GetValue("baseline"); unsigned int maxPos = (unsigned int)trace.GetValue("maxpos"); pair<unsigned int, unsigned int> range = globals->waveformRange("default"); unsigned int waveformLow = range.first; unsigned int waveformHigh = range.second; unsigned int delay = 2; double fraction = 0.25; vector<double> cfd; Trace::iterator cfdStart = trace.begin(); advance(cfdStart, (int)(maxPos - waveformLow - 2)); Trace::iterator cfdStop = trace.begin(); advance(cfdStop, (int)(maxPos + waveformHigh)); for(Trace::iterator it = cfdStart; it != cfdStop; it++) { Trace::iterator it0 = it; advance(it0, delay); double origVal = *it; double transVal = *it0; cfd.insert(cfd.end(), fraction * (origVal - transVal - aveBaseline)); } vector<double>::iterator cfdMax = max_element(cfd.begin(), cfd.end()); vector<double> fitY; fitY.insert(fitY.end(), cfd.begin(), cfdMax); fitY.insert(fitY.end(), *cfdMax); vector<double>fitX; for(unsigned int i = 0; i < fitY.size(); i++) fitX.insert(fitX.end(), i); double num = fitY.size(); double sumXSq = 0, sumX = 0, sumXY = 0, sumY = 0; for(unsigned int i = 0; i < num; i++) { sumXSq += fitX.at(i)*fitX.at(i); sumX += fitX.at(i); sumY += fitY.at(i); sumXY += fitX.at(i)*fitY.at(i); } double deltaPrime = num*sumXSq - sumX*sumX; double intercept = (1/deltaPrime)*(sumXSq*sumY - sumX*sumXY); double slope = (1/deltaPrime)*(num*sumXY - sumX*sumY); trace.InsertValue("phase", (-intercept/slope)+maxPos); EndAnalyze(); }
void ConfigureKeys::on_exit() { #ifndef DISABLE_LIBSIGC Globals g; g.render().DeleteTexture(m_bg); SDL_EnableKeyRepeat(0, 0); // 0,0 disables key-repeat m_con_active.clear(); m_con_passive.clear(); #endif // DISABLE_LIBSIGC }
NgammaT::NgammaT(SimInfo* info) : NPT(info) { Globals* simParams = info_->getSimParams(); if (!simParams->haveSurfaceTension()) { sprintf(painCave.errMsg, "If you use the NgammaT integrator, you must set a surface tension.\n"); painCave.severity = OPENMD_ERROR; painCave.isFatal = 1; simError(); } else { surfaceTension= simParams->getSurfaceTension()* PhysicalConstants::surfaceTensionConvert * PhysicalConstants::energyConvert; } }
void setup(){ globals.setAverages(0); for (int f=0; f<MAX_FEATURES_MFB; ++f) { for (int i = 0; i < num_movies; ++i){ if(TRAIN_SIMU_MFB) movie_features[i][f] = (rand()%14000 + 2000) * 0.000001235f; else movie_features[f][i] = (rand()%14000 + 2000) * 0.000001235f; } for (int i=0; i<num_users; i++){ if(TRAIN_SIMU_MFB){ user_features[i][f] = (rand()%14000 + 2000) * 0.000001235f; } else{ user_features[f][i] = (rand()%14000 + 2000) * 0.000001235f; } } } for(int u=0; u<num_users; u++){ b_u[u] = 0; } for (int i = 0; i < num_movies; ++i){ b_i[i] = 0; } for(int i=0; i<db->totalVotes(); i++){ trained_cache[i] = 0.0; } fprintf(stderr, "Done initializing.\n"); }
Particle::Particle(PVector _pos, PVector _vel) { pos.equals(_pos); vel.equals(_vel); lifeTime = glob.getLifetime(); age = 0; isDead = false; noiseVec.reset(); }
void CloseFunc() { window.window_handle = -1; globals.TakeDown(); scene.skybox.TakeDown(); scene.world.TakeDown(); scene.editor.TakeDown(); }
void CLOutputMgr::Output() { std::ostream &out = get_main_out(); OutputStructUnionDeclarations(out); // Type of message_t, for message passing. if (CLOptions::message_passing()) MessagePassing::OutputMessageType(out); Globals *globals = Globals::GetGlobals(); globals->OutputStructDefinition(out); globals->ModifyGlobalVariableReferences(); globals->AddGlobalStructToAllFunctions(); OutputForwardDeclarations(out); OutputFunctions(out); OutputEntryFunction(*globals); }
Item* Globals::createSpecialItemVertical(std::string name, unsigned int value) { // 8 est la taille de "Vertical" std::string basic_name(name.substr(0, name.size() - 8)); Item* item(new SpecialItemVertical(basic_name, value)); item->setTexture(*globals.getTextureManager().getResource(name)); return item; }
void Outro::on_draw() { if (m_snd_game_exit != NULL) { if (timer_elapsed() > static_cast<unsigned int>(m_snd_game_exit->length_in_ms) + 100) { next_state(); } } Globals g; g.render().DrawTile(0,0, g.values().res_w(), g.values().res_h(), m_img_mainmenu); string text1 = g.snd2txt().text(); string text2 = ""; if (text1.length() >= 25) { text2 = text1; text1.erase(25, string::npos); text2.erase(0, 25); } g.render().DrawText(500, 400, 1.0, 1.0, 1.0, text1); g.render().DrawText(500, 450, 1.0, 1.0, 1.0, text2); }
/** * \class na::ViewDragger */ ViewDragger::ViewDragger(Globals& g, ds::ui::Sprite& parent) : mParent(parent) , mMomentum(parent.getEngine()) , mIsTouchy(false) , mReturnTime(g.getSettingsLayout().getFloat("media_viewer:check_bounds:return_time", 0, 0.6f)) { mParent.enable(true); mParent.enableMultiTouch(ds::ui::MULTITOUCH_INFO_ONLY); mParent.setProcessTouchCallback([this](ds::ui::Sprite* bs, const ds::ui::TouchInfo& ti){ onTouched(ti);}); mMomentum.setMomentumParent(&mParent); mMomentum.setMass(8.0f); mMomentum.setFriction(0.5f); }
void Particle::draw() { if (!isDead) { ofPushStyle(); ofColor aux; aux.r=0; aux.g=0; aux.b=0; aux.a=glob.getPartAlpha(); ofSetColor(aux); ofCircle(pos.x, pos.y, 1-(age/lifeTime)); ofPopStyle(); } }
void Outro::on_enter() { Globals g; string snd = g.soundlist().get_random_sound(SND_GAME_EXIT); m_snd_game_exit = g.sound().load(snd); m_img_mainmenu = g.render().LoadTexture(g.images().mainmenu()); timer_reset(); timer_start(); g.sound().play(m_snd_game_exit); g.snd2txt().lookup(snd); g.render().SetTextSizes(32, 32); }
void ConfigureKeys::draw_grab_key() { Globals g; int width = g.values().res_w(); int height = g.values().res_h(); int quarter= width / 4; SDL_Rect r = {quarter - 220, 680, width - 2*(quarter-220), 70}; g.render().FillRect(r, .0, .0, .0, .5f); string str = "Press a key for "; switch (m_which_player) { case 0: str += "Player 1!"; break; case 1: str += "Player 2!"; break; } g.render().SetTextSizes(24, 24); g.render().DrawText(r, 255, 255, 255, str); }
void Particle::update() { // Use either ofNoise() in case you want to use oF internal Perlin Noise // or per.noise() in case you want to use Chris Little's implementation //Comment or Uncomment depending on your needs // Option 1a, Chris direct :::: //Perlin per; //noiseFloat = per.noise(pos.x * 0.0025, pos.y * 0.0025, glob.getElapsedFrames() * 0.001); // Option 1b, Chris via Globals.h :::: noiseFloat = glob.getPerlinNoise(pos.x * 0.0025, pos.y * 0.0025, glob.getElapsedFrames() * 0.001); // Option 2, openFrameworks internal :::: //noiseFloat = ofNoise(pos.x * 0.0025, pos.y * 0.0025, glob.getElapsedFrames() * 0.001); noiseVec.modX((float)(cos(((noiseFloat - 0.3) * (M_PI*2)) * 10))); noiseVec.modY((float)(sin(((noiseFloat - 0.3) * (M_PI*2)) * 10))); vel.add(noiseVec); vel.div(glob.getParSpeedRedFactor()); pos.add(vel); if(1.0-(age/lifeTime) == 0) { isDead = true; } //if we have the lines, respect the space for them if (glob.getLinesMode()) { if(pos.x < glob.getV0_x() || pos.x > glob.getWid() - glob.getV0_x() || pos.y < 0 || pos.y > glob.getHei()) { isDead = true; age = lifeTime; } } else { //else grab the whole screen as limit to kill the particles if(pos.x < 0 || pos.x > glob.getWid() || pos.y < 0 || pos.y > glob.getHei()) { isDead = true; age = lifeTime; } } if(1.0-(age/lifeTime) != 0) { age++; } }
//---------------------------------------------------------------------- void glutInitialize(int tex_size) { //glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); //glutInitWindowSize(tex_size, tex_size); glutInitWindowSize(1024, 1024); glutInitWindowPosition(100, 100); glutCreateWindow("Quadrics"); glutKeyboardFunc(keyboard); glViewport(0,0, tex_size, tex_size); glutIdleFunc(idle); glutDisplayFunc(display); glutReshapeFunc(reshape); g.setWinSize(tex_size, tex_size); }
int main(int argc, char * argv[]) { globals = Globals(); srand(int(time(NULL))); glutInit(&argc, argv); glutInitWindowSize(1024, 512); glutInitWindowPosition(0, 0); glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH); window.window_handle = glutCreateWindow("Mitchell Lutzke and Joe Klonowski - CS559 - UW-Madison"); glutReshapeFunc(ReshapeFunc); glutCloseFunc(CloseFunc); glutDisplayFunc(DisplayFunc); glutKeyboardFunc(KeyboardFunc); glutSpecialFunc(SpecialFunc); glutTimerFunc(window.interval, TimerFunc, 16); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); if (glewInit() != GLEW_OK) { cerr << "GLEW failed to initialize." << endl; return 0; } ilInit(); iluInit(); ilutInit(); ilutRenderer(ILUT_OPENGL); globals.Initialize(); window.controller = new Controller(); if(! scene.skybox.Initialize()) return -1; if(! scene.editor.Initialize(window.size)) return -1; if(! scene.world.Initialize(ivec2(1024, 512))) return -1; glutMainLoop(); return 0; }
static LRESULT CALLBACK lowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam) { if (!g.m_isInitialized) initialize(false); if (!g_hookData || nCode < 0) goto through; if (g.m_mouseDetour && g.m_engine) { unsigned int result; result = g.m_mouseDetour(g.m_engine, wParam, lParam); if (result) { return 1; } } through: return CallNextHookEx(g.m_hHookMouseProc, nCode, wParam, lParam); }
static LRESULT CALLBACK lowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) { KBDLLHOOKSTRUCT *pKbll = (KBDLLHOOKSTRUCT*)lParam; if (!g.m_isInitialized) initialize(false); if (!g_hookData || nCode < 0) goto through; if (g.m_keyboardDetour && g.m_engine) { unsigned int result; result = g.m_keyboardDetour(g.m_engine, wParam, lParam); if (result) { return 1; } } through: return CallNextHookEx(g.m_hHookKeyboardProc, nCode, wParam, lParam); }
//---------------------------------------------------------------------- int main(int argc, char** argv) { //int tex_size = 4096; int tex_size = 2048; //int tex_size = 1024; glutInit(&argc, argv); glutInitialize(tex_size); //initializeEnvironment(); glDisable(GL_BLEND); glewInit(); setupObjects(tex_size); init_shaders(); g.disableShaders(); // disable shaders glutMainLoop(); return 0; }
void ConfigureKeys::on_draw() { #ifndef DISABLE_LIBSIGC Globals g; // background image g.render().DrawTile(0, 0, g.values().res_w(), g.values().res_h(), m_bg); int width = g.values().res_w(); int half = width / 2; int quarter= width / 4; SDL_Rect top = {quarter - 220, 80, width - 2*(quarter-220), 80}; SDL_Rect rl = {quarter - 220, 170, half - 50, 500}; SDL_Rect rr = {half + (half -(quarter - 220 + (half - 50))), 170, half - 50, 500}; g.render().FillRect(top,.0, .0, .0, 0.5f); g.render().FillRect(rl ,.0, .0, .0, 0.5f); g.render().FillRect(rr ,.0, .0, .0, 0.5f); m_con_active.draw_all(); m_con_passive.draw_all(); draw_player_keys(); m_anim_bomb.Update(); if (mb_grab_key) { draw_grab_key(); m_anim_bomb.Draw(quarter - 185, 740, 50, 50); m_anim_bomb.Draw(quarter - 220 + (width - 2*(quarter-220)) - 45, 740, 50, 50); } else { int index = m_con_active.current_focused(); m_anim_bomb.Draw(quarter-145 + 512*(index>5?1:0), 142 + 75*((index>5?(index-6):index)+1), 50, 50); } #endif // DISABLE_LIBSIGC }
void ConfigureKeys::on_enter() { #ifndef DISABLE_LIBSIGC Globals g; SDL_EnableKeyRepeat(g.values().get(VAL_MENU_KEYREPEAT_DELAY), g.values().get(VAL_MENU_KEYREPEAT_INTERVAL)); create_key_map(); create_gui(); mb_grab_key = false; m_which_player = 0; m_bg = g.render().LoadTexture(g.images().background_random()); m_anim_bomb.SetAnimation(ANI_BOMB); m_anim_bomb.Start(); mp_keyconfig = &g.keycfg(); g.render().SetTextSizes(16, 16); #endif // DISABLE_LIBSIGC }
Globals* SceneLoader:: loadGlobals(TiXmlElement *globalElement){ Globals* globals = new Globals(); return globals->loadAttributes(globalElement); }