//void dCustomTransformManager::PreUpdate(dFloat timestep)
void dCustomTransformManager::PreUpdate(dFloat timestep, int threadID)
{
// for (dList<dCustomTransformController>::dListNode* node = m_controllerList.GetFirst(); node; node = node->GetNext()) {
// dCustomTransformController* const controller = &node->GetInfo();
// OnPreUpdate(controller, timestep, 0);
// }
D_TRACKTIME();
NewtonWorld* const world = GetWorld();
const int threadCount = NewtonGetThreadsCount(world);
dList<dCustomTransformController>::dListNode* node = m_controllerList.GetFirst();
for (int i = 0; i < threadID; i++) {
node = node ? node->GetNext() : NULL;
}
if (node) {
dCustomTransformController* const controller = &node->GetInfo();
OnPreUpdate(controller, timestep, threadID);
do {
for (int i = 0; i < threadCount; i++) {
node = node ? node->GetNext() : NULL;
}
} while (node);
}
}
void NewtonDemos::CalculateFPS(float timestep)
{
m_framesCount ++;
m_timestepAcc += timestep;
// this probably happing on loading of and a pause, just rest counters
if ((m_timestepAcc <= 0.0f) || (m_timestepAcc > 2.0f)){
m_timestepAcc = 0;
m_framesCount = 0;
}
//update fps every quarter of a second
if (m_timestepAcc >= 0.25f) {
m_fps = float (m_framesCount) / m_timestepAcc;
m_timestepAcc -= 0.25f;
m_framesCount = 0.0f;
wxString statusText;
NewtonWorld* const world = m_scene->GetNewton();
char platform[256];
NewtonGetDeviceString(world, NewtonGetCurrentDevice(world), platform, sizeof (platform));
int memoryUsed = NewtonGetMemoryUsed() / (1024) ;
statusText.Printf (wxT ("render fps: %7.2f"), m_fps);
m_statusbar->SetStatusText (statusText, 0);
statusText.Printf (wxT ("physics time: %4.2f ms"), m_scene->GetPhysicsTime() * 1000.0f);
m_statusbar->SetStatusText (statusText, 1);
statusText.Printf (wxT ("memory: %d kbytes"), memoryUsed);
m_statusbar->SetStatusText (statusText, 2);
statusText.Printf (wxT ("bodies: %d"), NewtonWorldGetBodyCount(world));
m_statusbar->SetStatusText (statusText, 3);
statusText.Printf (wxT ("threads: %d"), NewtonGetThreadsCount(world));
m_statusbar->SetStatusText (statusText, 4);
statusText.Printf (wxT ("auto sleep: %s"), m_autoSleepState ? wxT("on") : wxT("off"));
m_statusbar->SetStatusText (statusText, 5);
char floatMode[128];
NewtonGetDeviceString (world, m_hardwareDevice, floatMode, sizeof (floatMode));
statusText.Printf (wxT ("instructions: %s"), wxString::FromAscii(floatMode).wc_str());
m_statusbar->SetStatusText (statusText, 6);
}
}
void dAnimationModelManager::PostUpdate(dFloat timestep, int threadID)
{
D_TRACKTIME();
NewtonWorld* const world = GetWorld();
const int threadCount = NewtonGetThreadsCount(world);
dList<dAnimationJointRoot*>::dListNode* node = m_controllerList.GetFirst();
for (int i = 0; i < threadID; i++) {
node = node ? node->GetNext() : NULL;
}
if (node) {
dAnimationJointRoot* const model = node->GetInfo();
OnPostUpdate(model, timestep);
model->UpdateTransforms(timestep);
do {
for (int i = 0; i < threadCount; i++) {
node = node ? node->GetNext() : NULL;
}
} while (node);
}
}
void dCustomPlayerControllerManager::PreUpdate(dFloat timestep, int threadID)
{
D_TRACKTIME();
NewtonWorld* const world = GetWorld();
const int threadCount = NewtonGetThreadsCount(world);
dList<dCustomPlayerController>::dListNode* node = m_playerList.GetFirst();
for (int i = 0; i < threadID; i++) {
node = node ? node->GetNext() : NULL;
}
if (node) {
dCustomPlayerController* const controller = &node->GetInfo();
controller->PreUpdate(timestep);
do {
for (int i = 0; i < threadCount; i++) {
node = node ? node->GetNext() : NULL;
}
} while (node);
}
}
void dRuntimeProfiler::RenderThreadPerformance ()
{
NewtonWorld* const world = m_scene->GetNewton();
int threadCount = NewtonGetThreadsCount(world);
if (threadCount > 0) {
struct GLViewPort
{
int x;
int y;
int width;
int height;
} viewport;
//Retrieves the viewport and stores it in the variable
glGetIntegerv(GL_VIEWPORT, (GLint*) &viewport.x);
glColor3f(1.0, 1.0, 1.0);
glDisable (GL_LIGHTING);
//glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, viewport.width, 0, viewport.height );
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
m_width = viewport.width;
m_height = viewport.height;
float x0 = m_width - 600.0f;
float x1 = x0 + 256.0f;
float y0 = 50.0f;
for (int i = 0; i < threadCount; i ++) {
char label[32];
sprintf (label, "thread %d", i);
DrawLabel (x0 - 90, y0 + i * 22 - 10, label);
}
DrawLabel (x0, y0 - 30, "0.0 ms");
DrawLabel ((x1 + x0) * 0.5f, y0 - 30, "8.33 ms");
DrawLabel (x1, y0 - 30, "16.66 ms");
y0 -= 15.0f;
dVector color (1.0f, 0.0f, 0.0f, 1.0f/8.0f);
DrawRectangle (x0, m_height - (y0 + 20.0f * threadCount), x1 - x0, 20 * threadCount, color);
color = dVector (1.0f, 1.0f, 0.0f, 1.0f/2.0f);
if (threadCount > 1) {
for (int i = 0; i < threadCount; i ++) {
int tick = NewtonReadThreadPerformanceTicks (world, i);
dFloat time = dFloat (tick) * (1.0e-3f * 256.0f / 16.666f);
DrawRectangle(x0, m_height - (y0 + 15), time, 10, color);
y0 += 20.0f;
}
} else {
int tick = NewtonReadPerformanceTicks (world, NEWTON_PROFILER_WORLD_UPDATE);
dFloat time = dFloat (tick) * (1.0e-3f * 256.0f / 16.666f);
DrawRectangle(x0, m_height - (y0 + 15), time, 10, color);
}
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glDisable(GL_BLEND);
glEnable (GL_DEPTH_TEST);
glColor3f(1.0, 1.0, 1.0);
}
}
void DemoEntityManager::RenderFrame ()
{
dTimeTrackerEvent(__FUNCTION__);
// Make context current
if (m_mainWindow->m_suspendVisualUpdates) {
return;
}
dFloat timestep = dGetElapsedSeconds();
m_mainWindow->CalculateFPS(timestep);
// update the the state of all bodies in the scene
unsigned64 time0 = dGetTimeInMicrosenconds ();
UpdatePhysics(timestep);
unsigned64 time1 = dGetTimeInMicrosenconds ();
m_mainThreadPhysicsTime = dFloat ((time1 - time0) / 1000.0f);
// Get the interpolated location of each body in the scene
m_cameraManager->InterpolateMatrices (this, CalculateInteplationParam());
// Our shading model--Goraud (smooth).
glShadeModel (GL_SMOOTH);
// Culling.
glCullFace (GL_BACK);
glFrontFace (GL_CCW);
glEnable (GL_CULL_FACE);
// glEnable(GL_DITHER);
// z buffer test
glEnable(GL_DEPTH_TEST);
glDepthFunc (GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
glClearColor (0.5f, 0.5f, 0.5f, 0.0f );
//glClear( GL_COLOR_BUFFER_BIT );
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// set default lightning
// glDisable(GL_BLEND);
glEnable (GL_LIGHTING);
// make sure the model view matrix is set to identity before setting world space ligh sources
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
dFloat cubeColor[] = { 1.0f, 1.0f, 1.0f, 1.0 };
glMaterialParam(GL_FRONT, GL_SPECULAR, cubeColor);
glMaterialParam(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cubeColor);
glMaterialf(GL_FRONT, GL_SHININESS, 50.0);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
// one light form the Camera eye point
GLfloat lightDiffuse0[] = { 0.5f, 0.5f, 0.5f, 0.0 };
GLfloat lightAmbient0[] = { 0.0f, 0.0f, 0.0f, 0.0 };
dVector camPosition (m_cameraManager->GetCamera()->m_matrix.m_posit);
GLfloat lightPosition0[] = {camPosition.m_x, camPosition.m_y, camPosition.m_z};
glLightfv(GL_LIGHT0, GL_POSITION, lightPosition0);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient0);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse0);
glLightfv(GL_LIGHT0, GL_SPECULAR, lightDiffuse0);
glEnable(GL_LIGHT0);
// set just one directional light
GLfloat lightDiffuse1[] = { 0.7f, 0.7f, 0.7f, 0.0 };
GLfloat lightAmbient1[] = { 0.2f, 0.2f, 0.2f, 0.0 };
GLfloat lightPosition1[] = { -500.0f, 200.0f, 500.0f, 0.0 };
glLightfv(GL_LIGHT1, GL_POSITION, lightPosition1);
glLightfv(GL_LIGHT1, GL_AMBIENT, lightAmbient1);
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightDiffuse1);
glLightfv(GL_LIGHT1, GL_SPECULAR, lightDiffuse1);
glEnable(GL_LIGHT1);
// update Camera
m_cameraManager->GetCamera()->SetViewMatrix(GetWidth(), GetHeight());
// render all entities
if (m_mainWindow->m_hideVisualMeshes) {
if (m_sky) {
glPushMatrix();
m_sky->Render(timestep, this);
glPopMatrix();
}
} else {
for (dListNode* node = dList<DemoEntity*>::GetFirst(); node; node = node->GetNext()) {
DemoEntity* const entity = node->GetInfo();
glPushMatrix();
entity->Render(timestep, this);
glPopMatrix();
}
}
if (m_tranparentHeap.GetCount()) {
dMatrix modelView;
glGetFloat (GL_MODELVIEW_MATRIX, &modelView[0][0]);
while (m_tranparentHeap.GetCount()) {
const TransparentMesh& transparentMesh = m_tranparentHeap[0];
glLoadIdentity();
glLoadMatrix(&transparentMesh.m_matrix[0][0]);
transparentMesh.m_mesh->RenderTransparency();
m_tranparentHeap.Pop();
}
glLoadMatrix(&modelView[0][0]);
}
m_cameraManager->RenderPickedTarget ();
if (m_mainWindow->m_showContactPoints) {
RenderContactPoints (GetNewton());
}
if (m_mainWindow->m_showNormalForces) {
RenderNormalForces (GetNewton());
}
if (m_mainWindow->m_showNormalForces) {
// if (1) {
// see if there is a vehicle controller and
void* const vehListerNode = NewtonWorldGetPreListener(GetNewton(), VEHICLE_PLUGIN_NAME);
if (vehListerNode) {
CustomVehicleControllerManager* const manager = (CustomVehicleControllerManager*)NewtonWorldGetListenerUserData(GetNewton(), vehListerNode);
manager->Debug();
}
void* const characterListerNode = NewtonWorldGetPreListener(GetNewton(), PLAYER_PLUGIN_NAME);
if (characterListerNode) {
CustomPlayerControllerManager* const manager = (CustomPlayerControllerManager*)NewtonWorldGetListenerUserData(GetNewton(), characterListerNode);
manager->Debug();
}
}
if (m_mainWindow->m_showAABB) {
RenderAABB (GetNewton());
}
if (m_mainWindow->m_showCenterOfMass) {
RenderCenterOfMass (GetNewton());
}
if (m_mainWindow->m_showJoints) {
RenderJointsDebugInfo (GetNewton(), 0.5f);
}
DEBUG_DRAW_MODE mode = m_solid;
if (m_mainWindow->m_debugDisplayMode) {
mode = (m_mainWindow->m_debugDisplayMode == 1) ? m_solid : m_lines;
DebugRenderWorldCollision (GetNewton(), mode);
}
if (m_mainWindow->m_showStatistics) {
dVector color (1.0f, 1.0f, 1.0f, 0.0f);
Print (color, 10, 20, "render fps: %7.2f", m_mainWindow->m_fps);
Print (color, 10, 42, "physics time on main thread: %7.2f ms", GetPhysicsTime() * 1000.0f);
Print (color, 10, 64, "total memory: %d kbytes", NewtonGetMemoryUsed() / (1024));
Print (color, 10, 86, "number of bodies: %d", NewtonWorldGetBodyCount(GetNewton()));
Print (color, 10, 108, "number of threads: %d", NewtonGetThreadsCount(GetNewton()));
Print (color, 10, 130, "auto sleep: %s", m_mainWindow->m_autoSleepState ? "on" : "off");
}
int lineNumber = 130 + 22;
if (m_renderHood) {
// set display for 2d render mode
dFloat width = GetWidth();
dFloat height = GetHeight();
glColor3f(1.0, 1.0, 1.0);
glPushMatrix();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// render 2d display
m_renderHood (this, m_renderHoodContext, lineNumber);
// restore display mode
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
// draw everything and swap the display buffer
glFlush();
// Swap
SwapBuffers();
}
int dNewton::GetNumberOfThreads() const
{
return NewtonGetThreadsCount(m_world);
}
unsigned int PhysWorld3D::GetThreadCount() const
{
return NewtonGetThreadsCount(m_world);
}
