490 lines
17 KiB
C++
490 lines
17 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
|
|
*
|
|
* This application is open source and may be redistributed and/or modified
|
|
* freely and without restriction, both in commericial and non commericial applications,
|
|
* as long as this copyright notice is maintained.
|
|
*
|
|
* This application is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
#include <osgDB/ReadFile>
|
|
#include <osgUtil/Optimizer>
|
|
#include <osg/CoordinateSystemNode>
|
|
|
|
#include <osg/Switch>
|
|
#include <osgText/Text>
|
|
|
|
#include <osgViewer/Viewer>
|
|
|
|
#include <osgGA/TrackballManipulator>
|
|
#include <osgGA/FlightManipulator>
|
|
#include <osgGA/DriveManipulator>
|
|
#include <osgGA/KeySwitchMatrixManipulator>
|
|
#include <osgGA/StateSetManipulator>
|
|
#include <osgGA/AnimationPathManipulator>
|
|
#include <osgGA/TerrainManipulator>
|
|
|
|
#include <iostream>
|
|
|
|
class ThreadingHandler : public osgGA::GUIEventHandler
|
|
{
|
|
public:
|
|
|
|
ThreadingHandler() {}
|
|
|
|
bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
|
|
{
|
|
osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>(&aa);
|
|
if (!viewer) return false;
|
|
|
|
switch(ea.getEventType())
|
|
{
|
|
case(osgGA::GUIEventAdapter::KEYUP):
|
|
{
|
|
if (ea.getKey()=='m')
|
|
{
|
|
switch(viewer->getThreadingModel())
|
|
{
|
|
case(osgViewer::Viewer::SingleThreaded):
|
|
viewer->setThreadingModel(osgViewer::Viewer::ThreadPerContext);
|
|
osg::notify(osg::NOTICE)<<"Threading model 'ThreadPerContext' selected."<<std::endl;
|
|
break;
|
|
case(osgViewer::Viewer::ThreadPerContext):
|
|
viewer->setThreadingModel(osgViewer::Viewer::ThreadPerCamera);
|
|
osg::notify(osg::NOTICE)<<"Threading model 'ThreadPerCamera' selected."<<std::endl;
|
|
break;
|
|
case(osgViewer::Viewer::ThreadPerCamera):
|
|
viewer->setThreadingModel(osgViewer::Viewer::SingleThreaded);
|
|
osg::notify(osg::NOTICE)<<"Threading model 'SingleTheaded' selected."<<std::endl;
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
if (ea.getKey()=='e')
|
|
{
|
|
switch(viewer->getEndBarrierPosition())
|
|
{
|
|
case(osgViewer::Viewer::BeforeSwapBuffers):
|
|
viewer->setEndBarrierPosition(osgViewer::Viewer::AfterSwapBuffers);
|
|
osg::notify(osg::NOTICE)<<"Threading model 'AfterSwapBuffers' selected."<<std::endl;
|
|
break;
|
|
case(osgViewer::Viewer::AfterSwapBuffers):
|
|
viewer->setEndBarrierPosition(osgViewer::Viewer::BeforeSwapBuffers);
|
|
osg::notify(osg::NOTICE)<<"Threading model 'BeforeSwapBuffers' selected."<<std::endl;
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
default: break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool _done;
|
|
};
|
|
|
|
class StatsHandler : public osgGA::GUIEventHandler
|
|
{
|
|
public:
|
|
|
|
StatsHandler():
|
|
_statsType(NO_STATS),
|
|
_frameRateChildNum(0),
|
|
_viewerChildNum(0),
|
|
_sceneChildNum(0) {}
|
|
|
|
enum StatsType
|
|
{
|
|
NO_STATS = 0,
|
|
FRAME_RATE = 1,
|
|
VIEWER_STATS = 2,
|
|
SCENE_STATS = 3,
|
|
LAST = 4
|
|
};
|
|
|
|
bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
|
|
{
|
|
osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>(&aa);
|
|
if (!viewer) return false;
|
|
|
|
switch(ea.getEventType())
|
|
{
|
|
case(osgGA::GUIEventAdapter::KEYDOWN):
|
|
{
|
|
if (ea.getKey()=='s')
|
|
{
|
|
if (viewer->getStats())
|
|
{
|
|
if (!_camera.valid())
|
|
{
|
|
setUpCamera(viewer);
|
|
setUpScene(viewer);
|
|
}
|
|
|
|
++_statsType;
|
|
|
|
if (_statsType==LAST) _statsType = NO_STATS;
|
|
|
|
switch(_statsType)
|
|
{
|
|
case(NO_STATS):
|
|
{
|
|
_camera->setNodeMask(0x0);
|
|
_switch->setAllChildrenOff();
|
|
break;
|
|
}
|
|
case(FRAME_RATE):
|
|
{
|
|
_camera->setNodeMask(0xffffffff);
|
|
_switch->setValue(_frameRateChildNum, true);
|
|
break;
|
|
}
|
|
case(VIEWER_STATS):
|
|
{
|
|
_camera->setNodeMask(0xffffffff);
|
|
_switch->setValue(_viewerChildNum, true);
|
|
break;
|
|
}
|
|
case(SCENE_STATS):
|
|
{
|
|
_switch->setValue(_sceneChildNum, true);
|
|
_camera->setNodeMask(0xffffffff);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
return true;
|
|
}
|
|
if (ea.getKey()=='S')
|
|
{
|
|
if (viewer->getStats())
|
|
{
|
|
viewer->getStats()->report(osg::notify(osg::NOTICE));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
case(osgGA::GUIEventAdapter::FRAME):
|
|
{
|
|
update(viewer);
|
|
return true;
|
|
}
|
|
default: break;
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
void setUpCamera(osgViewer::Viewer* viewer)
|
|
{
|
|
osgViewer::Viewer::Windows windows;
|
|
viewer->getWindows(windows);
|
|
|
|
if (windows.empty()) return;
|
|
|
|
osgViewer::GraphicsWindow* window = windows.front();
|
|
|
|
_camera = new osg::Camera;
|
|
_camera->setGraphicsContext(window);
|
|
_camera->setViewport(0, 0, window->getTraits()->width, window->getTraits()->height);
|
|
|
|
_camera->setProjectionMatrix(osg::Matrix::ortho2D(0,1280,0,1024));
|
|
_camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
|
|
_camera->setViewMatrix(osg::Matrix::identity());
|
|
|
|
// only clear the depth buffer
|
|
_camera->setClearMask(0);
|
|
|
|
viewer->setUpRenderingSupport();
|
|
}
|
|
|
|
struct TextDrawCallback : public virtual osg::Drawable::DrawCallback
|
|
{
|
|
TextDrawCallback(osg::Stats* stats, const std::string name, int frameDelta):
|
|
_stats(stats),
|
|
_attributeName(name),
|
|
_frameDelta(frameDelta) {}
|
|
|
|
/** do customized draw code.*/
|
|
virtual void drawImplementation(osg::RenderInfo& renderInfo,const osg::Drawable* drawable) const
|
|
{
|
|
osgText::Text* text = (osgText::Text*)drawable;
|
|
|
|
int frameNumber = renderInfo.getState()->getFrameStamp()->getFrameNumber();
|
|
|
|
double value;
|
|
if (_stats->getAttribute( frameNumber+_frameDelta, _attributeName, value))
|
|
{
|
|
sprintf(_tmpText,"%4.2f",value);
|
|
text->setText(_tmpText);
|
|
}
|
|
|
|
text->drawImplementation(renderInfo);
|
|
}
|
|
|
|
osg::Stats* _stats;
|
|
std::string _attributeName;
|
|
int _frameDelta;
|
|
mutable char _tmpText[128];
|
|
};
|
|
|
|
void setUpScene(osgViewer::Viewer* viewer)
|
|
{
|
|
_switch = new osg::Switch;
|
|
_camera->addChild(_switch.get());
|
|
|
|
osg::StateSet* stateset = _switch->getOrCreateStateSet();
|
|
stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
|
|
stateset->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
|
|
|
|
std::string font("fonts/arial.ttf");
|
|
|
|
float leftPos = 10.0f;
|
|
float characterSize = 20.0f;
|
|
|
|
osg::Vec3 pos(leftPos,1000.0f,0.0f);
|
|
|
|
osg::Vec4 colorFR(1.0f,1.0f,1.0f,1.0f);
|
|
osg::Vec4 colorUpdate( 0.0f,1.0f,0.0f,1.0f);
|
|
osg::Vec4 colorCull( 0.0f,1.0f,1.0f,1.0f);
|
|
osg::Vec4 colorDraw( 1.0f,1.0f,0.0f,1.0f);
|
|
osg::Vec4 colorGPU( 1.0f,0.5f,0.0f,1.0f);
|
|
|
|
|
|
// frame rate stats
|
|
{
|
|
osg::Geode* geode = new osg::Geode();
|
|
|
|
std::string font("fonts/arial.ttf");
|
|
|
|
// turn lighting off for the text and disable depth test to ensure its always ontop.
|
|
|
|
{
|
|
_frameRateLabel = new osgText::Text;
|
|
geode->addDrawable( _frameRateLabel.get() );
|
|
|
|
_frameRateLabel->setColor(colorFR);
|
|
_frameRateLabel->setFont(font);
|
|
_frameRateLabel->setCharacterSize(characterSize);
|
|
_frameRateLabel->setPosition(pos);
|
|
_frameRateLabel->setText("Frame Rate: ");
|
|
|
|
pos.x() = _frameRateLabel->getBound().xMax();
|
|
|
|
_frameRateValue = new osgText::Text;
|
|
geode->addDrawable( _frameRateValue.get() );
|
|
|
|
_frameRateValue->setColor(colorFR);
|
|
_frameRateValue->setFont(font);
|
|
_frameRateValue->setCharacterSize(characterSize);
|
|
_frameRateValue->setPosition(pos);
|
|
_frameRateValue->setText("0.0");
|
|
|
|
_frameRateValue->setDrawCallback(new TextDrawCallback(viewer->getStats(),"Frame rate",-1));
|
|
|
|
pos.y() -= characterSize*1.5f;
|
|
;
|
|
}
|
|
|
|
_frameRateChildNum = _switch->getNumChildren();
|
|
_switch->addChild(geode, false);
|
|
}
|
|
|
|
|
|
// viewer stats
|
|
{
|
|
pos.x() = leftPos;
|
|
|
|
osg::Geode* geode = new osg::Geode();
|
|
|
|
{
|
|
osgText::Text* text = new osgText::Text;
|
|
geode->addDrawable( text );
|
|
|
|
text->setFont(font);
|
|
text->setPosition(pos);
|
|
text->setText("Viewer Stats ");
|
|
|
|
pos.y() -= characterSize*1.5f;
|
|
}
|
|
|
|
_viewerChildNum = _switch->getNumChildren();
|
|
_switch->addChild(geode, false);
|
|
}
|
|
|
|
// scene stats
|
|
{
|
|
pos.x() = leftPos;
|
|
|
|
osg::Geode* geode = new osg::Geode();
|
|
|
|
{
|
|
osgText::Text* text = new osgText::Text;
|
|
geode->addDrawable( text );
|
|
|
|
text->setFont(font);
|
|
text->setPosition(pos);
|
|
text->setText("Scene Stats ");
|
|
|
|
pos.y() -= characterSize*1.5f;
|
|
}
|
|
|
|
_sceneChildNum = _switch->getNumChildren();
|
|
_switch->addChild(geode, false);
|
|
}
|
|
}
|
|
|
|
void update(osgViewer::Viewer* viewer)
|
|
{
|
|
return ;
|
|
|
|
osg::Stats* stats = viewer->getStats();
|
|
if (!stats || _statsType==NO_STATS) return;
|
|
|
|
int frameNumber = viewer->getFrameStamp()->getFrameNumber();
|
|
|
|
char tmpText[128];
|
|
double frameRate = 0.0;
|
|
|
|
osg::Timer_t startTick = osg::Timer::instance()->tick();
|
|
if (stats->getAttribute(frameNumber-1, "Frame rate", frameRate))
|
|
{
|
|
sprintf(tmpText,"%4.2f",frameRate);
|
|
_frameRateValue->setText(tmpText);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
int _statsType;
|
|
osg::ref_ptr<osg::Camera> _camera;
|
|
osg::ref_ptr<osg::Switch> _switch;
|
|
|
|
unsigned int _frameRateChildNum;
|
|
osg::ref_ptr<osgText::Text> _frameRateLabel;
|
|
osg::ref_ptr<osgText::Text> _frameRateValue;
|
|
|
|
unsigned int _viewerChildNum;
|
|
|
|
unsigned int _sceneChildNum;
|
|
|
|
};
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
// use an ArgumentParser object to manage the program arguments.
|
|
osg::ArgumentParser arguments(&argc,argv);
|
|
|
|
arguments.getApplicationUsage()->setApplicationName(arguments.getApplicationName());
|
|
arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the standard OpenSceneGraph example which loads and visualises 3d models.");
|
|
arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
|
|
arguments.getApplicationUsage()->addCommandLineOption("--image <filename>","Load an image and render it on a quad");
|
|
arguments.getApplicationUsage()->addCommandLineOption("--dem <filename>","Load an image/DEM and render it on a HeightField");
|
|
arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display command line parameters");
|
|
arguments.getApplicationUsage()->addCommandLineOption("--help-env","Display environmental variables available");
|
|
arguments.getApplicationUsage()->addCommandLineOption("--help-keys","Display keyboard & mouse bindings available");
|
|
arguments.getApplicationUsage()->addCommandLineOption("--help-all","Display all command line, env vars and keyboard & mouse bindings.");
|
|
|
|
// if user request help write it out to cout.
|
|
bool helpAll = arguments.read("--help-all");
|
|
unsigned int helpType = ((helpAll || arguments.read("-h") || arguments.read("--help"))? osg::ApplicationUsage::COMMAND_LINE_OPTION : 0 ) |
|
|
((helpAll || arguments.read("--help-env"))? osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE : 0 ) |
|
|
((helpAll || arguments.read("--help-keys"))? osg::ApplicationUsage::KEYBOARD_MOUSE_BINDING : 0 );
|
|
if (helpType)
|
|
{
|
|
arguments.getApplicationUsage()->write(std::cout, helpType);
|
|
return 1;
|
|
}
|
|
|
|
// report any errors if they have occurred when parsing the program arguments.
|
|
if (arguments.errors())
|
|
{
|
|
arguments.writeErrorMessages(std::cout);
|
|
return 1;
|
|
}
|
|
|
|
if (arguments.argc()<=1)
|
|
{
|
|
arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
|
|
return 1;
|
|
}
|
|
|
|
osgViewer::Viewer viewer;
|
|
|
|
// set up the camera manipulators.
|
|
{
|
|
osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator = new osgGA::KeySwitchMatrixManipulator;
|
|
|
|
keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new osgGA::TrackballManipulator() );
|
|
keyswitchManipulator->addMatrixManipulator( '2', "Flight", new osgGA::FlightManipulator() );
|
|
keyswitchManipulator->addMatrixManipulator( '3', "Drive", new osgGA::DriveManipulator() );
|
|
keyswitchManipulator->addMatrixManipulator( '4', "Terrain", new osgGA::TerrainManipulator() );
|
|
|
|
std::string pathfile;
|
|
char keyForAnimationPath = '5';
|
|
while (arguments.read("-p",pathfile))
|
|
{
|
|
osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
|
|
if (apm || !apm->valid())
|
|
{
|
|
unsigned int num = keyswitchManipulator->getNumMatrixManipulators();
|
|
keyswitchManipulator->addMatrixManipulator( keyForAnimationPath, "Path", apm );
|
|
keyswitchManipulator->selectMatrixManipulator(num);
|
|
++keyForAnimationPath;
|
|
}
|
|
}
|
|
|
|
viewer.setCameraManipulator( keyswitchManipulator.get() );
|
|
}
|
|
|
|
// add the state manipulator
|
|
{
|
|
osg::ref_ptr<osgGA::StateSetManipulator> statesetManipulator = new osgGA::StateSetManipulator;
|
|
statesetManipulator->setStateSet(viewer.getCamera()->getOrCreateStateSet());
|
|
|
|
viewer.addEventHandler( statesetManipulator.get() );
|
|
}
|
|
|
|
// add the thread model handler
|
|
viewer.addEventHandler(new ThreadingHandler);
|
|
|
|
// add the stats handler
|
|
viewer.addEventHandler(new StatsHandler);
|
|
|
|
// load the data
|
|
osg::ref_ptr<osg::Node> loadedModel = osgDB::readNodeFiles(arguments);
|
|
if (!loadedModel)
|
|
{
|
|
std::cout << arguments.getApplicationName() <<": No data loaded" << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
// any option left unread are converted into errors to write out later.
|
|
arguments.reportRemainingOptionsAsUnrecognized();
|
|
|
|
// report any errors if they have occurred when parsing the program arguments.
|
|
if (arguments.errors())
|
|
{
|
|
arguments.writeErrorMessages(std::cout);
|
|
return 1;
|
|
}
|
|
|
|
|
|
// optimize the scene graph, remove redundant nodes and state etc.
|
|
osgUtil::Optimizer optimizer;
|
|
optimizer.optimize(loadedModel.get());
|
|
|
|
viewer.setSceneData( loadedModel.get() );
|
|
|
|
return viewer.run();
|
|
}
|