root/OpenSceneGraph/trunk/examples/osgshadow/osgshadow.cpp @ 12202

Revision 12202, 47.9 kB (checked in by robert, 3 years ago)

Introduced a new more generic function for settings up the depth partitioning of viewer cameras.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* OpenSceneGraph example, osgshadow.
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#include <osg/ArgumentParser>
20#include <osg/ComputeBoundsVisitor>
21#include <osg/Texture2D>
22#include <osg/ShapeDrawable>
23#include <osg/MatrixTransform>
24#include <osg/Geometry>
25
26#include <osgGA/TrackballManipulator>
27#include <osgGA/FlightManipulator>
28#include <osgGA/DriveManipulator>
29#include <osgGA/KeySwitchMatrixManipulator>
30#include <osgGA/AnimationPathManipulator>
31#include <osgGA/TerrainManipulator>
32#include <osgGA/AnimationPathManipulator>
33#include <osgGA/StateSetManipulator>
34
35#include <osgViewer/Viewer>
36#include <osgViewer/ViewerEventHandlers>
37
38#include <osgShadow/ShadowedScene>
39#include <osgShadow/ShadowVolume>
40#include <osgShadow/ShadowTexture>
41#include <osgShadow/ShadowMap>
42#include <osgShadow/SoftShadowMap>
43#include <osgShadow/ParallelSplitShadowMap>
44#include <osgShadow/LightSpacePerspectiveShadowMap>
45#include <osgShadow/StandardShadowMap>
46
47#include <osgDB/ReadFile>
48#include <osgDB/WriteFile>
49
50#include <osg/io_utils>
51#include <iostream>
52
53
54// for the grid data..
55#include "terrain_coords.h"
56// for the model number four - island scene
57#include "IslandScene.h"
58
59
60class ChangeFOVHandler : public osgGA::GUIEventHandler
61{
62public:
63    ChangeFOVHandler(osg::Camera* camera)
64        : _camera(camera)
65    {
66        double fovy, aspectRatio, zNear, zFar;
67        _camera->getProjectionMatrix().getPerspective(fovy, aspectRatio, zNear, zFar);
68        std::cout << "FOV is " << fovy << std::endl;
69    }
70
71    /** Deprecated, Handle events, return true if handled, false otherwise. */
72    virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
73    {
74        if (ea.getEventType() == osgGA::GUIEventAdapter::KEYUP)
75        {
76            if (ea.getKey() == '-' || ea.getKey() == '=' || ea.getKey() == '0')
77            {
78                double fovy, aspectRatio, zNear, zFar;
79                _camera->getProjectionMatrix().getPerspective(fovy, aspectRatio, zNear, zFar);
80
81                if (ea.getKey() == '-')
82                {
83                    fovy -= 5.0;
84                }
85
86                if (ea.getKey() == '=')
87                {
88                    fovy += 5.0;
89                }
90
91                if (ea.getKey() == '0')
92                {
93                    fovy = 45.0;
94                }
95
96                std::cout << "Setting FOV to " << fovy << std::endl;
97                _camera->getProjectionMatrix().makePerspective(fovy, aspectRatio, zNear, zFar);
98
99                return true;
100            }
101        }
102
103        return false;
104    }
105
106    osg::ref_ptr<osg::Camera> _camera;
107};
108
109
110class DumpShadowVolumesHandler : public osgGA::GUIEventHandler
111{
112public:
113    DumpShadowVolumesHandler(  )
114    {
115        set( false );
116    }
117
118    bool get() { return _value; }
119    void set( bool value ) { _value = value; }
120
121    /** Deprecated, Handle events, return true if handled, false otherwise. */
122    virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa)
123    {
124        if (ea.getEventType() == osgGA::GUIEventAdapter::KEYUP)
125        {
126            if (ea.getKey() == 'D' )
127            {
128                set( true );
129                return true;
130            }
131        }
132
133        return false;
134    }
135
136    bool  _value;
137};
138
139
140static int ReceivesShadowTraversalMask = 0x1;
141static int CastsShadowTraversalMask = 0x2;
142
143namespace ModelOne
144{
145
146    enum Faces
147    {
148        FRONT_FACE = 1,
149        BACK_FACE = 2,
150        LEFT_FACE = 4,
151        RIGHT_FACE = 8,
152        TOP_FACE = 16,
153        BOTTOM_FACE = 32
154    };
155
156    osg::Node* createCube(unsigned int mask)
157    {
158        osg::Geode* geode = new osg::Geode;
159
160        osg::Geometry* geometry = new osg::Geometry;
161        geode->addDrawable(geometry);
162
163        osg::Vec3Array* vertices = new osg::Vec3Array;
164        geometry->setVertexArray(vertices);
165
166        osg::Vec3Array* normals = new osg::Vec3Array;
167        geometry->setNormalArray(normals);
168        geometry->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
169
170        osg::Vec4Array* colours = new osg::Vec4Array;
171        geometry->setColorArray(colours);
172        geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
173        colours->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
174
175
176        osg::Vec3 origin(0.0f,0.0f,0.0f);
177        osg::Vec3 dx(2.0f,0.0f,0.0f);
178        osg::Vec3 dy(0.0f,1.0f,0.0f);
179        osg::Vec3 dz(0.0f,0.0f,1.0f);
180
181        osg::Vec3 px(1.0f,0.0,0.0f);
182        osg::Vec3 nx(-1.0f,0.0,0.0f);
183        osg::Vec3 py(0.0f,1.0f,0.0f);
184        osg::Vec3 ny(0.0f,-1.0f,0.0f);
185        osg::Vec3 pz(0.0f,0.0f,1.0f);
186        osg::Vec3 nz(0.0f,0.0f,-1.0f);
187
188        if (mask & FRONT_FACE)
189        {
190            // front face
191            vertices->push_back(origin);
192            vertices->push_back(origin+dx);
193            vertices->push_back(origin+dx+dz);
194            vertices->push_back(origin+dz);
195            normals->push_back(ny);
196            normals->push_back(ny);
197            normals->push_back(ny);
198            normals->push_back(ny);
199        }
200
201        if (mask & BACK_FACE)
202        {
203            // back face
204            vertices->push_back(origin+dy);
205            vertices->push_back(origin+dy+dz);
206            vertices->push_back(origin+dy+dx+dz);
207            vertices->push_back(origin+dy+dx);
208            normals->push_back(py);
209            normals->push_back(py);
210            normals->push_back(py);
211            normals->push_back(py);
212        }
213
214        if (mask & LEFT_FACE)
215        {
216            // left face
217            vertices->push_back(origin+dy);
218            vertices->push_back(origin);
219            vertices->push_back(origin+dz);
220            vertices->push_back(origin+dy+dz);
221            normals->push_back(nx);
222            normals->push_back(nx);
223            normals->push_back(nx);
224            normals->push_back(nx);
225        }
226
227        if (mask & RIGHT_FACE)
228        {
229            // right face
230            vertices->push_back(origin+dx+dy);
231            vertices->push_back(origin+dx+dy+dz);
232            vertices->push_back(origin+dx+dz);
233            vertices->push_back(origin+dx);
234            normals->push_back(px);
235            normals->push_back(px);
236            normals->push_back(px);
237            normals->push_back(px);
238        }
239
240        if (mask & TOP_FACE)
241        {
242            // top face
243            vertices->push_back(origin+dz);
244            vertices->push_back(origin+dz+dx);
245            vertices->push_back(origin+dz+dx+dy);
246            vertices->push_back(origin+dz+dy);
247            normals->push_back(pz);
248            normals->push_back(pz);
249            normals->push_back(pz);
250            normals->push_back(pz);
251        }
252
253        if (mask & BOTTOM_FACE)
254        {
255            // bottom face
256            vertices->push_back(origin);
257            vertices->push_back(origin+dy);
258            vertices->push_back(origin+dx+dy);
259            vertices->push_back(origin+dx);
260            normals->push_back(nz);
261            normals->push_back(nz);
262            normals->push_back(nz);
263            normals->push_back(nz);
264        }
265
266        geometry->addPrimitiveSet(new osg::DrawArrays(GL_QUADS, 0, vertices->size()));
267
268        return geode;
269    }
270
271    class SwitchHandler : public osgGA::GUIEventHandler
272    {
273    public:
274
275        SwitchHandler():
276            _childNum(0) {}
277
278        virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& /*aa*/, osg::Object* object, osg::NodeVisitor* /*nv*/)
279        {
280            osg::Switch* sw = dynamic_cast<osg::Switch*>(object);
281            if (!sw) return false;
282
283            if (ea.getHandled()) return false;
284
285            switch(ea.getEventType())
286            {
287                case(osgGA::GUIEventAdapter::KEYDOWN):
288                {
289                    if (ea.getKey()=='n')
290                    {
291                        ++_childNum;
292                        if (_childNum >= sw->getNumChildren()) _childNum = 0;
293
294                        sw->setSingleChildOn(_childNum);
295                        return true;
296                    }
297                    break;
298                }
299                default:
300                    break;
301            }
302            return false;
303        }
304
305    protected:
306
307        virtual ~SwitchHandler() {}
308        unsigned int    _childNum;
309
310    };
311
312
313    osg::Node* createModel(osg::ArgumentParser& /*arguments*/)
314    {
315        osg::Switch* sw = new osg::Switch;
316        sw->setEventCallback(new ModelOne::SwitchHandler);
317
318        sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE), true);
319        sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE | ModelOne::BACK_FACE), false);
320        sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE | ModelOne::BACK_FACE | ModelOne::LEFT_FACE), false);
321        sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE | ModelOne::BACK_FACE | ModelOne::LEFT_FACE | ModelOne::RIGHT_FACE), false);
322        sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE | ModelOne::BACK_FACE | ModelOne::LEFT_FACE | ModelOne::RIGHT_FACE | ModelOne::TOP_FACE), false);
323        sw->addChild(ModelOne::createCube(ModelOne::FRONT_FACE | ModelOne::BACK_FACE | ModelOne::LEFT_FACE | ModelOne::RIGHT_FACE | ModelOne::TOP_FACE | ModelOne::BOTTOM_FACE), false);
324
325        return sw;
326    }
327}
328
329namespace ModelTwo
330{
331    osg::AnimationPath* createAnimationPath(const osg::Vec3& center,float radius,double looptime)
332    {
333        // set up the animation path
334        osg::AnimationPath* animationPath = new osg::AnimationPath;
335        animationPath->setLoopMode(osg::AnimationPath::LOOP);
336
337        int numSamples = 40;
338        float yaw = 0.0f;
339        float yaw_delta = 2.0f*osg::PI/((float)numSamples-1.0f);
340        float roll = osg::inDegrees(30.0f);
341
342        double time=0.0f;
343        double time_delta = looptime/(double)numSamples;
344        for(int i=0;i<numSamples;++i)
345        {
346            osg::Vec3 position(center+osg::Vec3(sinf(yaw)*radius,cosf(yaw)*radius,0.0f));
347            osg::Quat rotation(osg::Quat(roll,osg::Vec3(0.0,1.0,0.0))*osg::Quat(-(yaw+osg::inDegrees(90.0f)),osg::Vec3(0.0,0.0,1.0)));
348
349            animationPath->insert(time,osg::AnimationPath::ControlPoint(position,rotation));
350
351            yaw += yaw_delta;
352            time += time_delta;
353
354        }
355        return animationPath;
356    }
357
358    osg::Node* createBase(const osg::Vec3& center,float radius)
359    {
360
361        osg::Geode* geode = new osg::Geode;
362
363        // set up the texture of the base.
364        osg::StateSet* stateset = new osg::StateSet();
365        osg::Image* image = osgDB::readImageFile("Images/lz.rgb");
366        if (image)
367        {
368            osg::Texture2D* texture = new osg::Texture2D;
369            texture->setImage(image);
370            stateset->setTextureAttributeAndModes(0,texture,osg::StateAttribute::ON);
371        }
372
373        geode->setStateSet( stateset );
374
375
376        osg::HeightField* grid = new osg::HeightField;
377        grid->allocate(38,39);
378        grid->setOrigin(center+osg::Vec3(-radius,-radius,0.0f));
379        grid->setXInterval(radius*2.0f/(float)(38-1));
380        grid->setYInterval(radius*2.0f/(float)(39-1));
381
382        float minHeight = FLT_MAX;
383        float maxHeight = -FLT_MAX;
384
385
386        unsigned int r;
387        for(r=0;r<39;++r)
388        {
389            for(unsigned int c=0;c<38;++c)
390            {
391                float h = vertex[r+c*39][2];
392                if (h>maxHeight) maxHeight=h;
393                if (h<minHeight) minHeight=h;
394            }
395        }
396
397        float hieghtScale = radius*0.5f/(maxHeight-minHeight);
398        float hieghtOffset = -(minHeight+maxHeight)*0.5f;
399
400        for(r=0;r<39;++r)
401        {
402            for(unsigned int c=0;c<38;++c)
403            {
404                float h = vertex[r+c*39][2];
405                grid->setHeight(c,r,(h+hieghtOffset)*hieghtScale);
406            }
407        }
408
409        geode->addDrawable(new osg::ShapeDrawable(grid));
410
411        osg::Group* group = new osg::Group;
412        group->addChild(geode);
413
414        return group;
415
416    }
417
418    osg::Node* createMovingModel(const osg::Vec3& center, float radius)
419    {
420        float animationLength = 10.0f;
421
422        osg::AnimationPath* animationPath = createAnimationPath(center,radius,animationLength);
423
424        osg::Group* model = new osg::Group;
425
426        osg::Node* cessna = osgDB::readNodeFile("cessna.osg");
427        if (cessna)
428        {
429            const osg::BoundingSphere& bs = cessna->getBound();
430
431            float size = radius/bs.radius()*0.3f;
432            osg::MatrixTransform* positioned = new osg::MatrixTransform;
433            positioned->setDataVariance(osg::Object::STATIC);
434            positioned->setMatrix(osg::Matrix::translate(-bs.center())*
435                                  osg::Matrix::scale(size,size,size)*
436                                  osg::Matrix::rotate(osg::inDegrees(180.0f),0.0f,0.0f,2.0f));
437
438            positioned->addChild(cessna);
439
440            osg::MatrixTransform* xform = new osg::MatrixTransform;
441            xform->setUpdateCallback(new osg::AnimationPathCallback(animationPath,0.0f,2.0));
442            xform->addChild(positioned);
443
444            model->addChild(xform);
445        }
446
447        return model;
448    }
449
450    osg::Node* createModel(osg::ArgumentParser& /*arguments*/)
451    {
452        osg::Vec3 center(0.0f,0.0f,0.0f);
453        float radius = 100.0f;
454        osg::Vec3 lightPosition(center+osg::Vec3(0.0f,0.0f,radius));
455
456        // the shadower model
457        osg::Node* shadower = createMovingModel(center,radius*0.5f);
458        shadower->setNodeMask(CastsShadowTraversalMask);
459
460        // the shadowed model
461        osg::Node* shadowed = createBase(center-osg::Vec3(0.0f,0.0f,radius*0.25),radius);
462        shadowed->setNodeMask(ReceivesShadowTraversalMask);
463
464        osg::Group* group = new osg::Group;
465
466        group->addChild(shadowed);
467        group->addChild(shadower);
468
469        return group;
470    }
471}
472
473namespace ModelThree
474{
475    osg::Group* createModel(osg::ArgumentParser& arguments)
476    {
477        osg::Group* scene = new osg::Group;
478
479        osg::ref_ptr<osg::Geode> geode_1 = new osg::Geode;
480        scene->addChild(geode_1.get());
481
482        osg::ref_ptr<osg::Geode> geode_2 = new osg::Geode;
483        osg::ref_ptr<osg::MatrixTransform> transform_2 = new osg::MatrixTransform;
484        transform_2->addChild(geode_2.get());
485//        transform_2->setUpdateCallback(new osg::AnimationPathCallback(osg::Vec3(0, 0, 0), osg::Z_AXIS, osg::inDegrees(45.0f)));
486        scene->addChild(transform_2.get());
487
488        osg::ref_ptr<osg::Geode> geode_3 = new osg::Geode;
489        osg::ref_ptr<osg::MatrixTransform> transform_3 = new osg::MatrixTransform;
490        transform_3->addChild(geode_3.get());
491//        transform_3->setUpdateCallback(new osg::AnimationPathCallback(osg::Vec3(0, 0, 0), osg::Z_AXIS, osg::inDegrees(-22.5f)));
492        scene->addChild(transform_3.get());
493
494        const float radius = 0.8f;
495        const float height = 1.0f;
496        osg::ref_ptr<osg::TessellationHints> hints = new osg::TessellationHints;
497        hints->setDetailRatio(2.0f);
498        osg::ref_ptr<osg::ShapeDrawable> shape;
499
500        shape = new osg::ShapeDrawable(new osg::Box(osg::Vec3(0.0f, 0.0f, -2.0f), 10, 10.0f, 0.1f), hints.get());
501        shape->setColor(osg::Vec4(0.5f, 0.5f, 0.7f, 1.0f));
502        geode_1->addDrawable(shape.get());
503
504        shape = new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(0.0f, 0.0f, 0.0f), radius * 2), hints.get());
505        shape->setColor(osg::Vec4(0.8f, 0.8f, 0.8f, 1.0f));
506        geode_1->addDrawable(shape.get());
507
508        shape = new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(-3.0f, 0.0f, 0.0f), radius), hints.get());
509        shape->setColor(osg::Vec4(0.6f, 0.8f, 0.8f, 1.0f));
510        geode_2->addDrawable(shape.get());
511
512        shape = new osg::ShapeDrawable(new osg::Box(osg::Vec3(3.0f, 0.0f, 0.0f), 2 * radius), hints.get());
513        shape->setColor(osg::Vec4(0.4f, 0.9f, 0.3f, 1.0f));
514        geode_2->addDrawable(shape.get());
515
516        shape = new osg::ShapeDrawable(new osg::Cone(osg::Vec3(0.0f, -3.0f, 0.0f), radius, height), hints.get());
517        shape->setColor(osg::Vec4(0.2f, 0.5f, 0.7f, 1.0f));
518        geode_2->addDrawable(shape.get());
519
520        shape = new osg::ShapeDrawable(new osg::Cylinder(osg::Vec3(0.0f, 3.0f, 0.0f), radius, height), hints.get());
521        shape->setColor(osg::Vec4(1.0f, 0.3f, 0.3f, 1.0f));
522        geode_2->addDrawable(shape.get());
523
524        shape = new osg::ShapeDrawable(new osg::Box(osg::Vec3(0.0f, 0.0f, 3.0f), 2.0f, 2.0f, 0.1f), hints.get());
525        shape->setColor(osg::Vec4(0.8f, 0.8f, 0.4f, 1.0f));
526        geode_3->addDrawable(shape.get());
527
528        // material
529        osg::ref_ptr<osg::Material> matirial = new osg::Material;
530        matirial->setColorMode(osg::Material::DIFFUSE);
531        matirial->setAmbient(osg::Material::FRONT_AND_BACK, osg::Vec4(0, 0, 0, 1));
532        matirial->setSpecular(osg::Material::FRONT_AND_BACK, osg::Vec4(1, 1, 1, 1));
533        matirial->setShininess(osg::Material::FRONT_AND_BACK, 64.0f);
534        scene->getOrCreateStateSet()->setAttributeAndModes(matirial.get(), osg::StateAttribute::ON);
535
536        bool withBaseTexture = true;
537        while(arguments.read("--with-base-texture")) { withBaseTexture = true; }
538        while(arguments.read("--no-base-texture")) { withBaseTexture = false; }
539
540        if (withBaseTexture)
541        {
542            scene->getOrCreateStateSet()->setTextureAttributeAndModes( 0, new osg::Texture2D(osgDB::readImageFile("Images/lz.rgb")), osg::StateAttribute::ON);
543        }
544
545        return scene;
546    }
547
548}
549
550
551osg::Node* createTestModel(osg::ArgumentParser& arguments)
552{
553    if (arguments.read("-1"))
554    {
555        return ModelOne::createModel(arguments);
556    }
557    else if (arguments.read("-2"))
558    {
559        return ModelTwo::createModel(arguments);
560    }
561    else if (arguments.read("-4"))
562    {
563        return ModelFour::createModel(arguments);
564    }
565    else /*if (arguments.read("-3"))*/
566    {
567        return ModelThree::createModel(arguments);
568    }
569
570}
571
572struct DepthPartitionSettings : public osg::Referenced
573{
574    DepthPartitionSettings() {}
575
576    enum DepthMode
577    {
578        FIXED_RANGE,
579        BOUNDING_VOLUME
580    };
581
582    bool getDepthRange(osg::View& view, unsigned int partition, double& zNear, double& zFar)
583    {
584        switch(_mode)
585        {
586            case(FIXED_RANGE):
587            {
588                if (partition==0)
589                {
590                    zNear = _zNear;
591                    zFar = _zMid;
592                    return true;
593                }
594                else if (partition==1)
595                {
596                    zNear = _zMid;
597                    zFar = _zFar;
598                    return true;
599                }
600                return false;
601            }
602            case(BOUNDING_VOLUME):
603            {
604                osgViewer::View* view_withSceneData = dynamic_cast<osgViewer::View*>(&view);
605                const osg::Node* node = view_withSceneData ? view_withSceneData->getSceneData() : 0;
606                if (!node) return false;
607
608                const osg::Camera* masterCamera = view.getCamera();
609                if (!masterCamera) return false;
610
611                osg::BoundingSphere bs = node->getBound();
612                const osg::Matrixd& viewMatrix = masterCamera->getViewMatrix();
613                //osg::Matrixd& projectionMatrix = masterCamera->getProjectionMatrix();
614
615                osg::Vec3d lookVectorInWorldCoords = osg::Matrixd::transform3x3(viewMatrix,osg::Vec3d(0.0,0.0,-1.0));
616                lookVectorInWorldCoords.normalize();
617
618                osg::Vec3d nearPointInWorldCoords = bs.center() - lookVectorInWorldCoords*bs.radius();
619                osg::Vec3d farPointInWorldCoords = bs.center() + lookVectorInWorldCoords*bs.radius();
620
621                osg::Vec3d nearPointInEyeCoords = nearPointInWorldCoords * viewMatrix;
622                osg::Vec3d farPointInEyeCoords = farPointInWorldCoords * viewMatrix;
623
624#if 0
625                OSG_NOTICE<<std::endl;
626                OSG_NOTICE<<"viewMatrix = "<<viewMatrix<<std::endl;
627                OSG_NOTICE<<"lookVectorInWorldCoords = "<<lookVectorInWorldCoords<<std::endl;
628                OSG_NOTICE<<"nearPointInWorldCoords = "<<nearPointInWorldCoords<<std::endl;
629                OSG_NOTICE<<"farPointInWorldCoords = "<<farPointInWorldCoords<<std::endl;
630                OSG_NOTICE<<"nearPointInEyeCoords = "<<nearPointInEyeCoords<<std::endl;
631                OSG_NOTICE<<"farPointInEyeCoords = "<<farPointInEyeCoords<<std::endl;
632#endif
633                double minZNearRatio = 0.001;
634
635
636                if (masterCamera->getDisplaySettings())
637                {
638                    OSG_NOTICE<<"Has display settings"<<std::endl;
639                }
640
641                double scene_zNear = -nearPointInEyeCoords.z();
642                double scene_zFar = -farPointInEyeCoords.z();
643                if (scene_zNear<=0.0) scene_zNear = minZNearRatio * scene_zFar;
644
645                double scene_zMid = sqrt(scene_zFar*scene_zNear);
646
647#if 0
648                OSG_NOTICE<<"scene_zNear = "<<scene_zNear<<std::endl;
649                OSG_NOTICE<<"scene_zMid = "<<scene_zMid<<std::endl;
650                OSG_NOTICE<<"scene_zFar = "<<scene_zFar<<std::endl;
651#endif
652                if (partition==0)
653                {
654                    zNear = scene_zNear;
655                    zFar = scene_zMid;
656                    return true;
657                }
658                else if (partition==1)
659                {
660                    zNear = scene_zMid;
661                    zFar = scene_zFar;
662                    return true;
663                }
664
665                return false;
666            }
667        }
668    }
669
670    DepthMode _mode;
671    double _zNear;
672    double _zMid;
673    double _zFar;
674};
675
676struct MyUpdateSlaveCallback : public osg::View::Slave::UpdateSlaveCallback
677{
678    MyUpdateSlaveCallback(DepthPartitionSettings* dps, unsigned int partition):_dps(dps), _partition(partition) {}
679   
680    virtual void updateSlave(osg::View& view, osg::View::Slave& slave)
681    {
682        slave.updateSlaveImplementation(view);
683
684        if (!_dps) return;
685
686        osg::Camera* camera = slave._camera.get();
687
688        double computed_zNear;
689        double computed_zFar;
690        if (!_dps->getDepthRange(view, _partition, computed_zNear, computed_zFar))
691        {
692            OSG_NOTICE<<"Switching off Camera "<<camera<<std::endl;
693            camera->setNodeMask(0x0);
694            return;
695        }
696        else
697        {
698            camera->setNodeMask(0xffffff);
699        }
700
701        if (camera->getProjectionMatrix()(0,3)==0.0 &&
702            camera->getProjectionMatrix()(1,3)==0.0 &&
703            camera->getProjectionMatrix()(2,3)==0.0)
704        {
705            double left, right, bottom, top, zNear, zFar;
706            camera->getProjectionMatrixAsOrtho(left, right, bottom, top, zNear, zFar);
707            camera->setProjectionMatrixAsOrtho(left, right, bottom, top, computed_zNear, computed_zFar);
708        }
709        else
710        {
711            double left, right, bottom, top, zNear, zFar;
712            camera->getProjectionMatrixAsFrustum(left, right, bottom, top, zNear, zFar);
713
714            double nr = computed_zNear / zNear;
715            camera->setProjectionMatrixAsFrustum(left * nr, right * nr, bottom * nr, top * nr, computed_zNear, computed_zFar);
716        }
717    }
718
719    osg::ref_ptr<DepthPartitionSettings> _dps;
720    unsigned int _partition;
721};
722
723
724bool setUpDepthPartitionForCamera(osg::View& view, osg::Camera* cameraToPartition, DepthPartitionSettings* dps)
725{
726    osg::ref_ptr<osg::GraphicsContext> context = cameraToPartition->getGraphicsContext();
727    if (!context) return false;
728
729    osg::ref_ptr<osg::Viewport> viewport = cameraToPartition->getViewport();
730    if (!viewport) return false;
731
732    cameraToPartition->setGraphicsContext(0);
733    cameraToPartition->setViewport(0);
734
735    bool useMastersSceneData = true;
736    osg::Matrixd projectionOffset;
737    osg::Matrixd viewOffset;
738
739    if (view.getCamera()==cameraToPartition)
740    {
741        // replace main camera with depth partition cameras
742        OSG_NOTICE<<"Replacing main Camera"<<std::endl;
743    }
744    else
745    {
746        unsigned int i = view.findSlaveIndexForCamera(cameraToPartition);
747        if (i>=view.getNumSlaves()) return false;
748
749        osg::View::Slave& slave = view.getSlave(i);
750
751        useMastersSceneData = slave._useMastersSceneData;
752        projectionOffset = slave._projectionOffset;
753        viewOffset = slave._viewOffset;
754
755        OSG_NOTICE<<"Replacing slave Camera"<<i<<std::endl;
756        view.removeSlave(i);
757    }
758
759    // far camera
760    {
761        osg::ref_ptr<osg::Camera> camera = new osg::Camera;
762        camera->setGraphicsContext(context.get());
763        camera->setViewport(viewport.get());
764
765        camera->setDrawBuffer(cameraToPartition->getDrawBuffer());
766        camera->setReadBuffer(cameraToPartition->getReadBuffer());
767
768        camera->setComputeNearFarMode(osg::Camera::DO_NOT_COMPUTE_NEAR_FAR);
769        camera->setCullingMode(osg::Camera::ENABLE_ALL_CULLING);
770
771        view.addSlave(camera.get());
772
773        osg::View::Slave& slave = view.getSlave(view.getNumSlaves()-1);
774
775        slave._useMastersSceneData = useMastersSceneData;
776        slave._projectionOffset = projectionOffset;
777        slave._viewOffset = viewOffset;
778        slave._updateSlaveCallback =  new MyUpdateSlaveCallback(dps, 1);
779    }
780
781    // near camera
782    {
783        osg::ref_ptr<osg::Camera> camera = new osg::Camera;
784        camera->setGraphicsContext(context.get());
785        camera->setViewport(viewport.get());
786
787        camera->setDrawBuffer(cameraToPartition->getDrawBuffer());
788        camera->setReadBuffer(cameraToPartition->getReadBuffer());
789
790        camera->setComputeNearFarMode(osg::Camera::DO_NOT_COMPUTE_NEAR_FAR);
791        camera->setCullingMode(osg::Camera::ENABLE_ALL_CULLING);
792        camera->setClearMask(GL_DEPTH_BUFFER_BIT);
793
794        view.addSlave(camera.get());
795
796        osg::View::Slave& slave = view.getSlave(view.getNumSlaves()-1);
797        slave._useMastersSceneData = useMastersSceneData;
798        slave._projectionOffset = projectionOffset;
799        slave._viewOffset = viewOffset;
800        slave._updateSlaveCallback =  new MyUpdateSlaveCallback(dps, 0);
801    }
802
803    return true;
804}
805
806
807typedef std::list< osg::ref_ptr<osg::Camera> > Cameras;
808
809Cameras getActiveCameras(osg::View& view)
810{
811    Cameras activeCameras;
812
813    if (view.getCamera() && view.getCamera()->getGraphicsContext())
814    {
815        activeCameras.push_back(view.getCamera());
816    }
817
818    for(unsigned int i=0; i<view.getNumSlaves(); ++i)
819    {
820        osg::View::Slave& slave = view.getSlave(i);
821        if (slave._camera.valid() && slave._camera->getGraphicsContext())
822        {
823            activeCameras.push_back(slave._camera.get());
824        }
825    }
826    return activeCameras;
827}
828
829
830bool setUpDepthPartition(osgViewer::View& view, DepthPartitionSettings* dsp)
831{
832    OSG_NOTICE<<"setUpDepthPartition(View,..)"<<std::endl;
833
834    Cameras originalCameras = getActiveCameras(view);
835    if (originalCameras.empty())
836    {
837        OSG_NOTICE<<"setUpDepthPartition(View,..) doing view.setUpViewAcrossAllScreens()"<<std::endl;
838        view.setUpViewAcrossAllScreens();
839
840        originalCameras = getActiveCameras(view);
841        if (originalCameras.empty())
842        {
843            OSG_NOTICE<<"setUpDepthPartition(View,..) Unable to set up windows for viewer."<<std::endl;
844            return false;
845        }
846    }
847
848    bool threadsWereRunning = view.getViewerBase()->areThreadsRunning();
849    if (threadsWereRunning) view.getViewerBase()->stopThreading();
850
851    for(Cameras::iterator itr = originalCameras.begin();
852        itr != originalCameras.end();
853        ++itr)
854    {
855        setUpDepthPartitionForCamera(view, itr->get(), dsp);
856    }
857
858    if (threadsWereRunning) view.getViewerBase()->startThreading();
859   
860    return true;
861}
862
863
864int main(int argc, char** argv)
865{
866    // use an ArgumentParser object to manage the program arguments.
867    osg::ArgumentParser arguments(&argc, argv);
868
869    // set up the usage document, in case we need to print out how to use this program.
870    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName() + " is the example which demonstrates using of GL_ARB_shadow extension implemented in osg::Texture class");
871    arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName());
872    arguments.getApplicationUsage()->addCommandLineOption("-h or --help", "Display this information");
873    arguments.getApplicationUsage()->addCommandLineOption("--positionalLight", "Use a positional light.");
874    arguments.getApplicationUsage()->addCommandLineOption("--directionalLight", "Use a direction light.");
875    arguments.getApplicationUsage()->addCommandLineOption("--noUpdate", "Disable the updating the of light source.");
876
877    arguments.getApplicationUsage()->addCommandLineOption("--castsShadowMask", "Override default castsShadowMask (default - 0x2)");
878    arguments.getApplicationUsage()->addCommandLineOption("--receivesShadowMask", "Override default receivesShadowMask (default - 0x1)");
879
880    arguments.getApplicationUsage()->addCommandLineOption("--base", "Add a base geometry to test shadows.");
881    arguments.getApplicationUsage()->addCommandLineOption("--sv", "Select ShadowVolume implementation.");
882    arguments.getApplicationUsage()->addCommandLineOption("--ssm", "Select SoftShadowMap implementation.");
883    arguments.getApplicationUsage()->addCommandLineOption("--sm", "Select ShadowMap implementation.");
884
885    arguments.getApplicationUsage()->addCommandLineOption("--pssm", "Select ParallelSplitShadowMap implementation.");//ADEGLI
886    arguments.getApplicationUsage()->addCommandLineOption("--mapcount", "ParallelSplitShadowMap texture count.");//ADEGLI
887    arguments.getApplicationUsage()->addCommandLineOption("--mapres", "ParallelSplitShadowMap texture resolution.");//ADEGLI
888    arguments.getApplicationUsage()->addCommandLineOption("--debug-color", "ParallelSplitShadowMap display debugging color (only the first 3 maps are color r=0,g=1,b=2.");//ADEGLI
889    arguments.getApplicationUsage()->addCommandLineOption("--minNearSplit", "ParallelSplitShadowMap shadow map near offset.");//ADEGLI
890    arguments.getApplicationUsage()->addCommandLineOption("--maxFarDist", "ParallelSplitShadowMap max far distance to shadow.");//ADEGLI
891    arguments.getApplicationUsage()->addCommandLineOption("--moveVCamFactor", "ParallelSplitShadowMap move the virtual frustum behind the real camera, (also back ground object can cast shadow).");//ADEGLI
892    arguments.getApplicationUsage()->addCommandLineOption("--PolyOffset-Factor", "ParallelSplitShadowMap set PolygonOffset factor.");//ADEGLI
893    arguments.getApplicationUsage()->addCommandLineOption("--PolyOffset-Unit", "ParallelSplitShadowMap set PolygonOffset unit.");//ADEGLI
894
895    arguments.getApplicationUsage()->addCommandLineOption("--lispsm", "Select LightSpacePerspectiveShadowMap implementation.");
896    arguments.getApplicationUsage()->addCommandLineOption("--msm", "Select MinimalShadowMap implementation.");
897    arguments.getApplicationUsage()->addCommandLineOption("--ViewBounds", "MSM, LiSPSM & optimize shadow for view frustum (weakest option)");
898    arguments.getApplicationUsage()->addCommandLineOption("--CullBounds", "MSM, LiSPSM & optimize shadow for bounds of culled objects in view frustum (better option).");
899    arguments.getApplicationUsage()->addCommandLineOption("--DrawBounds", "MSM, LiSPSM & optimize shadow for bounds of predrawn pixels in view frustum (best & default).");
900    arguments.getApplicationUsage()->addCommandLineOption("--mapres", "MSM, LiSPSM & texture resolution.");
901    arguments.getApplicationUsage()->addCommandLineOption("--maxFarDist", "MSM, LiSPSM & max far distance to shadow.");
902    arguments.getApplicationUsage()->addCommandLineOption("--moveVCamFactor", "MSM, LiSPSM & move the virtual frustum behind the real camera, (also back ground object can cast shadow).");
903    arguments.getApplicationUsage()->addCommandLineOption("--minLightMargin", "MSM, LiSPSM t& the same as --moveVCamFactor.");
904
905    arguments.getApplicationUsage()->addCommandLineOption("-1", "Use test model one.");
906    arguments.getApplicationUsage()->addCommandLineOption("-2", "Use test model two.");
907    arguments.getApplicationUsage()->addCommandLineOption("-3", "Use test model three (default).");
908    arguments.getApplicationUsage()->addCommandLineOption("-4", "Use test model four - island scene.");
909    arguments.getApplicationUsage()->addCommandLineOption("--two-sided", "Use two-sided stencil extension for shadow volumes.");
910    arguments.getApplicationUsage()->addCommandLineOption("--two-pass", "Use two-pass stencil for shadow volumes.");
911
912    // construct the viewer.
913    osgViewer::Viewer viewer(arguments);
914
915    // if user request help write it out to cout.
916    if (arguments.read("-h") || arguments.read("--help"))
917    {
918        arguments.getApplicationUsage()->write(std::cout);
919        return 1;
920    }
921
922    double partitionPosition = 5.0;
923    if (arguments.read("--depth-partition",partitionPosition) || arguments.read("--dp"))
924    {
925        // set up depth partitioning
926        osg::ref_ptr<DepthPartitionSettings> dps = new DepthPartitionSettings;
927        dps->_mode = DepthPartitionSettings::BOUNDING_VOLUME;
928        dps->_zNear = 0.5;
929        dps->_zMid = partitionPosition;
930        dps->_zFar = 1000.0;
931        setUpDepthPartition(viewer, dps.get());
932    }
933
934    float fov = 0.0;
935    while (arguments.read("--fov",fov)) {}
936
937    osg::Vec4 lightpos(0.0,0.0,1,0.0);
938    while (arguments.read("--positionalLight")) { lightpos.set(0.5,0.5,1.5,1.0); }
939    while (arguments.read("--directionalLight")) { lightpos.set(0.0,0.0,1,0.0); }
940
941    while ( arguments.read("--light-pos", lightpos.x(), lightpos.y(), lightpos.z(), lightpos.w())) {}
942    while ( arguments.read("--light-pos", lightpos.x(), lightpos.y(), lightpos.z())) { lightpos.w()=1.0; }
943    while ( arguments.read("--light-dir", lightpos.x(), lightpos.y(), lightpos.z())) { lightpos.w()=0.0; }
944
945
946    while (arguments.read("--castsShadowMask", CastsShadowTraversalMask ));
947    while (arguments.read("--receivesShadowMask", ReceivesShadowTraversalMask ));
948
949    bool updateLightPosition = true;
950    while (arguments.read("--noUpdate")) updateLightPosition = false;
951
952    // set up the camera manipulators.
953    {
954        osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator = new osgGA::KeySwitchMatrixManipulator;
955
956        keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new osgGA::TrackballManipulator() );
957        keyswitchManipulator->addMatrixManipulator( '2', "Flight", new osgGA::FlightManipulator() );
958        keyswitchManipulator->addMatrixManipulator( '3', "Drive", new osgGA::DriveManipulator() );
959        keyswitchManipulator->addMatrixManipulator( '4', "Terrain", new osgGA::TerrainManipulator() );
960
961        std::string pathfile;
962        char keyForAnimationPath = '5';
963        while (arguments.read("-p",pathfile))
964        {
965            osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
966            if (apm || !apm->valid())
967            {
968                unsigned int num = keyswitchManipulator->getNumMatrixManipulators();
969                keyswitchManipulator->addMatrixManipulator( keyForAnimationPath, "Path", apm );
970                keyswitchManipulator->selectMatrixManipulator(num);
971                ++keyForAnimationPath;
972            }
973        }
974
975        viewer.setCameraManipulator( keyswitchManipulator.get() );
976    }
977
978    // add the state manipulator
979    viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
980
981    // add stats
982    viewer.addEventHandler( new osgViewer::StatsHandler() );
983
984    // add the record camera path handler
985    viewer.addEventHandler(new osgViewer::RecordCameraPathHandler);
986
987    // add the window size toggle handler
988    viewer.addEventHandler(new osgViewer::WindowSizeHandler);
989
990    // add the threading handler
991    viewer.addEventHandler( new osgViewer::ThreadingHandler() );
992
993    osg::ref_ptr<osgShadow::ShadowedScene> shadowedScene = new osgShadow::ShadowedScene;
994
995    shadowedScene->setReceivesShadowTraversalMask(ReceivesShadowTraversalMask);
996    shadowedScene->setCastsShadowTraversalMask(CastsShadowTraversalMask);
997
998    osg::ref_ptr<osgShadow::MinimalShadowMap> msm = NULL;
999    if (arguments.read("--no-shadows"))
1000    {
1001        OSG_NOTICE<<"Not using a ShadowTechnique"<<std::endl;
1002        shadowedScene->setShadowTechnique(0);
1003    }
1004    else if (arguments.read("--sv"))
1005    {
1006        // hint to tell viewer to request stencil buffer when setting up windows
1007        osg::DisplaySettings::instance()->setMinimumNumStencilBits(8);
1008
1009        osg::ref_ptr<osgShadow::ShadowVolume> sv = new osgShadow::ShadowVolume;
1010        sv->setDynamicShadowVolumes(updateLightPosition);
1011        while (arguments.read("--two-sided")) sv->setDrawMode(osgShadow::ShadowVolumeGeometry::STENCIL_TWO_SIDED);
1012        while (arguments.read("--two-pass")) sv->setDrawMode(osgShadow::ShadowVolumeGeometry::STENCIL_TWO_PASS);
1013
1014        shadowedScene->setShadowTechnique(sv.get());
1015    }
1016    else if (arguments.read("--st"))
1017    {
1018        osg::ref_ptr<osgShadow::ShadowTexture> st = new osgShadow::ShadowTexture;
1019        shadowedScene->setShadowTechnique(st.get());
1020    }
1021    else if (arguments.read("--stsm"))
1022    {
1023        osg::ref_ptr<osgShadow::StandardShadowMap> st = new osgShadow::StandardShadowMap;
1024        shadowedScene->setShadowTechnique(st.get());
1025    }
1026    else if (arguments.read("--pssm"))
1027    {
1028        int mapcount = 3;
1029        while (arguments.read("--mapcount", mapcount));
1030        osg::ref_ptr<osgShadow::ParallelSplitShadowMap> pssm = new osgShadow::ParallelSplitShadowMap(NULL,mapcount);
1031
1032        int mapres = 1024;
1033        while (arguments.read("--mapres", mapres))
1034            pssm->setTextureResolution(mapres);
1035
1036        while (arguments.read("--debug-color")) { pssm->setDebugColorOn(); }
1037
1038
1039        int minNearSplit=0;
1040        while (arguments.read("--minNearSplit", minNearSplit))
1041            if ( minNearSplit > 0 ) {
1042                pssm->setMinNearDistanceForSplits(minNearSplit);
1043                std::cout << "ParallelSplitShadowMap : setMinNearDistanceForSplits(" << minNearSplit <<")" << std::endl;
1044            }
1045
1046        int maxfardist = 0;
1047        while (arguments.read("--maxFarDist", maxfardist))
1048            if ( maxfardist > 0 ) {
1049                pssm->setMaxFarDistance(maxfardist);
1050                std::cout << "ParallelSplitShadowMap : setMaxFarDistance(" << maxfardist<<")" << std::endl;
1051            }
1052
1053        int moveVCamFactor = 0;
1054        while (arguments.read("--moveVCamFactor", moveVCamFactor))
1055            if ( maxfardist > 0 ) {
1056                pssm->setMoveVCamBehindRCamFactor(moveVCamFactor);
1057                std::cout << "ParallelSplitShadowMap : setMoveVCamBehindRCamFactor(" << moveVCamFactor<<")" << std::endl;
1058            }
1059
1060
1061       
1062        double polyoffsetfactor = pssm->getPolygonOffset().x();
1063        double polyoffsetunit   = pssm->getPolygonOffset().y();
1064        while (arguments.read("--PolyOffset-Factor", polyoffsetfactor));
1065        while (arguments.read("--PolyOffset-Unit", polyoffsetunit));
1066        pssm->setPolygonOffset(osg::Vec2(polyoffsetfactor,polyoffsetunit));
1067
1068        shadowedScene->setShadowTechnique(pssm.get());
1069    }
1070    else if (arguments.read("--ssm"))
1071    {
1072        osg::ref_ptr<osgShadow::SoftShadowMap> sm = new osgShadow::SoftShadowMap;
1073        shadowedScene->setShadowTechnique(sm.get());
1074    }
1075    else if ( arguments.read("--lispsm") )
1076    {
1077        if( arguments.read( "--ViewBounds" ) )
1078            msm = new osgShadow::LightSpacePerspectiveShadowMapVB;
1079        else if( arguments.read( "--CullBounds" ) )
1080            msm = new osgShadow::LightSpacePerspectiveShadowMapCB;
1081        else // if( arguments.read( "--DrawBounds" ) ) // default
1082            msm = new osgShadow::LightSpacePerspectiveShadowMapDB;
1083    }
1084    else if( arguments.read("--msm") )
1085    {
1086       if( arguments.read( "--ViewBounds" ) )
1087            msm = new osgShadow::MinimalShadowMap;
1088       else if( arguments.read( "--CullBounds" ) )
1089            msm = new osgShadow::MinimalCullBoundsShadowMap;
1090       else // if( arguments.read( "--DrawBounds" ) ) // default
1091            msm = new osgShadow::MinimalDrawBoundsShadowMap;
1092    }
1093    else /* if (arguments.read("--sm")) */
1094    {
1095        osg::ref_ptr<osgShadow::ShadowMap> sm = new osgShadow::ShadowMap;
1096        shadowedScene->setShadowTechnique(sm.get());
1097
1098        int mapres = 1024;
1099        while (arguments.read("--mapres", mapres))
1100            sm->setTextureSize(osg::Vec2s(mapres,mapres));
1101    }
1102
1103    if( msm )// Set common MSM & LISPSM arguments
1104    {
1105        shadowedScene->setShadowTechnique( msm.get() );
1106        while( arguments.read("--debugHUD") )           
1107            msm->setDebugDraw( true );
1108
1109        float minLightMargin = 10.f;
1110        float maxFarPlane = 0;
1111        unsigned int texSize = 1024;
1112        unsigned int baseTexUnit = 0;
1113        unsigned int shadowTexUnit = 1;
1114
1115        while ( arguments.read("--moveVCamFactor", minLightMargin ) );
1116        while ( arguments.read("--minLightMargin", minLightMargin ) );
1117        while ( arguments.read("--maxFarDist", maxFarPlane ) );
1118        while ( arguments.read("--mapres", texSize ));
1119        while ( arguments.read("--baseTextureUnit", baseTexUnit) );
1120        while ( arguments.read("--shadowTextureUnit", shadowTexUnit) );
1121
1122        msm->setMinLightMargin( minLightMargin );
1123        msm->setMaxFarPlane( maxFarPlane );
1124        msm->setTextureSize( osg::Vec2s( texSize, texSize ) );
1125        msm->setShadowTextureCoordIndex( shadowTexUnit );
1126        msm->setShadowTextureUnit( shadowTexUnit );
1127        msm->setBaseTextureCoordIndex( baseTexUnit );
1128        msm->setBaseTextureUnit( baseTexUnit );
1129    }
1130
1131    OSG_NOTICE<<"shadowedScene->getShadowTechnique()="<<shadowedScene->getShadowTechnique()<<std::endl;
1132
1133    osg::ref_ptr<osg::Node> model = osgDB::readNodeFiles(arguments);
1134    if (model.valid())
1135    {
1136        model->setNodeMask(CastsShadowTraversalMask | ReceivesShadowTraversalMask);
1137    }
1138    else
1139    {
1140        model = createTestModel(arguments);
1141    }
1142
1143    // get the bounds of the model.
1144    osg::ComputeBoundsVisitor cbbv;
1145    model->accept(cbbv);
1146    osg::BoundingBox bb = cbbv.getBoundingBox();
1147
1148    if (lightpos.w()==1.0)
1149    {
1150        lightpos.x() = bb.xMin()+(bb.xMax()-bb.xMin())*lightpos.x();
1151        lightpos.y() = bb.yMin()+(bb.yMax()-bb.yMin())*lightpos.y();
1152        lightpos.z() = bb.zMin()+(bb.zMax()-bb.zMin())*lightpos.z();
1153    }
1154     
1155    if ( arguments.read("--base"))
1156    {
1157
1158        osg::Geode* geode = new osg::Geode;
1159
1160        osg::Vec3 widthVec(bb.radius(), 0.0f, 0.0f);
1161        osg::Vec3 depthVec(0.0f, bb.radius(), 0.0f);
1162        osg::Vec3 centerBase( (bb.xMin()+bb.xMax())*0.5f, (bb.yMin()+bb.yMax())*0.5f, bb.zMin()-bb.radius()*0.1f );
1163
1164        geode->addDrawable( osg::createTexturedQuadGeometry( centerBase-widthVec*1.5f-depthVec*1.5f,
1165                                                             widthVec*3.0f, depthVec*3.0f) );
1166
1167        geode->setNodeMask(shadowedScene->getReceivesShadowTraversalMask());
1168
1169        geode->getOrCreateStateSet()->setTextureAttributeAndModes(0, new osg::Texture2D(osgDB::readImageFile("Images/lz.rgb")));
1170
1171        shadowedScene->addChild(geode);
1172    }
1173
1174    osg::ref_ptr<osg::LightSource> ls = new osg::LightSource;
1175    ls->getLight()->setPosition(lightpos);
1176
1177    bool spotlight = false;
1178    if (arguments.read("--spotLight"))
1179    {
1180        spotlight = true;
1181
1182        osg::Vec3 center = bb.center();
1183        osg::Vec3 lightdir = center - osg::Vec3(lightpos.x(), lightpos.y(), lightpos.z());
1184        lightdir.normalize();
1185        ls->getLight()->setDirection(lightdir);
1186        ls->getLight()->setSpotCutoff(25.0f);
1187
1188        //set the LightSource, only for checking, there is only 1 light in the scene
1189        osgShadow::ShadowMap* shadowMap = dynamic_cast<osgShadow::ShadowMap*>(shadowedScene->getShadowTechnique());
1190        if( shadowMap ) shadowMap->setLight(ls.get());
1191    }
1192
1193    if ( arguments.read("--coloured-light"))
1194    {
1195        ls->getLight()->setAmbient(osg::Vec4(1.0,0.0,0.0,1.0));
1196        ls->getLight()->setDiffuse(osg::Vec4(0.0,1.0,0.0,1.0));
1197    }
1198    else
1199    {
1200        ls->getLight()->setAmbient(osg::Vec4(0.2,0.2,0.2,1.0));
1201        ls->getLight()->setDiffuse(osg::Vec4(0.8,0.8,0.8,1.0));
1202    }
1203
1204    shadowedScene->addChild(model.get());
1205    shadowedScene->addChild(ls.get());
1206
1207    viewer.setSceneData(shadowedScene.get());
1208
1209    osg::ref_ptr< DumpShadowVolumesHandler > dumpShadowVolumes = new DumpShadowVolumesHandler;
1210
1211    viewer.addEventHandler(new ChangeFOVHandler(viewer.getCamera()));
1212    viewer.addEventHandler( dumpShadowVolumes.get() );
1213
1214    // create the windows and run the threads.
1215    viewer.realize();
1216
1217    if (fov!=0.0)
1218    {
1219        double fovy, aspectRatio, zNear, zFar;
1220        viewer.getCamera()->getProjectionMatrix().getPerspective(fovy, aspectRatio, zNear, zFar);
1221
1222        std::cout << "Setting FOV to " << fov << std::endl;
1223        viewer.getCamera()->getProjectionMatrix().makePerspective(fov, aspectRatio, zNear, zFar);
1224    }
1225
1226    // it is done after viewer.realize() so that the windows are already initialized
1227    if ( arguments.read("--debugHUD"))
1228    {
1229        osgViewer::Viewer::Windows windows;
1230        viewer.getWindows(windows);
1231
1232        if (windows.empty()) return 1;
1233
1234        osgShadow::ShadowMap* sm = dynamic_cast<osgShadow::ShadowMap*>(shadowedScene->getShadowTechnique());
1235        if( sm ) {
1236            osg::ref_ptr<osg::Camera> hudCamera = sm->makeDebugHUD();
1237
1238            // set up cameras to rendering on the first window available.
1239            hudCamera->setGraphicsContext(windows[0]);
1240            hudCamera->setViewport(0,0,windows[0]->getTraits()->width, windows[0]->getTraits()->height);
1241
1242            viewer.addSlave(hudCamera.get(), false);
1243        }
1244    }
1245
1246
1247    // osgDB::writeNodeFile(*group,"test.osg");
1248 
1249    while (!viewer.done())
1250    {
1251        {
1252            osgShadow::MinimalShadowMap * msm = dynamic_cast<osgShadow::MinimalShadowMap*>( shadowedScene->getShadowTechnique() );
1253   
1254            if( msm ) {
1255
1256                // If scene decorated by CoordinateSystemNode try to find localToWorld
1257                // and set modellingSpaceToWorld matrix to optimize scene bounds computation
1258
1259                osg::NodePath np = viewer.getCoordinateSystemNodePath();
1260                if( !np.empty() ) {
1261                    osg::CoordinateSystemNode * csn =
1262                        dynamic_cast<osg::CoordinateSystemNode *>( np.back() );
1263
1264                    if( csn ) {
1265                        osg::Vec3d pos =
1266                            viewer.getCameraManipulator()->getMatrix().getTrans();
1267
1268                        msm->setModellingSpaceToWorldTransform
1269                            ( csn->computeLocalCoordinateFrame( pos ) );
1270                    }
1271                }
1272            }       
1273        }
1274
1275        if (updateLightPosition)
1276        {
1277            float t = viewer.getFrameStamp()->getSimulationTime();
1278
1279            if (lightpos.w()==1.0)
1280            {
1281                lightpos.set(bb.center().x()+sinf(t)*bb.radius(), bb.center().y() + cosf(t)*bb.radius(), bb.zMax() + bb.radius()*3.0f  ,1.0f);
1282            }
1283            else
1284            {
1285                lightpos.set(sinf(t),cosf(t),1.0f,0.0f);
1286            }
1287            ls->getLight()->setPosition(lightpos);
1288
1289            osg::Vec3f lightDir(-lightpos.x(),-lightpos.y(),-lightpos.z());
1290            if(spotlight)
1291                lightDir =  osg::Vec3(bb.center().x()+sinf(t)*bb.radius()/2.0, bb.center().y() + cosf(t)*bb.radius()/2.0, bb.center().z())
1292                - osg::Vec3(lightpos.x(), lightpos.y(), lightpos.z()) ;
1293            lightDir.normalize();
1294            ls->getLight()->setDirection(lightDir);
1295        }
1296
1297        if( dumpShadowVolumes->get() )
1298        {
1299            dumpShadowVolumes->set( false );
1300
1301            static int dumpFileNo = 0;
1302            dumpFileNo ++;
1303            char filename[256];
1304            std::sprintf( filename, "shadowDump%d.osg", dumpFileNo );
1305           
1306            osgShadow::MinimalShadowMap * msm = dynamic_cast<osgShadow::MinimalShadowMap*>( shadowedScene->getShadowTechnique() );
1307
1308            if( msm ) msm->setDebugDump( filename );           
1309        }
1310
1311        viewer.frame();
1312    }
1313
1314    return 0;
1315}
Note: See TracBrowser for help on using the browser.