Example #1
0
void dNewton::ResetTimer()
{
	#ifdef _MSC_VER
		LARGE_INTEGER baseCount;
		LARGE_INTEGER frequency;
		QueryPerformanceFrequency(&frequency);
		QueryPerformanceCounter (&baseCount);
		m_baseCount = dLong (baseCount.QuadPart);
		m_frequency = dLong (frequency.QuadPart);
	#endif
/*
	#if (defined (_POSIX_VER) || defined (_POSIX_VER_64))
		timespec ts;
		clock_gettime(CLOCK_REALTIME, &ts); // Works on Linux
		//baseCount = ts.tv_nsec / 1000;
		baseCount = unsigned64 (ts.tv_sec) * 1000000 + ts.tv_nsec / 1000;
	#endif

	#ifdef _MACOSX_VER
		timeval tp;
		gettimeofday(&tp, NULL);
		unsigned64 microsecunds =  unsigned64 (tp.tv_sec) * 1000000 + tp.tv_usec;
		baseCount = microsecunds;
	#endif
*/

	m_microseconds = GetTimeInMicrosenconds();
}
Example #2
0
void OgreNewtonWorld::Update ()
{
//NewtonSerializeToFile (GetNewton(), "xxxx.bin");

	dLong lastTime = m_lastPhysicTimeInMicroseconds;
	m_lastPhysicTimeInMicroseconds = GetTimeInMicrosenconds ();
	Real applicationTime = Real (m_lastPhysicTimeInMicroseconds - lastTime) * 1.0e-6f;
	if (m_concurrentUpdateMode) {
		dNewton::UpdateAsync (m_timestep);
	} else {
		dNewton::Update (m_timestep);
	}

	dFloat param = GetInterpolationParam(m_timestep);
	dAssert (applicationTime > 0.0f);
	OnNodesTransformBegin (param);

	// iterate over all physics bodies and get the tranformtaion matrix;
	for (dNewtonBody* body = GetFirstBody(); body; body = GetNextBody(body)) {
		SceneNode* const node = (SceneNode*) body->GetUserData();
		if (node) {
			dMatrix matrix;
			body->GetVisualMatrix (param, &matrix[0][0]);
			dQuaternion rot (matrix);

			Vector3 posit (matrix.m_posit.m_x, matrix.m_posit.m_y, matrix.m_posit.m_z);
			Quaternion rotation (rot.m_q0, rot.m_q1, rot.m_q2, rot.m_q3);

			node->setPosition (posit);
			node->setOrientation (rotation);

			// update the application user data (that need to be update at rendering time, ex animations, particles emmitions, etc)
			body->OnApplicationPostTransform (applicationTime);
		}
	}
	
	OnNodesTransformEnd (param);
	m_physicUpdateTimestepInMocroseconds = GetTimeInMicrosenconds () - m_lastPhysicTimeInMicroseconds;
}
Example #3
0
int main (int argc, char* argv[])
{

	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF));

	// initialize graphics system
	if (!InitGraphicsSystem (800, 600)) {
		exit (0);
	}
	// set a callback for destroying the world ate termination
	atexit (ShutDown);

	// Create a Simple Scene Manager
	g_sceneManager = new SceneManager();

	// set the memory allocators
	NewtonSetMemorySystem (AllocMemory, FreeMemory);

	// create the Newton World
	g_world = NewtonCreate ();

	// use the standard x87 floating point model  
	NewtonSetPlatformArchitecture (g_world, 0);

	// set a fix world size
//	dVector minSize (-500.0f, -500.0f, -500.0f);
//	dVector maxSize ( 500.0f,  500.0f,  500.0f);
//	NewtonSetWorldSize (g_world, &minSize[0], &maxSize[0]); 

	// initialize Newton Visual Debugger
#ifdef USE_VISUAL_DEBUGGER
	g_newtonDebugger = NewtonDebuggerCreateServer ();
