root/OpenSceneGraph/trunk/examples/osgmultitexturecontrol/osgmultitexturecontrol.cpp @ 8366

Revision 8366, 12.5 kB (checked in by robert, 7 years ago)

Introduced a TerrainHandler? that adjust the sameple ratio and vertical scale
of terrain interactively using the 'r','R' and 'v','V' keys respecitvely.

Line 
1/* OpenSceneGraph example, osgmultitexture.
2*
3*  Permission is hereby granted, free of charge, to any person obtaining a copy
4*  of this software and associated documentation files (the "Software"), to deal
5*  in the Software without restriction, including without limitation the rights
6*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7*  copies of the Software, and to permit persons to whom the Software is
8*  furnished to do so, subject to the following conditions:
9*
10*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
11*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
13*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
14*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
15*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
16*  THE SOFTWARE.
17*/
18
19
20#include <osg/Notify>
21
22#include <osg/Texture2D>
23#include <osg/io_utils>
24
25#include <osgDB/Registry>
26#include <osgDB/ReadFile>
27
28#include <osgFX/MultiTextureControl>
29
30#include <osgGA/TerrainManipulator>
31#include <osgGA/StateSetManipulator>
32#include <osgGA/AnimationPathManipulator>
33#include <osgGA/TrackballManipulator>
34#include <osgGA/FlightManipulator>
35#include <osgGA/DriveManipulator>
36#include <osgGA/KeySwitchMatrixManipulator>
37#include <osgGA/StateSetManipulator>
38#include <osgGA/AnimationPathManipulator>
39#include <osgGA/TerrainManipulator>
40
41#include <osgTerrain/Terrain>
42
43#include <osgViewer/ViewerEventHandlers>
44#include <osgViewer/Viewer>
45
46
47#include <iostream>
48
49template<class T>
50class FindTopMostNodeOfTypeVisitor : public osg::NodeVisitor
51{
52public:
53    FindTopMostNodeOfTypeVisitor():
54        osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
55        _foundNode(0)
56    {}
57   
58    void apply(osg::Node& node)
59    {
60        T* result = dynamic_cast<T*>(&node);
61        if (result)
62        {
63            _foundNode = result;
64        }
65        else
66        {
67            traverse(node);
68        }
69    }
70   
71    T* _foundNode;
72};
73
74template<class T>
75T* findTopMostNodeOfType(osg::Node* node)
76{
77    if (!node) return 0;
78
79    FindTopMostNodeOfTypeVisitor<T> fnotv;
80    node->accept(fnotv);
81   
82    return fnotv._foundNode;
83}
84
85/** Callback used to track the elevation of the camera and update the texture weights in an MultiTextureControl node.*/
86class ElevationLayerBlendingCallback : public osg::NodeCallback
87{
88    public:
89   
90        typedef std::vector<double> Elevations;
91
92        ElevationLayerBlendingCallback(osgFX::MultiTextureControl* mtc, const Elevations& elevations, float animationTime=4.0f):
93            _previousFrame(-1),
94            _previousTime(0.0),
95            _mtc(mtc),
96            _elevations(elevations),
97            _animationTime(animationTime) {}
98   
99        /** Callback method called by the NodeVisitor when visiting a node.*/
100        virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
101        {
102            if (!nv->getFrameStamp() || _previousFrame==nv->getFrameStamp()->getFrameNumber())
103            {
104                // we've already updated for this frame so no need to do it again, just traverse children.
105                traverse(node,nv);
106                return;
107            }
108           
109            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
110           
111            float deltaTime = 0.01f;
112            if (_previousFrame!=-1)
113            {
114                deltaTime = float(nv->getFrameStamp()->getReferenceTime() - _previousTime);
115            }
116           
117            _previousTime = nv->getFrameStamp()->getReferenceTime();
118            _previousFrame = nv->getFrameStamp()->getFrameNumber();
119
120            double elevation = nv->getViewPoint().z();
121       
122            osg::CoordinateSystemNode* csn = dynamic_cast<osg::CoordinateSystemNode*>(node);
123            if (csn)
124            {
125                osg::EllipsoidModel* em = csn->getEllipsoidModel();
126                if (em)
127                {
128                    double X = nv->getViewPoint().x();
129                    double Y = nv->getViewPoint().y();
130                    double Z = nv->getViewPoint().z();
131                    double latitude, longitude;
132                    em->convertXYZToLatLongHeight(X,Y,Z,latitude, longitude, elevation);
133                }
134            }
135       
136            if (_mtc.valid() && !_elevations.empty())
137            {
138                unsigned int index = _mtc->getNumTextureWeights()-1;
139                for(unsigned int i=0; i<_elevations.size(); ++i)
140                {
141                    if (elevation>_elevations[i])
142                    {
143                        index = i;
144                        break;
145                    }
146                }
147               
148                float delta = std::min(deltaTime/_animationTime, 1.0f);
149               
150                for(unsigned int i=0; i<_mtc->getNumTextureWeights(); ++i)
151                {
152                    float currentValue = _mtc->getTextureWeight(i);
153                    float desiredValue = (i==index) ? 1.0f : 0.0f;
154                    if (desiredValue != currentValue)
155                    {
156                        if (currentValue<desiredValue)
157                        {
158                            desiredValue = std::min(currentValue + delta, desiredValue);
159                        }
160                        else
161                        {
162                            desiredValue = std::max(currentValue - delta, desiredValue);
163                        }
164                   
165                        _mtc->setTextureWeight(i, desiredValue);
166                    }
167                }
168               
169            }
170       
171            traverse(node,nv);
172        }
173
174        int                                             _previousFrame;
175        double                                          _previousTime;
176        float                                           _animationTime;
177        osg::observer_ptr<osgFX::MultiTextureControl>   _mtc;
178        Elevations                                      _elevations;
179       
180        OpenThreads::Mutex                              _mutex;
181};
182
183
184// class to handle events with a pick
185class TerrainHandler : public osgGA::GUIEventHandler {
186public:
187
188    TerrainHandler(osgTerrain::Terrain* terrain):
189        _terrain(terrain) {}
190   
191    bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
192    {
193        switch(ea.getEventType())
194        {
195            case(osgGA::GUIEventAdapter::KEYDOWN):
196            {   
197                if (ea.getKey()=='r')
198                {
199                    _terrain->setSampleRatio(_terrain->getSampleRatio()*0.5);
200                    osg::notify(osg::NOTICE)<<"Sample ratio "<<_terrain->getSampleRatio()<<std::endl;
201                    return true;
202                }
203                else if (ea.getKey()=='R')
204                {
205                    _terrain->setSampleRatio(_terrain->getSampleRatio()/0.5);
206                    osg::notify(osg::NOTICE)<<"Sample ratio "<<_terrain->getSampleRatio()<<std::endl;
207                    return true;
208                }
209                else if (ea.getKey()=='v')
210                {
211                    _terrain->setVerticalScale(_terrain->getVerticalScale()*1.25);
212                    osg::notify(osg::NOTICE)<<"Vertical scale "<<_terrain->getVerticalScale()<<std::endl;
213                    return true;
214                }
215                else if (ea.getKey()=='V')
216                {
217                    _terrain->setVerticalScale(_terrain->getVerticalScale()/1.25);
218                    osg::notify(osg::NOTICE)<<"Vertical scale "<<_terrain->getVerticalScale()<<std::endl;
219                    return true;
220                }
221
222                return false;
223            }   
224            default:
225                return false;
226        }
227    }
228   
229protected:
230
231    ~TerrainHandler() {}
232
233    osg::ref_ptr<osgTerrain::Terrain>  _terrain;
234};
235
236int main( int argc, char **argv )
237{
238    // use an ArgumentParser object to manage the program arguments.
239    osg::ArgumentParser arguments(&argc,argv);
240   
241    // construct the viewer.
242    osgViewer::Viewer viewer(arguments);
243   
244    float verticalScale = 1.0f;
245    while(arguments.read("-v",verticalScale)) {}
246   
247    float sampleRatio = 1.0f;
248    while(arguments.read("-r",sampleRatio)) {}
249
250
251    // add all the event handlers to the viewer
252    {
253        // add the state manipulator
254        viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
255
256        // add the thread model handler
257        viewer.addEventHandler(new osgViewer::ThreadingHandler);
258
259        // add the window size toggle handler
260        viewer.addEventHandler(new osgViewer::WindowSizeHandler);
261
262        // add the stats handler
263        viewer.addEventHandler(new osgViewer::StatsHandler);
264
265        // add the help handler
266        viewer.addEventHandler(new osgViewer::HelpHandler(arguments.getApplicationUsage()));
267
268        // add the record camera path handler
269        viewer.addEventHandler(new osgViewer::RecordCameraPathHandler);
270
271        // add the LOD Scale handler
272        viewer.addEventHandler(new osgViewer::LODScaleHandler);
273    }
274
275    // add all the camera manipulators
276    {
277        osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator = new osgGA::KeySwitchMatrixManipulator;
278
279        keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new osgGA::TrackballManipulator() );
280        keyswitchManipulator->addMatrixManipulator( '2', "Flight", new osgGA::FlightManipulator() );
281        keyswitchManipulator->addMatrixManipulator( '3', "Drive", new osgGA::DriveManipulator() );
282
283        unsigned int num = keyswitchManipulator->getNumMatrixManipulators();
284        keyswitchManipulator->addMatrixManipulator( '4', "Terrain", new osgGA::TerrainManipulator() );
285
286        std::string pathfile;
287        char keyForAnimationPath = '5';
288        while (arguments.read("-p",pathfile))
289        {
290            osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
291            if (apm || !apm->valid())
292            {
293                num = keyswitchManipulator->getNumMatrixManipulators();
294                keyswitchManipulator->addMatrixManipulator( keyForAnimationPath, "Path", apm );
295                ++keyForAnimationPath;
296            }
297        }
298
299        keyswitchManipulator->selectMatrixManipulator(num);
300
301        viewer.setCameraManipulator( keyswitchManipulator.get() );
302    }
303
304    // set up the scene graph
305    {
306        // load the nodes from the commandline arguments.
307        osg::Node* rootnode = osgDB::readNodeFiles(arguments);
308
309        if (!rootnode)
310        {
311            osg::notify(osg::NOTICE)<<"Warning: no valid data loaded, please specify a database on the command line."<<std::endl;
312            return 1;
313        }
314
315        osgTerrain::Terrain* terrain = findTopMostNodeOfType<osgTerrain::Terrain>(rootnode);
316        if (!terrain)
317        {
318            terrain = new osgTerrain::Terrain;
319            terrain->addChild(rootnode);
320
321            rootnode = terrain;
322        }   
323
324        terrain->setSampleRatio(sampleRatio);
325        terrain->setVerticalScale(verticalScale);
326
327        // register our custom handler for adjust Terrain settings       
328        viewer.addEventHandler(new TerrainHandler(terrain));
329
330        osg::CoordinateSystemNode* csn = findTopMostNodeOfType<osg::CoordinateSystemNode>(rootnode);
331
332        unsigned int numLayers = 1;
333        osgFX::MultiTextureControl* mtc = findTopMostNodeOfType<osgFX::MultiTextureControl>(rootnode);
334        if (mtc)
335        {
336            numLayers = mtc->getNumTextureWeights();
337        }
338
339        if (numLayers<2)
340        {
341            osg::notify(osg::NOTICE)<<"Warning: scene must have MultiTextureControl node with at least 2 texture units defined."<<std::endl;
342            return 1;
343        }
344
345        double maxElevationTransition = 1e6;
346        ElevationLayerBlendingCallback::Elevations elevations;
347        for(unsigned int i=0; i<numLayers; ++i)
348        {
349            elevations.push_back(maxElevationTransition);
350            maxElevationTransition /= 2.0;
351        }
352
353        ElevationLayerBlendingCallback* elbc = new ElevationLayerBlendingCallback(mtc, elevations);
354
355        // assign to the most appropriate node (the CoordinateSystemNode is best as it provides the elevation on the globe.)
356        if (csn) csn->setCullCallback(elbc);   
357        else if (mtc) mtc->setCullCallback(elbc);
358        else rootnode->setCullCallback(elbc);
359
360        // add a viewport to the viewer and attach the scene graph.
361        viewer.setSceneData( rootnode );
362    }
363   
364    // create the windows and run the threads.
365    viewer.realize();
366
367    return viewer.run();
368}
Note: See TracBrowser for help on using the browser.