void ApplicationController::processSimulation() { while (simulate) { stepSimulation(); std::this_thread::sleep_for(std::chrono::milliseconds(interval)); } }
static int stepSimulationThreadSafe(rtSimulationThread_t *p_thread) { //EXEC HOLD_TIME_TAKING(simulationExecutionTime); pthread_mutex_lock(&p_thread->simulationMutex); //EXEC RESUME_TIME_TAKING(simulationExecutionTime); int ret = stepSimulation(&p_thread->simulation); pthread_mutex_unlock(&p_thread->simulationMutex); return ret; }
void ParticleEffectEntityItem::update(const quint64& now) { float deltaTime = (float)(now - _lastSimulated) / (float)USECS_PER_SECOND; _lastSimulated = now; if (isEmittingParticles()) { stepSimulation(deltaTime); } EntityItem::update(now); // let our base class handle it's updates... }
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow) { if(!createWindow(SAMPLE_NAME,DISPLAY_WIDTH,DISPLAY_HEIGHT)) { MessageBox(NULL,"Can't create gl window.","ERROR",MB_OK|MB_ICONEXCLAMATION); return 0; } init(); physics_create_scene(sceneId); PfxPerfCounter counter; counter.countBegin("dt"); SCE_PFX_PRINTF("## %s: INIT SUCCEEDED ##\n", SAMPLE_NAME); MSG msg; while(s_isRunning) { if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) { if(msg.message==WM_QUIT) { s_isRunning = false; } else { TranslateMessage(&msg); DispatchMessage(&msg); } } else { counter.countEnd(); float dt = counter.getCountTime(0)/1000.f; update(dt); if(simulating) stepSimulation(dt); counter.resetCount(); counter.countBegin("dt"); render(); perf_sync(); } } shutdown(); SCE_PFX_PRINTF("## %s: FINISHED ##\n", SAMPLE_NAME); releaseWindow(); return (msg.wParam); }
void ParticleEffectEntityItem::update(const quint64& now) { float deltaTime = (float)(now - _lastAnimated) / (float)USECS_PER_SECOND; _lastAnimated = now; // only advance the frame index if we're playing if (getAnimationIsPlaying()) { _animationLoop.simulate(deltaTime); } if (isAnimatingSomething()) { stepSimulation(deltaTime); } EntityItem::update(now); // let our base class handle it's updates... }
void Simulator::mainLoop (void) { // TODO: change duration so it limits to 100 updates a second, but allows // for slower times if the client really has to think about things. std::cout << "Mainloop running" << std::endl; while (running) { sendSensors(); nextControl = getControl(); entities->rocket->applyControl(nextControl); stepSimulation(1./100); // Rate limit the simulation std::chrono::milliseconds dura(10); std::this_thread::sleep_for(dura); } std::cout << "Mainloop not running" << std::endl; }
void ParticleEffectEntityItem::update(const quint64& now) { // we check for 'now' in the past in case users set their clock backward if (now < _lastSimulated) { _lastSimulated = now; return; } float deltaTime = (float)(now - _lastSimulated) / (float)USECS_PER_SECOND; _lastSimulated = now; if (isEmittingParticles()) { stepSimulation(deltaTime); } EntityItem::update(now); // let our base class handle it's updates... }
int main(int argc, char** argv) { srand(time(0)); config(&argc, argv); initNetwork(); initSimulation(); initDisplay(&argc, argv); for(;;) { stepNetwork(); stepSimulation(); stepDisplay(); }; return 0; }
void ParticleEffectEntityItem::update(const quint64& now) { float deltaTime = (float)(now - _lastAnimated) / (float)USECS_PER_SECOND; _lastAnimated = now; // only advance the frame index if we're playing if (getAnimationIsPlaying()) { _animationLoop.simulate(deltaTime); } if (isAnimatingSomething()) { stepSimulation(deltaTime); // update the dimensions glm::vec3 dims; dims.x = glm::max(glm::abs(_particleMinBound.x), glm::abs(_particleMaxBound.x)) * 2.0f; dims.y = glm::max(glm::abs(_particleMinBound.y), glm::abs(_particleMaxBound.y)) * 2.0f; dims.z = glm::max(glm::abs(_particleMinBound.z), glm::abs(_particleMaxBound.z)) * 2.0f; setDimensions(dims); } EntityItem::update(now); // let our base class handle it's updates... }
void DynamicsWorld::update(btScalar dt) { stepSimulation(dt, maxSubSteps, timeStep); //CProfileManager::dumpAll(); }
void ForkLiftDemo::stepSimulation(float deltaTime) { //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); { int wheelIndex = 2; m_vehicle->applyEngineForce(gEngineForce,wheelIndex); m_vehicle->setBrake(gBreakingForce,wheelIndex); wheelIndex = 3; m_vehicle->applyEngineForce(gEngineForce,wheelIndex); m_vehicle->setBrake(gBreakingForce,wheelIndex); wheelIndex = 0; m_vehicle->setSteeringValue(gVehicleSteering,wheelIndex); wheelIndex = 1; m_vehicle->setSteeringValue(gVehicleSteering,wheelIndex); } float dt = deltaTime; if (m_dynamicsWorld) { //during idle mode, just run 1 simulation step maximum int maxSimSubSteps = 2; int numSimSteps; numSimSteps = m_dynamicsWorld->stepSimulation(dt,maxSimSubSteps); if (m_dynamicsWorld->getConstraintSolver()->getSolverType()==BT_MLCP_SOLVER) { btMLCPSolver* sol = (btMLCPSolver*) m_dynamicsWorld->getConstraintSolver(); int numFallbacks = sol->getNumFallbacks(); if (numFallbacks) { static int totalFailures = 0; totalFailures+=numFallbacks; printf("MLCP solver failed %d times, falling back to btSequentialImpulseSolver (SI)\n",totalFailures); } sol->setNumFallbacks(0); } //#define VERBOSE_FEEDBACK #ifdef VERBOSE_FEEDBACK if (!numSimSteps) printf("Interpolated transforms\n"); else { if (numSimSteps > maxSimSubSteps) { //detect dropping frames printf("Dropped (%i) simulation steps out of %i\n",numSimSteps - maxSimSubSteps,numSimSteps); } else { printf("Simulated (%i) steps\n",numSimSteps); } } #endif //VERBOSE_FEEDBACK } }
int main(int argc, char **argv) { bool keepGoing = true; srand(time(NULL)); //seed random generator parseArguments(argc, argv); allocWorld(); fillWorld(); Timer renderTimer = makeTimer(1.0 / config.framerate); if (config.render) initRender(); if (config.measureSamples < 0) { /* Loop forever, or until the user quits the renderer */ while (stepSimulation(&renderTimer)); } else { printf("Waiting for system to relax.\n"); for (double t = 0; keepGoing && t < config.measureWait; t += config.timeStep) { keepGoing = stepSimulation(&renderTimer); if (fmod(t, config.measureWait / 100) < config.timeStep) { printf("\rRelax time %13f of %f", (t + config.measureWait/100) / TIME_FACTOR, config.measureWait / TIME_FACTOR); fflush(stdout); } } /* Perform the measurements */ printf("\nStarting measurement.\n"); FILE *outstream = fopen(DATA_FILE_NAME, "w"); //plotHeader(outstream); double intervalTime = 0; for (long sample = 0; keepGoing && sample < config.measureSamples; sample++) { while (keepGoing && intervalTime <= config.measureInterval) { keepGoing = stepSimulation(&renderTimer); intervalTime += config.timeStep; } if (!keepGoing) break; /* Check for numerical drift (or bugs) before * commiting measurement. */ if (!physicsCheck()) die("You broke physics!\n"); dumpEnergies(outstream); printf("\rMeasured sample %ld/%ld", sample + 1, config.measureSamples); fflush(stdout); intervalTime -= config.measureInterval; } printf("\n"); fclose(outstream); } freeWorld(); return 0; }
int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) { WindowDetails* details = DefineWindow(hInstance, nShowCmd); MSG msg; int rows = details->Height / gCellSize + 2; int columns = details->Width / gCellSize + 2; int prevCellSize = gCellSize; int* sim = createSimulationMatrix(rows, columns, gBoundary); populateSimulation(gSimulationMode, sim, rows, columns, 0.35); clock_t prevTime = clock(); while (running) { while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessageW(&msg); } if (prevCellSize != gCellSize) { fitWindow(gCellSize, prevCellSize, details); prevCellSize = gCellSize; } switch (ButtonMessage) { case 1: free(sim); sim = createSimulationMatrix(rows, columns, gBoundary); populateSimulation(gSimulationMode, sim, rows, columns, 0.35); generation = 0; break; case 2: gSimulationMode++; if (gSimulationMode > 2) gSimulationMode = 0; free(sim); sim = createSimulationMatrix(rows, columns, gBoundary); populateSimulation(gSimulationMode, sim, rows, columns, 0.35); generation = 0; break; case 3: gBoundary = !gBoundary; break; } ButtonMessage = 0; clock_t curTime = clock(); if (((double)(curTime - prevTime) / CLOCKS_PER_SEC) >= gStepsPerSecond && !paused) { prevTime = curTime; generation++; swprintf_s(title, 256, titleFormat, generation, gSimulationMode, gBoundary, (int)(1 / gStepsPerSecond)); SetWindowTextW(details->Window, title); int* newSim = stepSimulation(gSimulationMode, details->BackBuffer, details->Width, sim, rows, columns, gBoundary, gCellSize); sim = newSim; StretchDIBits(details->DC, 0, 0, details->Width, details->Height, 0, 0, details->BitMapInfo.bmiHeader.biWidth, Abs(details->BitMapInfo.bmiHeader.biHeight), details->BackBuffer, &details->BitMapInfo, DIB_RGB_COLORS, SRCCOPY); } } ReleaseDC(NULL, details->DC); free(details->BackBuffer); free(details); return EXIT_SUCCESS; }