#endif

	// configure the Newton world to use iterative solve mode 0
	// this is the most efficient but the less accurate mode
	NewtonSetSolverModel (g_world, 1);

	// now populate the world with Graphic and physical entities 
	CreateScene(g_world, g_sceneManager);

    // run the main application loop until the user terminate the app
    for (;;) {
        // Draw the screen. 
        AdvanceSimulation (GetTimeInMicrosenconds ());
    }

    // Never reached. 
    return 0;
}
Example #4
0
void dNewton::UpdateAsync (dFloat timestepInSecunds)
{
	dLong timestepMicrosecunds = (dLong) (double (timestepInSecunds) * 1000000.0f);
	dLong currentTime = GetTimeInMicrosenconds ();

	dLong nextTime = currentTime - m_microseconds;
	int loops = 0;
	while ((nextTime >= timestepMicrosecunds) && (loops < m_maxUpdatePerIterations)) {
		loops ++;
		NewtonUpdateAsync (m_world, timestepInSecunds);
		nextTime -= timestepMicrosecunds;
		m_microseconds += timestepMicrosecunds;
	}
}
Example #5
0
OgreNewtonWorld::OgreNewtonWorld (int updateFramerate)
	:dNewton()
	,m_materialMap()
	,m_gravity (0.0f, -9.8f, 0.0f)
	,m_concurrentUpdateMode(true)
	,m_lastPhysicTimeInMicroseconds(GetTimeInMicrosenconds ())
	,m_physicUpdateTimestepInMocroseconds(0)
{
	SetUpdateFPS (Real (updateFramerate), 3);

	// add some of the essential managers, in order of execution
	m_triggerManager = new OgreNewtonTriggerManager(this);
	m_localTransformManager = new OgreNewtonArticulationManager (this);
	m_playerManager = new OgreNewtonPlayerManager (this);
	m_rayPickerManager = new OgreNewtonRayPickManager (this, 0);
	m_inputManager = new OgreNewtonInputManager(this);

	// when debugging it is good to set thread count to 1
	//SetNumberOfThreads(1);
}
Example #6
0
void AdvanceSimulation (int timeInMilisecunds)
{
	// do the physics simulation here
	int deltaTime;
	int physicLoopsTimeAcc;
	dFloat fps;
	dFloat physicTime;


	// get the time step
	deltaTime = timeInMilisecunds - g_currentTime;
	g_currentTime = timeInMilisecunds;
	g_timeAccumulator += deltaTime;

	physicTime = 0;
	// advance the simulation at a fix step
	int loops = 0;
	physicLoopsTimeAcc = 0;


	while ((loops < MAX_PHYSICS_LOOPS) && (g_timeAccumulator >= DEMO_FPS_IN_MICROSECUNDS))
	{
		loops ++;

		// Process incoming events. 
		ProcessEvents (g_world);

		// sample time before the Update
		g_physicTime = GetTimeInMicrosenconds ();

		// run the newton update function
		NewtonUpdate (g_world, (1.0f / DEMO_PHYSICS_FPS));

		// calculate the time spent in the physical Simulation
		g_physicTime = GetTimeInMicrosenconds () - g_physicTime;

		// call the visual debugger to show the physics scene
#ifdef USE_VISUAL_DEBUGGER
		NewtonDebuggerServe (g_newtonDebugger, g_world);
#endif

		// subtract time from time accumulator
		g_timeAccumulator -= DEMO_FPS_IN_MICROSECUNDS;
		physicTime ++;

		physicLoopsTimeAcc += g_physicTime;
	}

	if (loops > MAX_PHYSICS_LOOPS) {
		g_physicTime = physicLoopsTimeAcc;
		g_timeAccumulator = DEMO_FPS_IN_MICROSECUNDS;
	}


	// Clear the color and depth buffers. 
	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	// calculate the interpolation parameter for smooth rendering 
	g_sceneManager->SetIntepolationParam(dFloat (g_timeAccumulator) / dFloat(DEMO_FPS_IN_MICROSECUNDS));

	// do the rendering here entire Scene
	g_sceneManager->Render ();

	// display the frame rate
	// smooth the fps by averaging the last few rendering time steps;
	int dtAcc = 0;
	static int fpsIndex;
	static long int smoothFPS[128];

	smoothFPS[fpsIndex] = deltaTime;
	fpsIndex = (fpsIndex + 1) % (sizeof (smoothFPS) / sizeof (smoothFPS[0]));
	for (int i = 0; i < (sizeof (smoothFPS) / sizeof (smoothFPS[0])); i ++) {
		dtAcc += smoothFPS[i];
	}
	dtAcc /= (sizeof (smoothFPS) / sizeof (smoothFPS[0]));

	fps = 1000000.0f / dFloat (dtAcc);
	physicTime = g_physicTime * dFloat(1000.0f / 1000000.0f);
	Print (dVector (1.0f, 1.0f, 0.0f, 0.0f), 10, 10, "fps: %6.2f", fps);
	Print (dVector (1.0f, 1.0f, 0.0f, 0.0f), 10, 22, "physic time (milliseconds): %5.2f", physicTime);

	// show GL rendered Scene 
	glFlush();
	SDL_GL_SwapBuffers( );
}
Example #7
0
void dNewton::UpdateOffLine (dFloat timestepInSecunds)
{
	NewtonUpdate (m_world, timestepInSecunds);
	m_microseconds += GetTimeInMicrosenconds ();
}
Example #8
0
dFloat dNewton::GetInterpolationParam(dFloat timestepInSecunds) const
{
	dLong timeStep = GetTimeInMicrosenconds () - m_microseconds;
	dFloat param = (dFloat (timeStep) * 1.0e-6f) / timestepInSecunds;
	return dClamp (param, dFloat(0.0f), dFloat(1.0f));
}