root/OpenSceneGraph/trunk/examples/osgmovie/osgmovie.cpp @ 7475

Revision 7475, 27.2 kB (checked in by robert, 7 years ago)

Preliminary PanoramicSphericalScreen? support

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* OpenSceneGraph example, osgmovie.
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 <osgViewer/Viewer>
20#include <osgViewer/ViewerEventHandlers>
21
22#include <osgDB/ReadFile>
23
24#include <osg/Geode>
25#include <osg/Geometry>
26#include <osg/StateSet>
27#include <osg/Material>
28#include <osg/Texture2D>
29#include <osg/TextureRectangle>
30#include <osg/TextureCubeMap>
31#include <osg/TexMat>
32#include <osg/CullFace>
33#include <osg/ImageStream>
34#include <osg/io_utils>
35
36#include <osgGA/TrackballManipulator>
37#include <osgGA/EventVisitor>
38
39#include <iostream>
40
41osg::ImageStream* s_imageStream = 0;
42class MovieEventHandler : public osgGA::GUIEventHandler
43{
44public:
45
46    MovieEventHandler():_trackMouse(false) {}
47   
48    void setMouseTracking(bool track) { _trackMouse = track; }
49    bool getMouseTracking() const { return _trackMouse; }
50   
51    void set(osg::Node* node);
52
53    virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa, osg::Object*, osg::NodeVisitor* nv);
54   
55    virtual void getUsage(osg::ApplicationUsage& usage) const;
56
57    typedef std::vector< osg::ref_ptr<osg::ImageStream> > ImageStreamList;
58
59protected:
60
61    virtual ~MovieEventHandler() {}
62
63    class FindImageStreamsVisitor : public osg::NodeVisitor
64    {
65    public:
66        FindImageStreamsVisitor(ImageStreamList& imageStreamList):
67            _imageStreamList(imageStreamList) {}
68           
69        virtual void apply(osg::Geode& geode)
70        {
71            apply(geode.getStateSet());
72
73            for(unsigned int i=0;i<geode.getNumDrawables();++i)
74            {
75                apply(geode.getDrawable(i)->getStateSet());
76            }
77       
78            traverse(geode);
79        }
80
81        virtual void apply(osg::Node& node)
82        {
83            apply(node.getStateSet());
84            traverse(node);
85        }
86       
87        inline void apply(osg::StateSet* stateset)
88        {
89            if (!stateset) return;
90           
91            osg::StateAttribute* attr = stateset->getTextureAttribute(0,osg::StateAttribute::TEXTURE);
92            if (attr)
93            {
94                osg::Texture2D* texture2D = dynamic_cast<osg::Texture2D*>(attr);
95                if (texture2D) apply(dynamic_cast<osg::ImageStream*>(texture2D->getImage()));
96
97                osg::TextureRectangle* textureRec = dynamic_cast<osg::TextureRectangle*>(attr);
98                if (textureRec) apply(dynamic_cast<osg::ImageStream*>(textureRec->getImage()));
99            }
100        }
101       
102        inline void apply(osg::ImageStream* imagestream)
103        {
104            if (imagestream)
105            {
106                _imageStreamList.push_back(imagestream);
107                s_imageStream = imagestream;
108            }
109        }
110       
111        ImageStreamList& _imageStreamList;
112    };
113
114
115    bool            _trackMouse;
116    ImageStreamList _imageStreamList;
117   
118};
119
120
121
122void MovieEventHandler::set(osg::Node* node)
123{
124    _imageStreamList.clear();
125    if (node)
126    {
127        FindImageStreamsVisitor fisv(_imageStreamList);
128        node->accept(fisv);
129    }
130}
131
132
133bool MovieEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa, osg::Object*, osg::NodeVisitor* nv)
134{
135    switch(ea.getEventType())
136    {
137        case(osgGA::GUIEventAdapter::MOVE):
138        case(osgGA::GUIEventAdapter::PUSH):
139        case(osgGA::GUIEventAdapter::RELEASE):
140        {
141            if (_trackMouse)
142            {
143                osgViewer::View* view = dynamic_cast<osgViewer::View*>(&aa);
144                osgUtil::LineSegmentIntersector::Intersections intersections;
145                if (view && view->computeIntersections(ea.getX(), ea.getY(), nv->getNodePath(), intersections))
146                {
147
148                    // use the nearest intersection                 
149                    const osgUtil::LineSegmentIntersector::Intersection& intersection = *(intersections.begin());
150                    osg::Drawable* drawable = intersection.drawable.get();
151                    osg::Geometry* geometry = drawable ? drawable->asGeometry() : 0;
152                    osg::Vec3Array* vertices = geometry ? dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray()) : 0;
153                    if (vertices)
154                    {
155                        // get the vertex indices.
156                        const osgUtil::LineSegmentIntersector::Intersection::IndexList& indices = intersection.indexList;
157                        const osgUtil::LineSegmentIntersector::Intersection::RatioList& ratios = intersection.ratioList;
158
159                        if (indices.size()==3 && ratios.size()==3)
160                        {
161                            unsigned int i1 = indices[0];
162                            unsigned int i2 = indices[1];
163                            unsigned int i3 = indices[2];
164
165                            float r1 = ratios[0];
166                            float r2 = ratios[1];
167                            float r3 = ratios[2];
168
169                            osg::Array* texcoords = (geometry->getNumTexCoordArrays()>0) ? geometry->getTexCoordArray(0) : 0;
170                            osg::Vec2Array* texcoords_Vec2Array = dynamic_cast<osg::Vec2Array*>(texcoords);
171                            if (texcoords_Vec2Array)
172                            {
173                                // we have tex coord array so now we can compute the final tex coord at the point of intersection.                               
174                                osg::Vec2 tc1 = (*texcoords_Vec2Array)[i1];
175                                osg::Vec2 tc2 = (*texcoords_Vec2Array)[i2];
176                                osg::Vec2 tc3 = (*texcoords_Vec2Array)[i3];
177                                osg::Vec2 tc = tc1*r1 + tc2*r2 + tc3*r3;
178
179                                osg::notify(osg::NOTICE)<<"We hit tex coords "<<tc<<std::endl;
180
181                            }
182                        }
183                        else
184                        {
185                            osg::notify(osg::NOTICE)<<"Intersection has insufficient indices to work with";
186                        }
187
188                    }
189                }
190                else
191                {
192                    osg::notify(osg::NOTICE)<<"No intersection"<<std::endl;
193                }
194            }
195            break;
196        }
197        case(osgGA::GUIEventAdapter::KEYDOWN):
198        {
199            if (ea.getKey()=='s')
200            {
201                for(ImageStreamList::iterator itr=_imageStreamList.begin();
202                    itr!=_imageStreamList.end();
203                    ++itr)
204                {
205                    std::cout<<"Play"<<std::endl;
206                     (*itr)->play();
207                }
208                return true;
209            }
210            else if (ea.getKey()=='p')
211            {
212                for(ImageStreamList::iterator itr=_imageStreamList.begin();
213                    itr!=_imageStreamList.end();
214                    ++itr)
215                {
216                    std::cout<<"Pause"<<std::endl;
217                    (*itr)->pause();
218                }
219                return true;
220            }
221            else if (ea.getKey()=='r')
222            {
223                for(ImageStreamList::iterator itr=_imageStreamList.begin();
224                    itr!=_imageStreamList.end();
225                    ++itr)
226                {
227                    std::cout<<"Restart"<<std::endl;
228                    (*itr)->rewind();
229                    (*itr)->play();
230                }
231                return true;
232            }
233            else if (ea.getKey()=='l')
234            {
235                for(ImageStreamList::iterator itr=_imageStreamList.begin();
236                    itr!=_imageStreamList.end();
237                    ++itr)
238                {
239                    if ( (*itr)->getLoopingMode() == osg::ImageStream::LOOPING)
240                    {
241                        std::cout<<"Toggle Looping Off"<<std::endl;
242                        (*itr)->setLoopingMode( osg::ImageStream::NO_LOOPING );
243                    }
244                    else
245                    {
246                        std::cout<<"Toggle Looping On"<<std::endl;
247                        (*itr)->setLoopingMode( osg::ImageStream::LOOPING );
248                    }
249                }
250                return true;
251            }
252            return false;
253        }
254
255        default:
256            return false;
257    }
258    return false;
259}
260
261void MovieEventHandler::getUsage(osg::ApplicationUsage& usage) const
262{
263    usage.addKeyboardMouseBinding("p","Pause movie");
264    usage.addKeyboardMouseBinding("s","Play movie");
265    usage.addKeyboardMouseBinding("r","Restart movie");
266    usage.addKeyboardMouseBinding("l","Toggle looping of movie");
267}
268
269
270osg::Geometry* myCreateTexturedQuadGeometry(const osg::Vec3& pos,float width,float height, osg::Image* image, bool useTextureRectangle)
271{
272    bool flip = image->getOrigin()==osg::Image::TOP_LEFT;
273    if (useTextureRectangle)
274    {
275        osg::Geometry* pictureQuad = osg::createTexturedQuadGeometry(pos,
276                                           osg::Vec3(width,0.0f,0.0f),
277                                           osg::Vec3(0.0f,0.0f,height),
278                                           0.0f, flip ? image->t() : 0.0, image->s(), flip ? 0.0 : image->t());
279
280        osg::TextureRectangle* texture = new osg::TextureRectangle(image);
281        texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
282        texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
283       
284       
285        pictureQuad->getOrCreateStateSet()->setTextureAttributeAndModes(0,
286                                                                        texture,
287                                                                        osg::StateAttribute::ON);
288       
289        return pictureQuad;
290    }
291    else
292    {
293        osg::Geometry* pictureQuad = osg::createTexturedQuadGeometry(pos,
294                                           osg::Vec3(width,0.0f,0.0f),
295                                           osg::Vec3(0.0f,0.0f,height),
296                                           0.0f, flip ? 1.0f : 0.0f , 1.0f, flip ? 0.0f : 1.0f);
297                                   
298        osg::Texture2D* texture = new osg::Texture2D(image);
299        texture->setFilter(osg::Texture::MIN_FILTER,osg::Texture::LINEAR);
300        texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
301        texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
302       
303       
304        pictureQuad->getOrCreateStateSet()->setTextureAttributeAndModes(0,
305                    texture,
306                    osg::StateAttribute::ON);
307
308        return pictureQuad;
309    }
310}
311
312class DomeModel
313{
314public:
315
316    DomeModel(osg::ArgumentParser& arguments):
317        sphere_radius(1.0),
318        collar_radius(0.45),
319        rotationDegrees(180.0),
320        distance(0.0),
321        flip(false),
322        texcoord_flip(false)
323    {
324        if (arguments.read("--radius", sphere_radius)) {}
325        if (arguments.read("--collar", collar_radius)) {}
326        if (arguments.read("--rotation", rotationDegrees)) {}
327
328        distance = sqrt(sphere_radius*sphere_radius - collar_radius*collar_radius);
329        if (arguments.read("--distance", distance)) {}
330
331        if (arguments.read("--flip")) { flip = true; }
332    }
333   
334    double sphere_radius;
335    double collar_radius;
336    double rotationDegrees;
337    double distance;
338    bool flip;
339    bool texcoord_flip;
340
341};
342
343
344osg::Geometry* createDomeDistortionMesh(const osg::Vec3& origin, const osg::Vec3& widthVector, const osg::Vec3& heightVector, DomeModel& domeModel)
345{
346    osg::Vec3d center(0.0,0.0,0.0);
347    osg::Vec3d eye(0.0,0.0,0.0);
348   
349    bool centerProjection = false;
350
351    osg::Vec3d projector = eye - osg::Vec3d(0.0,0.0, domeModel.distance);
352   
353   
354    osg::notify(osg::NOTICE)<<"Projector position = "<<projector<<std::endl;
355    osg::notify(osg::NOTICE)<<"distance = "<<domeModel.distance<<std::endl;
356
357
358    // create the quad to visualize.
359    osg::Geometry* geometry = new osg::Geometry();
360
361    geometry->setSupportsDisplayList(false);
362
363    osg::Vec3 xAxis(widthVector);
364    float width = widthVector.length();
365    xAxis /= width;
366
367    osg::Vec3 yAxis(heightVector);
368    float height = heightVector.length();
369    yAxis /= height;
370   
371    int noSteps = 160;
372
373    osg::Vec3Array* vertices = new osg::Vec3Array;
374    osg::Vec2Array* texcoords = new osg::Vec2Array;
375    osg::Vec4Array* colors = new osg::Vec4Array;
376
377    osg::Vec3 bottom = origin;
378    osg::Vec3 dx = xAxis*(width/((float)(noSteps-2)));
379    osg::Vec3 dy = yAxis*(height/((float)(noSteps-1)));
380   
381    osg::Vec3 top = origin + yAxis*height;
382
383    osg::Vec3d screenCenter = origin + widthVector*0.5f + heightVector*0.5f;
384    float screenRadius = heightVector.length() * 0.5f;
385
386    double rotation = osg::DegreesToRadians(domeModel.rotationDegrees);
387
388    osg::Vec3 cursor = bottom;
389    int i,j;
390   
391    int midSteps = noSteps/2;
392   
393    for(i=0;i<midSteps;++i)
394    {
395        osg::Vec3 cursor = bottom+dy*(float)i;
396        for(j=0;j<midSteps;++j)
397        {
398            osg::Vec2 delta(cursor.x() - screenCenter.x(), cursor.y() - screenCenter.y());
399            double theta = atan2(delta.x(), -delta.y());
400            theta += 2*osg::PI;
401
402            double phi = osg::PI_2 * delta.length() / screenRadius;
403            if (phi > osg::PI_2) phi = osg::PI_2;
404
405            double f = domeModel.distance * sin(phi);
406            double e = domeModel.distance * cos(phi) + sqrt( domeModel.sphere_radius*domeModel.sphere_radius - f*f);
407            double l = e * cos(phi);
408            double h = e * sin(phi);
409            double gamma = atan2(h, l-domeModel.distance);
410
411            osg::Vec2 texcoord(theta/(2.0*osg::PI), 1.0-gamma/osg::PI);
412
413            // osg::notify(osg::NOTICE)<<"cursor = "<<cursor<< " theta = "<<theta<< "phi="<<phi<<" gamma = "<<gamma<<" texcoord="<<texcoord<<std::endl;
414
415            if (domeModel.flip)
416                vertices->push_back(osg::Vec3(cursor.x(), top.y()-(cursor.y()-origin.y()),cursor.z()));
417            else
418                vertices->push_back(cursor);
419           
420            colors->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
421            texcoords->push_back( domeModel.texcoord_flip ? osg::Vec2(texcoord.x(), 1.0f - texcoord.y()) : texcoord);
422
423            if (j+1<midSteps) cursor += dx;
424        }
425
426        for(;j<noSteps;++j)
427        {
428            osg::Vec2 delta(cursor.x() - screenCenter.x(), cursor.y() - screenCenter.y());
429            double theta = atan2(delta.x(), -delta.y());
430            double phi = osg::PI_2 * delta.length() / screenRadius;
431            if (phi > osg::PI_2) phi = osg::PI_2;
432
433            double f = domeModel.distance * sin(phi);
434            double e = domeModel.distance * cos(phi) + sqrt( domeModel.sphere_radius*domeModel.sphere_radius - f*f);
435            double l = e * cos(phi);
436            double h = e * sin(phi);
437            double gamma = atan2(h, l-domeModel.distance);
438
439            osg::Vec2 texcoord(theta/(2.0*osg::PI), 1.0-gamma/osg::PI);
440
441            // osg::notify(osg::NOTICE)<<"cursor = "<<cursor<< " theta = "<<theta<< "phi="<<phi<<" gamma = "<<gamma<<" texcoord="<<texcoord<<std::endl;
442
443            if (domeModel.flip)
444                vertices->push_back(osg::Vec3(cursor.x(), top.y()-(cursor.y()-origin.y()),cursor.z()));
445            else
446                vertices->push_back(cursor);
447
448            colors->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
449            texcoords->push_back( domeModel.texcoord_flip ? osg::Vec2(texcoord.x(), 1.0f - texcoord.y()) : texcoord);
450
451            cursor += dx;
452        }
453        // osg::notify(osg::NOTICE)<<std::endl;
454    }
455   
456    for(;i<noSteps;++i)
457    {
458        osg::Vec3 cursor = bottom+dy*(float)i;
459        for(j=0;j<noSteps;++j)
460        {
461            osg::Vec2 delta(cursor.x() - screenCenter.x(), cursor.y() - screenCenter.y());
462            double theta = atan2(delta.x(), -delta.y());
463            if (theta<0.0) theta += 2*osg::PI;
464            double phi = osg::PI_2 * delta.length() / screenRadius;
465            if (phi > osg::PI_2) phi = osg::PI_2;
466
467            double f = domeModel.distance * sin(phi);
468            double e = domeModel.distance * cos(phi) + sqrt( domeModel.sphere_radius*domeModel.sphere_radius - f*f);
469            double l = e * cos(phi);
470            double h = e * sin(phi);
471            double gamma = atan2(h, l-domeModel.distance);
472
473            osg::Vec2 texcoord(theta/(2.0*osg::PI), 1.0-gamma/osg::PI);
474
475            // osg::notify(osg::NOTICE)<<"cursor = "<<cursor<< " theta = "<<theta<< "phi="<<phi<<" gamma = "<<gamma<<" texcoord="<<texcoord<<std::endl;
476
477            if (domeModel.flip)
478                vertices->push_back(osg::Vec3(cursor.x(), top.y()-(cursor.y()-origin.y()),cursor.z()));
479            else
480                vertices->push_back(cursor);
481
482            colors->push_back(osg::Vec4(1.0f,1.0f,1.0f,1.0f));
483            texcoords->push_back( domeModel.texcoord_flip ? osg::Vec2(texcoord.x(), 1.0f - texcoord.y()) : texcoord);
484
485            cursor += dx;
486        }
487
488        // osg::notify(osg::NOTICE)<<std::endl;
489    }
490
491    // pass the created vertex array to the points geometry object.
492    geometry->setVertexArray(vertices);
493
494    geometry->setColorArray(colors);
495    geometry->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
496
497    geometry->setTexCoordArray(0,texcoords);
498
499    for(i=0;i<noSteps-1;++i)
500    {
501        osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(osg::PrimitiveSet::QUAD_STRIP);
502        for(j=0;j<noSteps;++j)
503        {
504            elements->push_back(j+(i+1)*noSteps);
505            elements->push_back(j+(i)*noSteps);
506        }
507        geometry->addPrimitiveSet(elements);
508    }
509   
510    return geometry;
511}
512
513
514void setDomeCorrection(osgViewer::Viewer& viewer, osg::ArgumentParser& arguments)
515{
516    // enforce single threading right now to avoid double buffering of RTT texture
517    viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
518 
519    osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
520    if (!wsi)
521    {
522        osg::notify(osg::NOTICE)<<"Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
523        return;
524    }
525
526    unsigned int screenNum = 0;
527    while (arguments.read("--screen",screenNum)) {}
528
529
530    unsigned int width, height;
531    wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(screenNum), width, height);
532
533    while (arguments.read("--width",width)) {}
534    while (arguments.read("--height",height)) {}
535
536    DomeModel domeModel(arguments);
537
538    osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
539    traits->screenNum = screenNum;
540    traits->x = 0;
541    traits->y = 0;
542    traits->width = width;
543    traits->height = height;
544    traits->windowDecoration = false;
545    traits->doubleBuffer = true;
546    traits->sharedContext = 0;
547   
548   
549
550    osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
551    if (!gc)
552    {
553        osg::notify(osg::NOTICE)<<"GraphicsWindow has not been created successfully."<<std::endl;
554        return;
555    }
556
557    osg::Texture* texture = 0;
558    for(int i=1;i<arguments.argc() && !texture;++i)
559    {
560        if (arguments.isString(i))
561        {
562            osg::Image* image = osgDB::readImageFile(arguments[i]);
563            osg::ImageStream* imagestream = dynamic_cast<osg::ImageStream*>(image);
564            if (imagestream) imagestream->play();
565
566            if (image)
567            {
568                domeModel.texcoord_flip = image->getOrigin()==osg::Image::TOP_LEFT;
569           
570#if 1           
571                texture = new osg::TextureRectangle(image);
572#else
573                texture = new osg::Texture2D(image);
574#endif
575            }
576        }
577    }
578   
579    if (!texture)
580    {
581        return;
582    }
583
584    // distortion correction set up.
585    {
586        osg::Geode* geode = new osg::Geode();
587        geode->addDrawable( createDomeDistortionMesh(osg::Vec3(0.0f,0.0f,0.0f), osg::Vec3(width,0.0f,0.0f), osg::Vec3(0.0f,height,0.0f), domeModel) );
588
589        // new we need to add the texture to the mesh, we do so by creating a
590        // StateSet to contain the Texture StateAttribute.
591        osg::StateSet* stateset = geode->getOrCreateStateSet();
592        stateset->setTextureAttributeAndModes(0, texture, osg::StateAttribute::ON);
593        texture->setMaxAnisotropy(16.0f);
594        stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
595#if 1       
596        osg::TexMat* texmat = new osg::TexMat;
597        texmat->setScaleByTextureRectangleSize(true);
598        stateset->setTextureAttributeAndModes(0, texmat, osg::StateAttribute::ON);
599#endif
600        osg::ref_ptr<osg::Camera> camera = new osg::Camera;
601        camera->setGraphicsContext(gc.get());
602        camera->setClearMask(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );
603        camera->setClearColor( osg::Vec4(0.1,0.1,1.0,1.0) );
604        camera->setViewport(new osg::Viewport(0, 0, width, height));
605        GLenum buffer = traits->doubleBuffer ? GL_BACK : GL_FRONT;
606        camera->setDrawBuffer(buffer);
607        camera->setReadBuffer(buffer);
608        camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF);
609        camera->setAllowEventFocus(false);
610        //camera->setInheritanceMask(camera->getInheritanceMask() & ~osg::CullSettings::CLEAR_COLOR & ~osg::CullSettings::COMPUTE_NEAR_FAR_MODE);
611        //camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
612       
613        camera->setProjectionMatrixAsOrtho2D(0,width,0,height);
614        camera->setViewMatrix(osg::Matrix::identity());
615
616        // add subgraph to render
617        // camera->addChild(geode);
618       
619        camera->setName("DistortionCorrectionCamera");
620
621        viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd(), true);
622
623        viewer.setSceneData(geode);
624    }
625   
626   
627    viewer.getCamera()->setNearFarRatio(0.0001f);
628}
629
630int main(int argc, char** argv)
631{
632    // use an ArgumentParser object to manage the program arguments.
633    osg::ArgumentParser arguments(&argc,argv);
634   
635    // set up the usage document, in case we need to print out how to use this program.
636    arguments.getApplicationUsage()->setApplicationName(arguments.getApplicationName());
637    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" example demonstrates the use of ImageStream for rendering movies as textures.");
638    arguments.getApplicationUsage()->setCommandLineUsage(arguments.getApplicationName()+" [options] filename ...");
639    arguments.getApplicationUsage()->addCommandLineOption("-h or --help","Display this information");
640    arguments.getApplicationUsage()->addCommandLineOption("--texture2D","Use Texture2D rather than TextureRectangle.");
641    arguments.getApplicationUsage()->addCommandLineOption("--shader","Use shaders to post process the video.");
642    arguments.getApplicationUsage()->addCommandLineOption("--dome","Use full dome distortion correction.");
643   
644    bool useTextureRectangle = true;
645    bool useShader = false;
646
647    // construct the viewer.
648    osgViewer::Viewer viewer(arguments);
649   
650    if (arguments.argc()<=1)
651    {
652        arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
653        return 1;
654    }
655
656    while (arguments.read("--texture2D")) useTextureRectangle=false;
657    while (arguments.read("--shader")) useShader=true;
658
659    // if user request help write it out to cout.
660    if (arguments.read("-h") || arguments.read("--help"))
661    {
662        arguments.getApplicationUsage()->write(std::cout);
663        return 1;
664    }
665
666
667
668    if (arguments.read("--dome") || arguments.read("--puffer") )
669    {   
670        setDomeCorrection(viewer, arguments);
671    }
672    else
673    {
674        osg::ref_ptr<osg::Geode> geode = new osg::Geode;
675        osg::Vec3 pos(0.0f,0.0f,0.0f);
676
677        osg::StateSet* stateset = geode->getOrCreateStateSet();
678        stateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
679
680        if (useShader)
681        {
682            //useTextureRectangle = false;
683
684            static const char *shaderSourceTextureRec = {
685                "uniform vec4 cutoff_color;\n"
686                "uniform samplerRect movie_texture;\n"
687                "void main(void)\n"
688                "{\n"
689                "    vec4 texture_color = textureRect(movie_texture, gl_TexCoord[0]); \n"
690                "    if (all(lessThanEqual(texture_color,cutoff_color))) discard; \n"
691                "    gl_FragColor = texture_color;\n"
692                "}\n"
693            };
694
695            static const char *shaderSourceTexture2D = {
696                "uniform vec4 cutoff_color;\n"
697                "uniform sampler2D movie_texture;\n"
698                "void main(void)\n"
699                "{\n"
700                "    vec4 texture_color = texture2D(movie_texture, gl_TexCoord[0]); \n"
701                "    if (all(lessThanEqual(texture_color,cutoff_color))) discard; \n"
702                "    gl_FragColor = texture_color;\n"
703                "}\n"
704            };
705
706            osg::Program* program = new osg::Program;
707
708            program->addShader(new osg::Shader(osg::Shader::FRAGMENT,
709                                               useTextureRectangle ? shaderSourceTextureRec : shaderSourceTexture2D));
710
711            stateset->addUniform(new osg::Uniform("cutoff_color",osg::Vec4(0.1f,0.1f,0.1f,1.0f)));
712            stateset->addUniform(new osg::Uniform("movie_texture",0));
713
714            stateset->setAttribute(program);
715
716        }
717
718        for(int i=1;i<arguments.argc();++i)
719        {
720            if (arguments.isString(i))
721            {
722                osg::Image* image = osgDB::readImageFile(arguments[i]);
723                osg::ImageStream* imagestream = dynamic_cast<osg::ImageStream*>(image);
724                if (imagestream) imagestream->play();
725
726                if (image)
727                {
728                    geode->addDrawable(myCreateTexturedQuadGeometry(pos,image->s(),image->t(),image, useTextureRectangle));
729
730                    pos.z() += image->t()*1.5f;
731                }
732                else
733                {
734                    std::cout<<"Unable to read file "<<arguments[i]<<std::endl;
735                }           
736            }
737        }
738
739        // set the scene to render
740        viewer.setSceneData(geode.get());
741
742        if (viewer.getSceneData()==0)
743        {
744            arguments.getApplicationUsage()->write(std::cout);
745            return 1;
746        }
747    }
748   
749
750    // pass the model to the MovieEventHandler so it can pick out ImageStream's to manipulate.
751    MovieEventHandler* meh = new MovieEventHandler();
752    meh->set(viewer.getSceneData());
753    viewer.addEventHandler(meh);
754   
755    // add in support for stats
756    viewer.addEventHandler(new osgViewer::StatsHandler());
757
758    // report any errors if they have occured when parsing the program aguments.
759    if (arguments.errors())
760    {
761        arguments.writeErrorMessages(std::cout);
762        return 1;
763    }
764
765
766
767    // create the windows and run the threads.
768    return viewer.run();
769
770
771}
Note: See TracBrowser for help on using the browser.