root/OpenSceneGraph/trunk/examples/osgsimulation/osgsimulation.cpp @ 5959

Revision 5959, 13.3 kB (checked in by robert, 7 years ago)

Ported follow examples to osgViewer:

osgshape
osgsimplifier
osgsimulation
osgslice
osgspacewarp
osgspheresegment
osgspotlight
osgstereoimage

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#ifdef WIN32
2/////////////////////////////////////////////////////////////////////////////
3// Disable unavoidable warning messages:
4
5//  4103: used #pragma pack to change alignment
6//  4114: same type qualifier used more than once
7//  4201: nonstandard extension used : nameless struct/union
8//  4237: "keyword" reserved for future use
9//  4251: class needs to have dll-interface to export class
10//  4275: non DLL-interface class used as base for DLL-interface class
11//  4290: C++ Exception Specification ignored
12//  4503: decorated name length exceeded, name was truncated
13//  4786: string too long - truncated to 255 characters
14
15#pragma warning(disable : 4103 4114 4201 4237 4251 4275 4290 4503 4335 4786)
16
17#endif // WIN32
18
19#include <osgViewer/Viewer>
20
21#include <osg/Group>
22#include <osg/Geode>
23#include <osg/ShapeDrawable>
24#include <osg/Texture2D>
25#include <osg/PositionAttitudeTransform>
26#include <osg/MatrixTransform>
27#include <osg/CoordinateSystemNode>
28
29#include <osgDB/FileUtils>
30#include <osgDB/ReadFile>
31
32#include <osgText/Text>
33
34#include <osgTerrain/DataSet>
35
36#include <osgSim/OverlayNode>
37#include <osgSim/SphereSegment>
38
39#include <osgGA/NodeTrackerManipulator>
40
41#include <iostream>
42
43class MyGraphicsContext {
44    public:
45        MyGraphicsContext()
46        {
47            osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
48            traits->x = 0;
49            traits->y = 0;
50            traits->width = 1;
51            traits->height = 1;
52            traits->windowDecoration = false;
53            traits->doubleBuffer = false;
54            traits->sharedContext = 0;
55            traits->pbuffer = true;
56
57            _gc = osg::GraphicsContext::createGraphicsContext(traits.get());
58
59            if (!_gc)
60            {
61                osg::notify(osg::NOTICE)<<"Failed to create pbuffer, failing back to normal graphics window."<<std::endl;
62               
63                traits->pbuffer = false;
64                _gc = osg::GraphicsContext::createGraphicsContext(traits.get());
65            }
66
67            if (_gc.valid())
68           
69           
70            {
71                _gc->realize();
72                _gc->makeCurrent();
73                std::cout<<"Realized window"<<std::endl;
74            }
75        }
76       
77        bool valid() const { return _gc.valid() && _gc->isRealized(); }
78       
79    private:
80        osg::ref_ptr<osg::GraphicsContext> _gc;
81};
82
83osg::Node* createEarth()
84{
85    osg::ref_ptr<osg::Node> scene;
86   
87    {
88        std::string filename = osgDB::findDataFile("Images/land_shallow_topo_2048.jpg");
89
90        // make osgTerrain::DataSet quieter..
91        osgTerrain::DataSet::setNotifyOffset(1);
92
93        osg::ref_ptr<osgTerrain::DataSet> dataSet = new osgTerrain::DataSet;
94
95        // register the source imagery
96        {
97            osgTerrain::DataSet::Source* source = new osgTerrain::DataSet::Source(osgTerrain::DataSet::Source::IMAGE, filename);
98
99            source->setCoordinateSystemPolicy(osgTerrain::DataSet::Source::PREFER_CONFIG_SETTINGS);
100            source->setCoordinateSystem(osgTerrain::DataSet::coordinateSystemStringToWTK("WGS84"));
101
102             source->setGeoTransformPolicy(osgTerrain::DataSet::Source::PREFER_CONFIG_SETTINGS_BUT_SCALE_BY_FILE_RESOLUTION);
103            source->setGeoTransformFromRange(-180.0, 180.0, -90.0, 90.0);
104
105            dataSet->addSource(source);
106        }
107
108        // set up destination database paramters.
109        dataSet->setDatabaseType(osgTerrain::DataSet::LOD_DATABASE);
110        dataSet->setConvertFromGeographicToGeocentric(true);
111        dataSet->setDestinationName("test.osg");
112
113        // load the source data and record sizes.
114        dataSet->loadSources();
115
116        MyGraphicsContext context;
117        dataSet->createDestination(30);
118
119        if (dataSet->getDatabaseType()==osgTerrain::DataSet::LOD_DATABASE) dataSet->buildDestination();
120        else dataSet->writeDestination();
121       
122        scene = dataSet->getDestinationRootNode();
123       
124        // now we must get rid of all the old OpenGL objects before we start using the scene graph again
125        // otherwise it'll end up in an inconsistent state.
126        scene->releaseGLObjects(dataSet->getState());
127        osg::Texture::flushAllDeletedTextureObjects(0);
128        osg::Drawable::flushAllDeletedDisplayLists(0);
129    }
130       
131    return scene.release();
132   
133}
134
135
136class ModelPositionCallback : public osg::NodeCallback
137{
138public:
139
140    ModelPositionCallback():
141        _latitude(0.0),
142        _longitude(0.0),
143        _height(100000.0)
144    {
145        _rotation.makeRotate(osg::DegreesToRadians(90.0),0.0,0.0,1.0);
146    }
147   
148    void updateParameters()
149    {
150        _longitude += ((2.0*osg::PI)/360.0)/20.0;
151    }
152
153
154    virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
155    {
156        updateParameters();
157       
158        osg::NodePath nodePath = nv->getNodePath();
159
160        osg::MatrixTransform* mt = nodePath.empty() ? 0 : dynamic_cast<osg::MatrixTransform*>(nodePath.back());
161        if (mt)
162        {
163            osg::CoordinateSystemNode* csn = 0;
164
165            // find coordinate system node from our parental chain
166            unsigned int i;
167            for(i=0; i<nodePath.size() && csn==0; ++i)
168            {
169                csn = dynamic_cast<osg::CoordinateSystemNode*>(nodePath[i]);
170            }
171           
172            if (csn)
173            {
174
175
176                osg::EllipsoidModel* ellipsoid = csn->getEllipsoidModel();
177                if (ellipsoid)
178                {
179                    osg::Matrix inheritedMatrix;
180                    for(i+=1; i<nodePath.size()-1; ++i)
181                    {
182                        osg::Transform* transform = nodePath[i]->asTransform();
183                        if (transform) transform->computeLocalToWorldMatrix(inheritedMatrix, nv);
184                    }
185                   
186                    osg::Matrixd matrix(inheritedMatrix);
187
188                    //osg::Matrixd matrix;
189                    ellipsoid->computeLocalToWorldTransformFromLatLongHeight(_latitude,_longitude,_height,matrix);
190                    matrix.preMult(osg::Matrix::rotate(_rotation));
191                   
192                    mt->setMatrix(matrix);
193                }
194
195            }       
196        }
197           
198        traverse(node,nv);
199    }   
200   
201    double                  _latitude;
202    double                  _longitude;
203    double                  _height;
204    osg::Quat               _rotation;
205};
206
207
208class FindNamedNodeVisitor : public osg::NodeVisitor
209{
210public:
211    FindNamedNodeVisitor(const std::string& name):
212        osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
213        _name(name) {}
214   
215    virtual void apply(osg::Node& node)
216    {
217        if (node.getName()==_name)
218        {
219            _foundNodes.push_back(&node);
220        }
221        traverse(node);
222    }
223   
224    typedef std::vector< osg::ref_ptr<osg::Node> > NodeList;
225
226    std::string _name;
227    NodeList _foundNodes;
228};
229
230
231int main(int argc, char **argv)
232{
233    // use an ArgumentParser object to manage the program arguments.
234    osg::ArgumentParser arguments(&argc,argv);
235   
236    // set up the usage document, in case we need to print out how to use this program.
237    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which demonstrates use of node tracker.");
238    arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName());
239    arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information");
240   
241
242    // construct the viewer.
243    osgViewer::Viewer viewer;
244
245    viewer.getCamera()->setComputeNearFarMode(osg::CullSettings::COMPUTE_NEAR_FAR_USING_PRIMITIVES);
246    viewer.getCamera()->setNearFarRatio(0.00001f);
247
248
249    osg::Quat rotation;
250    osg::Vec4 vec4;
251    while (arguments.read("--rotate-model",vec4[0],vec4[1],vec4[2],vec4[3]))
252    {
253        osg::Quat local_rotate;
254        local_rotate.makeRotate(osg::DegreesToRadians(vec4[0]),vec4[1],vec4[2],vec4[3]);
255       
256        rotation = rotation * local_rotate;
257    }
258
259    osg::NodeCallback* nc = 0;
260    std::string flightpath_filename;
261    while (arguments.read("--flight-path",flightpath_filename))
262    {
263        std::ifstream fin(flightpath_filename.c_str());
264        if (fin)
265        {
266            osg::AnimationPath* path = new osg::AnimationPath;
267            path->read(fin);
268            nc = new osg::AnimationPathCallback(path);
269        }
270    }
271   
272    osgGA::NodeTrackerManipulator::TrackerMode trackerMode = osgGA::NodeTrackerManipulator::NODE_CENTER_AND_ROTATION;
273    std::string mode;
274    while (arguments.read("--tracker-mode",mode))
275    {
276        if (mode=="NODE_CENTER_AND_ROTATION") trackerMode = osgGA::NodeTrackerManipulator::NODE_CENTER_AND_ROTATION;
277        else if (mode=="NODE_CENTER_AND_AZIM") trackerMode = osgGA::NodeTrackerManipulator::NODE_CENTER_AND_AZIM;
278        else if (mode=="NODE_CENTER") trackerMode = osgGA::NodeTrackerManipulator::NODE_CENTER;
279        else
280        {
281            std::cout<<"Unrecognized --tracker-mode option "<<mode<<", valid options are:"<<std::endl;
282            std::cout<<"    NODE_CENTER_AND_ROTATION"<<std::endl;
283            std::cout<<"    NODE_CENTER_AND_AZIM"<<std::endl;
284            std::cout<<"    NODE_CENTER"<<std::endl;
285            return 1;
286        }
287    }
288   
289   
290    osgGA::NodeTrackerManipulator::RotationMode rotationMode = osgGA::NodeTrackerManipulator::TRACKBALL;
291    while (arguments.read("--rotation-mode",mode))
292    {
293        if (mode=="TRACKBALL") rotationMode = osgGA::NodeTrackerManipulator::TRACKBALL;
294        else if (mode=="ELEVATION_AZIM") rotationMode = osgGA::NodeTrackerManipulator::ELEVATION_AZIM;
295        else
296        {
297            std::cout<<"Unrecognized --rotation-mode option "<<mode<<", valid options are:"<<std::endl;
298            std::cout<<"    TRACKBALL"<<std::endl;
299            std::cout<<"    ELEVATION_AZIM"<<std::endl;
300            return 1;
301        }
302    }
303
304    // if user request help write it out to cout.
305    if (arguments.read("-h") || arguments.read("--help"))
306    {
307        arguments.getApplicationUsage()->write(std::cout);
308        return 1;
309    }
310
311    // any option left unread are converted into errors to write out later.
312    arguments.reportRemainingOptionsAsUnrecognized();
313
314    // report any errors if they have occured when parsing the program aguments.
315    if (arguments.errors())
316    {
317        arguments.writeErrorMessages(std::cout);
318        return 1;
319    }
320   
321    // read the scene from the list of file specified commandline args.
322    osg::ref_ptr<osg::Node> root = osgDB::readNodeFiles(arguments);
323
324    if (!root) root = createEarth();
325   
326    if (!root) return 0;
327
328    // add a viewport to the viewer and attach the scene graph.
329    viewer.setSceneData(root.get());
330
331    osg::CoordinateSystemNode* csn = dynamic_cast<osg::CoordinateSystemNode*>(root.get());
332    if (csn)
333    {
334
335        bool insertOverlayNode = true;
336        osg::ref_ptr<osgSim::OverlayNode> overlayNode;
337        if (insertOverlayNode)
338        {
339       
340            overlayNode = new osgSim::OverlayNode;
341           
342            // insert the OverlayNode between the coordinate system node and its children.
343            for(unsigned int i=0; i<csn->getNumChildren(); ++i)
344            {
345                overlayNode->addChild( csn->getChild(i) );
346            }
347
348            csn->removeChildren(0, csn->getNumChildren());
349            csn->addChild(overlayNode.get());
350           
351            // tell the overlay node to continously update its overlay texture
352            // as we know we'll be tracking a moving target.
353            overlayNode->setContinuousUpdate(true);
354        }
355       
356       
357        osg::Node* cessna = osgDB::readNodeFile("cessna.osg");
358        if (cessna)
359        {
360            double s = 200000.0 / cessna->getBound().radius();
361       
362            osg::MatrixTransform* scaler = new osg::MatrixTransform;
363            scaler->addChild(cessna);
364            scaler->setMatrix(osg::Matrixd::scale(s,s,s)*osg::Matrixd::rotate(rotation));
365            scaler->getOrCreateStateSet()->setMode(GL_RESCALE_NORMAL,osg::StateAttribute::ON);       
366       
367            if (false)
368            {
369                osgSim::SphereSegment* ss = new osgSim::SphereSegment(
370                                    osg::Vec3(0.0f,0.0f,0.0f), // center
371                                    19.9f, // radius
372                                    osg::DegreesToRadians(135.0f),
373                                    osg::DegreesToRadians(240.0f),
374                                    osg::DegreesToRadians(-10.0f),
375                                    osg::DegreesToRadians(30.0f),
376                                    60);
377                                   
378                scaler->addChild(ss);
379            }
380
381            osg::MatrixTransform* mt = new osg::MatrixTransform;
382            mt->addChild(scaler);
383
384
385            if (!nc) nc = new ModelPositionCallback;
386
387            mt->setUpdateCallback(nc);
388
389            csn->addChild(mt);
390           
391            // if we are using an overaly node, use the cessna subgraph as the overlay subgraph
392            if (overlayNode.valid())
393            {
394                overlayNode->setOverlaySubgraph(mt);
395            }
396
397            osgGA::NodeTrackerManipulator* tm = new osgGA::NodeTrackerManipulator;
398            tm->setTrackerMode(trackerMode);
399            tm->setRotationMode(rotationMode);
400            tm->setTrackNode(scaler);
401
402            viewer.setCameraManipulator(tm);
403        }
404        else
405        {
406             std::cout<<"Failed to read cessna.osg"<<std::endl;
407        }
408       
409    }   
410
411    return viewer.run();
412}
Note: See TracBrowser for help on using the browser.