dd996a3289
forcing users to use osgDB::readRef*File() methods. The later is preferable as it closes a potential threading bug when using paging databases in conjunction
with the osgDB::Registry Object Cache. This threading bug occurs when one thread gets an object from the Cache via an osgDB::read*File() call where only
a pointer to the object is passed back, so taking a reference to the object is delayed till it gets reassigned to a ref_ptr<>, but at the same time another
thread calls a flush of the Object Cache deleting this object as it's referenceCount is now zero. Using osgDB::readREf*File() makes sure the a ref_ptr<> is
passed back and the referenceCount never goes to zero.
To ensure the OSG builds when OSG_PROVIDE_READFILE is to OFF the many cases of osgDB::read*File() usage had to be replaced with a ref_ptr<> osgDB::readRef*File()
usage. The avoid this change causing lots of other client code to be rewritten to handle the use of ref_ptr<> in place of C pointer I introduced a serious of
templte methods in various class to adapt ref_ptr<> to the underly C pointer to be passed to old OSG API's, example of this is found in include/osg/Group:
bool addChild(Node* child); // old method which can only be used with a Node*
tempalte<class T> bool addChild(const osg::ref_ptr<T>& child) { return addChild(child.get()); } // adapter template method
These changes together cover 149 modified files, so it's a large submission. This extent of changes are warrent to make use of the Object Cache
and multi-threaded loaded more robust.
git-svn-id: http://svn.openscenegraph.org/osg/OpenSceneGraph/trunk@15164 16af8721-9629-0410-8352-f15c8da7e697
356 lines
12 KiB
C++
356 lines
12 KiB
C++
/* OpenSceneGraph example, osgcamera.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include <osgDB/ReadFile>
|
|
#include <osgDB/WriteFile>
|
|
#include <osgViewer/Viewer>
|
|
#include <osgViewer/ViewerEventHandlers>
|
|
#include <osgGA/TrackballManipulator>
|
|
#include <osgGA/FlightManipulator>
|
|
#include <osgGA/AnimationPathManipulator>
|
|
#include <iostream>
|
|
|
|
class ModelHandler : public osgGA::GUIEventHandler
|
|
{
|
|
public:
|
|
|
|
ModelHandler():
|
|
_position(0) {}
|
|
|
|
typedef std::vector<std::string> Filenames;
|
|
Filenames _filenames;
|
|
unsigned int _position;
|
|
|
|
void add(const std::string& filename) { _filenames.push_back(filename); }
|
|
|
|
bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
|
|
{
|
|
osgViewer::Viewer* viewer = dynamic_cast<osgViewer::Viewer*>(&aa);
|
|
if (!viewer) return false;
|
|
|
|
if (_filenames.empty()) return false;
|
|
|
|
switch(ea.getEventType())
|
|
{
|
|
case(osgGA::GUIEventAdapter::KEYUP):
|
|
{
|
|
if (ea.getKey()=='l')
|
|
{
|
|
osg::ref_ptr<osg::Node> model = osgDB::readRefNodeFile( _filenames[_position] );
|
|
++_position;
|
|
if (_position>=_filenames.size()) _position = 0;
|
|
|
|
if (model.valid())
|
|
{
|
|
viewer->setSceneData(model.get());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
default: break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool _done;
|
|
};
|
|
|
|
|
|
void singleWindowMultipleCameras(osgViewer::Viewer& viewer)
|
|
{
|
|
osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
|
|
if (!wsi)
|
|
{
|
|
osg::notify(osg::NOTICE)<<"Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
|
|
return;
|
|
}
|
|
|
|
unsigned int width, height;
|
|
wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
|
|
|
|
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
|
|
traits->x = 0;
|
|
traits->y = 0;
|
|
traits->width = width;
|
|
traits->height = height;
|
|
traits->windowDecoration = true;
|
|
traits->doubleBuffer = true;
|
|
traits->sharedContext = 0;
|
|
|
|
osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
|
|
if (gc.valid())
|
|
{
|
|
osg::notify(osg::INFO)<<" GraphicsWindow has been created successfully."<<std::endl;
|
|
|
|
// need to ensure that the window is cleared make sure that the complete window is set the correct colour
|
|
// rather than just the parts of the window that are under the camera's viewports
|
|
gc->setClearColor(osg::Vec4f(0.2f,0.2f,0.6f,1.0f));
|
|
gc->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
else
|
|
{
|
|
osg::notify(osg::NOTICE)<<" GraphicsWindow has not been created successfully."<<std::endl;
|
|
}
|
|
|
|
unsigned int numCameras = 2;
|
|
double aspectRatioScale = 1.0;///(double)numCameras;
|
|
for(unsigned int i=0; i<numCameras;++i)
|
|
{
|
|
osg::ref_ptr<osg::Camera> camera = new osg::Camera;
|
|
camera->setGraphicsContext(gc.get());
|
|
camera->setViewport(new osg::Viewport((i*width)/numCameras,(i*height)/numCameras, width/numCameras, height/numCameras));
|
|
GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;
|
|
camera->setDrawBuffer(buffer);
|
|
camera->setReadBuffer(buffer);
|
|
|
|
viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd::scale(aspectRatioScale,1.0,1.0));
|
|
}
|
|
}
|
|
|
|
void multipleWindowMultipleCameras(osgViewer::Viewer& viewer, bool multipleScreens)
|
|
{
|
|
osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
|
|
if (!wsi)
|
|
{
|
|
osg::notify(osg::NOTICE)<<"Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
|
|
return;
|
|
}
|
|
|
|
unsigned int width, height;
|
|
wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
|
|
|
|
|
|
unsigned int numCameras = 6;
|
|
double aspectRatioScale = (double)numCameras;
|
|
double translate_x = double(numCameras)-1;
|
|
for(unsigned int i=0; i<numCameras;++i, translate_x -= 2.0)
|
|
{
|
|
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
|
|
traits->screenNum = multipleScreens ? i / 3 : 0;
|
|
traits->x = (i*width)/numCameras;
|
|
traits->y = 0;
|
|
traits->width = width/numCameras-1;
|
|
traits->height = height;
|
|
traits->windowDecoration = true;
|
|
traits->doubleBuffer = true;
|
|
traits->sharedContext = 0;
|
|
|
|
osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
|
|
if (gc.valid())
|
|
{
|
|
osg::notify(osg::INFO)<<" GraphicsWindow has been created successfully."<<std::endl;
|
|
}
|
|
else
|
|
{
|
|
osg::notify(osg::NOTICE)<<" GraphicsWindow has not been created successfully."<<std::endl;
|
|
}
|
|
|
|
osg::ref_ptr<osg::Camera> camera = new osg::Camera;
|
|
camera->setGraphicsContext(gc.get());
|
|
camera->setViewport(new osg::Viewport(0,0, width/numCameras, height));
|
|
GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;
|
|
camera->setDrawBuffer(buffer);
|
|
camera->setReadBuffer(buffer);
|
|
|
|
viewer.addSlave(camera.get(), osg::Matrix::scale(aspectRatioScale, 1.0, 1.0)*osg::Matrix::translate(translate_x, 0.0, 0.0), osg::Matrix() );
|
|
}
|
|
}
|
|
|
|
class EnableVBOVisitor : public osg::NodeVisitor
|
|
{
|
|
public:
|
|
EnableVBOVisitor():
|
|
osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) {}
|
|
|
|
void apply(osg::Geode& geode)
|
|
{
|
|
for(unsigned int i=0; i<geode.getNumDrawables();++i)
|
|
{
|
|
osg::Geometry* geom = geode.getDrawable(i)->asGeometry();
|
|
if (geom)
|
|
{
|
|
osg::notify(osg::NOTICE)<<"Enabling VBO"<<std::endl;
|
|
geom->setUseVertexBufferObjects(true);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
int main( int argc, char **argv )
|
|
{
|
|
// use an ArgumentParser object to manage the program arguments.
|
|
osg::ArgumentParser arguments(&argc,argv);
|
|
|
|
if (argc<2)
|
|
{
|
|
std::cout << argv[0] <<": requires filename argument." << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
unsigned int numRepeats = 2;
|
|
if (arguments.read("--repeat",numRepeats) || arguments.read("-r",numRepeats) || arguments.read("--repeat") || arguments.read("-r"))
|
|
{
|
|
|
|
bool sharedModel = arguments.read("--shared");
|
|
bool enableVBO = arguments.read("--vbo");
|
|
|
|
osg::ref_ptr<osg::Node> model;
|
|
if (sharedModel)
|
|
{
|
|
model = osgDB::readRefNodeFiles(arguments);
|
|
if (!model) return 0;
|
|
|
|
if (enableVBO)
|
|
{
|
|
EnableVBOVisitor enableVBOs;
|
|
model->accept(enableVBOs);
|
|
}
|
|
}
|
|
|
|
osgViewer::Viewer::ThreadingModel threadingModel = osgViewer::Viewer::AutomaticSelection;
|
|
while (arguments.read("-s")) { threadingModel = osgViewer::Viewer::SingleThreaded; }
|
|
while (arguments.read("-g")) { threadingModel = osgViewer::Viewer::CullDrawThreadPerContext; }
|
|
while (arguments.read("-d")) { threadingModel = osgViewer::Viewer::DrawThreadPerContext; }
|
|
while (arguments.read("-c")) { threadingModel = osgViewer::Viewer::CullThreadPerCameraDrawThreadPerContext; }
|
|
|
|
for(unsigned int i=0; i<numRepeats; ++i)
|
|
{
|
|
osg::notify(osg::NOTICE)<<"+++++++++++++ New viewer ++++++++++++"<<std::endl;
|
|
|
|
{
|
|
osgViewer::Viewer viewer;
|
|
|
|
viewer.setThreadingModel(threadingModel);
|
|
|
|
if (sharedModel) viewer.setSceneData(model.get());
|
|
else
|
|
{
|
|
osg::ref_ptr<osg::Node> node = osgDB::readRefNodeFiles(arguments);
|
|
if (!node) return 0;
|
|
|
|
if (enableVBO)
|
|
{
|
|
EnableVBOVisitor enableVBOs;
|
|
node->accept(enableVBOs);
|
|
}
|
|
|
|
viewer.setSceneData(node.get());
|
|
}
|
|
|
|
viewer.run();
|
|
}
|
|
|
|
osg::notify(osg::NOTICE)<<"------------ Viewer ended ----------"<<std::endl<<std::endl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
std::string pathfile;
|
|
osg::ref_ptr<osgGA::AnimationPathManipulator> apm = 0;
|
|
while (arguments.read("-p",pathfile))
|
|
{
|
|
apm = new osgGA::AnimationPathManipulator(pathfile);
|
|
if (!apm.valid() || !(apm->valid()) )
|
|
{
|
|
apm = 0;
|
|
}
|
|
}
|
|
|
|
osgViewer::Viewer viewer(arguments);
|
|
|
|
while (arguments.read("-s")) { viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded); }
|
|
while (arguments.read("-g")) { viewer.setThreadingModel(osgViewer::Viewer::CullDrawThreadPerContext); }
|
|
while (arguments.read("-d")) { viewer.setThreadingModel(osgViewer::Viewer::DrawThreadPerContext); }
|
|
while (arguments.read("-c")) { viewer.setThreadingModel(osgViewer::Viewer::CullThreadPerCameraDrawThreadPerContext); }
|
|
|
|
bool limitNumberOfFrames = false;
|
|
unsigned int maxFrames = 10;
|
|
while (arguments.read("--run-till-frame-number",maxFrames)) { limitNumberOfFrames = true; }
|
|
|
|
// alternative viewer window setups.
|
|
while (arguments.read("-1")) { singleWindowMultipleCameras(viewer); }
|
|
while (arguments.read("-2")) { multipleWindowMultipleCameras(viewer, false); }
|
|
while (arguments.read("-3")) { multipleWindowMultipleCameras(viewer, true); }
|
|
|
|
if (apm.valid()) viewer.setCameraManipulator(apm.get());
|
|
else viewer.setCameraManipulator( new osgGA::TrackballManipulator() );
|
|
|
|
viewer.addEventHandler(new osgViewer::StatsHandler);
|
|
viewer.addEventHandler(new osgViewer::ThreadingHandler);
|
|
|
|
std::string configfile;
|
|
while (arguments.read("--config", configfile))
|
|
{
|
|
osg::notify(osg::NOTICE)<<"Trying to read config file "<<configfile<<std::endl;
|
|
osg::ref_ptr<osg::Object> object = osgDB::readRefObjectFile(configfile);
|
|
osgViewer::View* view = dynamic_cast<osgViewer::View*>(object.get());
|
|
if (view)
|
|
{
|
|
osg::notify(osg::NOTICE)<<"Read config file successfully"<<std::endl;
|
|
}
|
|
else
|
|
{
|
|
osg::notify(osg::NOTICE)<<"Failed to read config file : "<<configfile<<std::endl;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
while (arguments.read("--write-config", configfile)) { osgDB::writeObjectFile(viewer, configfile); }
|
|
|
|
|
|
if (arguments.read("-m"))
|
|
{
|
|
ModelHandler* modelHandler = new ModelHandler;
|
|
for(int i=1; i<arguments.argc();++i)
|
|
{
|
|
modelHandler->add(arguments[i]);
|
|
}
|
|
|
|
viewer.addEventHandler(modelHandler);
|
|
}
|
|
else
|
|
{
|
|
// load the scene.
|
|
osg::ref_ptr<osg::Node> loadedModel = osgDB::readRefNodeFiles(arguments);
|
|
|
|
if (!loadedModel) loadedModel = osgDB::readRefNodeFile("cow.osgt");
|
|
|
|
if (!loadedModel)
|
|
{
|
|
std::cout << argv[0] <<": No data loaded." << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
viewer.setSceneData(loadedModel);
|
|
}
|
|
|
|
viewer.realize();
|
|
|
|
unsigned int numFrames = 0;
|
|
while(!viewer.done() && !(limitNumberOfFrames && numFrames>=maxFrames))
|
|
{
|
|
viewer.frame();
|
|
++numFrames;
|
|
}
|
|
|
|
return 0;
|
|
}
|