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

Revision 6948, 27.1 kB (checked in by robert, 7 years ago)

Refactored the dome correction code to support movie flipping.

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