/// Utility function you call before something you want to time, so that the
/// recorded times will all be consistent using the viewer's time.
void startTiming(osgViewer::Viewer& viewer, const std::string& name)
{
osg::Timer_t tick = osg::Timer::instance()->tick();
double currentTime = osg::Timer::instance()->delta_s(viewer.getStartTick(), tick);
int framenumber = viewer.getFrameStamp()->getFrameNumber();
viewer.getViewerStats()->setAttribute(framenumber, name + " begin", currentTime);
}
LevelUpdater::LevelUpdater(Level *level) :
_level(level),
_previousStepTime(viewer.getFrameStamp()->getSimulationTime())
{
_blendColor = new osg::BlendColor(osg::Vec4(1, 1, 1, 1));
/*
_level->getShadowedScene()->getOrCreateStateSet()->setAttributeAndModes(_blendColor, osg::StateAttribute::ON);
_level->getShadowedScene()->getOrCreateStateSet()->setMode(GL_ALPHA_TEST, osg::StateAttribute::ON);
_level->getShadowedScene()->getOrCreateStateSet()->setMode(GL_BLEND, osg::StateAttribute::ON);
_level->getShadowedScene()->getOrCreateStateSet()->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
*/
}
void updateUserStats(osgViewer::Viewer& viewer)
{
// Test the custom stats line by just adding up the update and cull
// times for the viewer main camera for the previous frame.
if (viewer.getViewerStats()->collectStats("update") && viewer.getCamera()->getStats()->collectStats("rendering"))
{
// First get the frame number. The code below assumes that
// updateUserStats() is called after advance(), so the frame number
// that will be returned is for the frame that has just started and is
// not rendered yet. The previous frame is framenumber-1, but we can't
// use that frame's timings because it's probably not finished
// rendering yet (in multithreaded viewer modes). So we'll use the
// timings for framenumber-2 for this demo.
int framenumber = viewer.getFrameStamp()->getFrameNumber();
// Get the update time and the viewer main camera's cull time. We use
// getAveragedAttribute() in order to get the actual time elapsed as
// calculated by the stats.
double update = 0.0, cull = 0.0;
viewer.getViewerStats()->getAveragedAttribute("Update traversal time taken", update);
viewer.getCamera()->getStats()->getAveragedAttribute("Cull traversal time taken", cull);
// Get various begin and end times, note these are not elapsed times
// in a frame but rather the simulation time at those moments.
double eventBegin = 0.0, updateBegin = 0.0, cullEnd = 0.0, drawEnd = 0.0;
viewer.getViewerStats()->getAttribute(framenumber-2, "Event traversal begin time", eventBegin);
viewer.getViewerStats()->getAttribute(framenumber-2, "Update traversal begin time", updateBegin);
viewer.getCamera()->getStats()->getAttribute(framenumber-2, "Cull traversal end time", cullEnd);
viewer.getCamera()->getStats()->getAttribute(framenumber-2, "Draw traversal end time", drawEnd);
// This line displays the frame number. It's not averaged, just displayed as is.
viewer.getViewerStats()->setAttribute(framenumber, frameNumberName, framenumber);
// This line displays the frame time (from beginning of event to end of draw). No bars.
viewer.getViewerStats()->setAttribute(framenumber-1, frameTimeName, drawEnd - eventBegin);
// This line displays the sum of update and main camera cull times.
viewer.getViewerStats()->setAttribute(framenumber-1, customTimeName + " time taken", update+cull);
// Since we give begin and end times that correspond to the begin of
// the update phase and the end of the cull phase, the bar in the
// graph will not correspond to the summed times above if something
// happened between update and cull (as in this demo). Also, we need
// to translate the updateBegin and cullEnd times by one frame since
// we're taking the times for framenumber-2 but using them to display
// in the framenumber-1 graph.
viewer.getViewerStats()->setAttribute(framenumber-1, customTimeName + " begin", updateBegin + (1.0/60.0));
viewer.getViewerStats()->setAttribute(framenumber-1, customTimeName + " end", cullEnd + (1.0/60.0));
}
}
/// Utility function you call after something you want to time, so that the
/// recorded times will all be consistent using the viewer's time.
void endTiming(osgViewer::Viewer& viewer, const std::string& name)
{
osg::Timer_t tick = osg::Timer::instance()->tick();
double currentTime = osg::Timer::instance()->delta_s(viewer.getStartTick(), tick);
int framenumber = viewer.getFrameStamp()->getFrameNumber();
viewer.getViewerStats()->setAttribute(framenumber, name + " end", currentTime);
double begin = 0.0;
double elapsed = 0.0;
if (viewer.getViewerStats()->getAttribute(framenumber, name + " begin", begin))
{
elapsed = currentTime - begin;
}
viewer.getViewerStats()->setAttribute(framenumber, name + " time taken", elapsed);
}
void LevelMenuUpdater::operator()(osg::Node *node, osg::NodeVisitor *nv)
{
double currentStepTime = viewer.getFrameStamp()->getSimulationTime();
if(_menu->levelRunning())
{
if(_menu->getCurrentLevel()->playerReachedFinish())
_menu->returnFromLevel();
}
else if(_previousStepTime > 0.0f)
{
_menu->resetCamera();
_menu->getBackground()->postMult(osg::Matrix::rotate(osg::inDegrees((currentStepTime - _previousStepTime) * 20.0f),0.0f,0.0f,1.0f));
}
_previousStepTime = currentStepTime;
}
void LevelUpdater::operator()(osg::Node *node, osg::NodeVisitor *nv)
{
double currentStepTime = viewer.getFrameStamp()->getSimulationTime();
// compensate error arising from the osg::Viewer resetting its SimulationTime
if(currentStepTime - _previousStepTime < 0.0f)
{
Player::getInstance()->resetPosition();
((LazyCameraManipulator *)viewer.getCameraManipulator())->resetCamera();
_previousStepTime = currentStepTime - 0.5;
}
int numSimulationSubSteps = _level->getPhysicsWorld()->stepSimulation(currentStepTime - _previousStepTime,
(int)((currentStepTime - _previousStepTime) * 60.0f) + 1);
((LazyCameraManipulator *)viewer.getCameraManipulator())->setNumSimulationSubSteps(numSimulationSubSteps);
_previousStepTime = currentStepTime;
// player dies when falling too low
{
btVector3 position = Player::getInstance()->getController()->getGhostObject()->getWorldTransform().getOrigin();
int yBucketIndex = (int)(position.y() / 20.0f);
if(yBucketIndex >= _level->getDeadlyAltitudes().size())
yBucketIndex = _level->getDeadlyAltitudes().size() - 1;
float minimum = min(_level->getDeadlyAltitudes()[yBucketIndex],
(_level->getDeadlyAltitudes())[yBucketIndex + 1]);
if(position.z() < (minimum - 5.0f))
_level->playerDied();
}
// fade out when level is finished
osg::Vec4 constantBlendColor = _blendColor->getConstantColor();
float alpha = constantBlendColor.a();
// player reached finish
{
osg::Vec3 position = Player::getInstance()->getPosition();
std::vector<osg::Vec3> finishs = _level->getFinishs();
for(size_t i = 0; i < finishs.size(); i++)
{
float maxDistance = 1.0f;
osg::Vec3 diff = position - finishs[i];
if(diff.x() < maxDistance && diff.x() > -maxDistance &&
diff.y() < maxDistance * 3.0f && diff.y() > -maxDistance &&
diff.z() < maxDistance && diff.z() > -maxDistance)
{
if(alpha == 1.0f)
{
alpha -= 0.01f;
_level->getHeadUpDisplay()->stopTimer();
viewer.getEventHandlers().remove(_level->getKeyboardHandler());
((LazyCameraManipulator *)viewer.getCameraManipulator())->fadeOut();
Player::getInstance()->getPlayerState()->setRequestAccelerate(false);
Player::getInstance()->getPlayerState()->setRequestDecelerate(true);
}
}
}
if(alpha < 1.0f)
{
alpha -= 0.01f;
if(alpha <= 0.0f)
{
alpha = 0.0f;
_level->setReachedFinish(true);
}
constantBlendColor[3] = alpha;
_blendColor->setConstantColor(constantBlendColor);
}
}
traverse(node, nv);
}
int Metrics::run(osgViewer::Viewer& viewer)
{
if (Metrics::enabled())
{
if (!viewer.isRealized())
{
viewer.realize();
}
// If Metrics are enabled, enable stats on the Viewer so that it we can report them for the Metrics
if (Metrics::enabled())
{
osgViewer::ViewerBase::Scenes scenes;
viewer.getScenes(scenes);
for (osgViewer::ViewerBase::Scenes::iterator itr = scenes.begin();
itr != scenes.end();
++itr)
{
osgViewer::Scene* scene = *itr;
osgDB::DatabasePager* dp = scene->getDatabasePager();
if (dp && dp->isRunning())
{
dp->resetStats();
}
}
viewer.getViewerStats()->collectStats("frame_rate", true);
viewer.getViewerStats()->collectStats("event", true);
viewer.getViewerStats()->collectStats("update", true);
viewer.getCamera()->getStats()->collectStats("rendering", true);
viewer.getCamera()->getStats()->collectStats("gpu", true);
}
// Report memory and fps every 10 frames.
unsigned int reportEvery = 10;
while (!viewer.done())
{
{
METRIC_SCOPED_EX("frame", 1, "number", toString<int>(viewer.getFrameStamp()->getFrameNumber()).c_str());
{
METRIC_SCOPED("advance");
viewer.advance();
}
{
METRIC_SCOPED("event");
viewer.eventTraversal();
}
{
METRIC_SCOPED("update");
viewer.updateTraversal();
}
{
METRIC_SCOPED("render");
viewer.renderingTraversals();
}
}
// Report memory and fps periodically. periodically.
if (viewer.getFrameStamp()->getFrameNumber() % reportEvery == 0)
{
// Only report the metrics if they are enabled to avoid computing the memory.
if (Metrics::enabled())
{
Metrics::counter("Memory::WorkingSet", "WorkingSet", Memory::getProcessPhysicalUsage() / 1048576);
Metrics::counter("Memory::PrivateBytes", "PrivateBytes", Memory::getProcessPrivateUsage() / 1048576);
Metrics::counter("Memory::PeakPrivateBytes", "PeakPrivateBytes", Memory::getProcessPeakPrivateUsage() / 1048576);
}
}
double eventTime = 0.0;
if (viewer.getViewerStats()->getAttribute(viewer.getViewerStats()->getLatestFrameNumber(), "Event traversal time taken", eventTime))
{
Metrics::counter("Viewer::Event", "Event", eventTime * 1000.0);
}
double updateTime = 0.0;
if (viewer.getViewerStats()->getAttribute(viewer.getViewerStats()->getLatestFrameNumber(), "Update traversal time taken", updateTime))
{
Metrics::counter("Viewer::Update", "Update", updateTime * 1000.0);
}
double cullTime = 0.0;
if (viewer.getCamera()->getStats()->getAttribute(viewer.getCamera()->getStats()->getLatestFrameNumber(), "Cull traversal time taken", cullTime))
{
Metrics::counter("Viewer::Cull", "Cull", cullTime * 1000.0);
}
double drawTime = 0.0;
if (viewer.getCamera()->getStats()->getAttribute(viewer.getCamera()->getStats()->getLatestFrameNumber(), "Draw traversal time taken", drawTime))
{
Metrics::counter("Viewer::Draw", "Draw", drawTime * 1000.0);
}
double gpuTime = 0.0;
if (viewer.getCamera()->getStats()->getAttribute(viewer.getCamera()->getStats()->getLatestFrameNumber()-1, "GPU draw time taken", gpuTime))
{
Metrics::counter("Viewer::GPU", "GPU", gpuTime * 1000.0);
}
double frameRate = 0.0;
if (viewer.getViewerStats()->getAttribute(viewer.getViewerStats()->getLatestFrameNumber() - 1, "Frame rate", frameRate))
{
Metrics::counter("Viewer::FPS", "FPS", frameRate);
}
}
return 0;
}
else
{
return viewer.run();
}
}