//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); }