osg/View

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/
 
#ifndef OSG_VIEW
#define OSG_VIEW 1
 
#include <osg/Camera>
#include <osg/Light>
#include <osg/Stats>
 
#include <OpenThreads/Mutex>
 
namespace osg {

class OSG_EXPORT View : public virtual osg::Object
{
    public :
 
        View();
 
        View(const osg::View& view, const osg::CopyOp& copyop=CopyOp::SHALLOW_COPY);
 
        META_Object(osg,View);

        virtual void take(View& rhs);
 

        void setStats(osg::Stats* stats) { _stats = stats; }

        osg::Stats* getStats() { return _stats.get(); }

        const osg::Stats* getStats() const { return _stats.get(); }
 

        enum LightingMode
        {
            NO_LIGHT,
            HEADLIGHT,
            SKY_LIGHT
        };

        void setLightingMode(LightingMode lightingMode);

        LightingMode getLightingMode() const { return _lightingMode; }

        void setLight(osg::Light* light) { _light = light; }

        osg::Light* getLight() { return _light.get(); }

        const osg::Light* getLight() const { return _light.get(); }

        void setCamera(osg::Camera* camera);

        osg::Camera* getCamera() { return _camera.get(); }

        const osg::Camera* getCamera() const { return _camera.get(); }

        void setFrameStamp(osg::FrameStamp* fs) { _frameStamp = fs; }

        osg::FrameStamp* getFrameStamp() { return _frameStamp.get(); }

        const osg::FrameStamp* getFrameStamp() const { return _frameStamp.get(); }
 

        struct OSG_EXPORT Slave
        {
            Slave(bool useMastersSceneData=true):
                _useMastersSceneData(useMastersSceneData) {}
 
            Slave(osg::Camera* camera, const osg::Matrixd& projectionOffset, const osg::Matrixd& viewOffset, bool useMastersSceneData=true):
                _camera(camera),
                _projectionOffset(projectionOffset),
                _viewOffset(viewOffset),
                _useMastersSceneData(useMastersSceneData) {}
 
            Slave(const Slave& rhs) :
                _camera(rhs._camera),
                _projectionOffset(rhs._projectionOffset),
                _viewOffset(rhs._viewOffset),
                _useMastersSceneData(rhs._useMastersSceneData),
                _updateSlaveCallback(rhs._updateSlaveCallback) {}
 
            virtual ~Slave() {}
 
            Slave& operator = (const Slave& rhs)
            {
                _camera = rhs._camera;
                _projectionOffset = rhs._projectionOffset;
                _viewOffset = rhs._viewOffset;
                _useMastersSceneData = rhs._useMastersSceneData;
                _updateSlaveCallback = rhs._updateSlaveCallback;
                return *this;
            }
 
            struct UpdateSlaveCallback : public virtual Referenced
            {
                virtual void updateSlave(osg::View& view, osg::View::Slave& slave) = 0;
            };
 
            void updateSlave(View& view)
            {
                if (_updateSlaveCallback.valid()) _updateSlaveCallback->updateSlave(view, *this);
                else updateSlaveImplementation(view);
            }
 
            virtual void updateSlaveImplementation(View& view);
 
            osg::ref_ptr<osg::Camera>           _camera;
            osg::Matrixd                        _projectionOffset;
            osg::Matrixd                        _viewOffset;
            bool                                _useMastersSceneData;
            osg::ref_ptr<UpdateSlaveCallback>   _updateSlaveCallback;
        };
 
        bool addSlave(osg::Camera* camera, bool useMastersSceneData=true) { return addSlave(camera, osg::Matrix::identity(), osg::Matrix::identity(), useMastersSceneData); }
 
        bool addSlave(osg::Camera* camera, const osg::Matrix& projectionOffset, const osg::Matrix& viewOffset, bool useMastersSceneData=true);
 
        bool removeSlave(unsigned int pos);
 
        unsigned int getNumSlaves() const { return static_cast<unsigned int>(_slaves.size()); }
 
        Slave& getSlave(unsigned int pos) { return _slaves[pos]; }
        const Slave& getSlave(unsigned int pos) const { return _slaves[pos]; }
 
        unsigned int findSlaveIndexForCamera(osg::Camera* camera) const;
 
        Slave * findSlaveForCamera(osg::Camera* camera);
 
        void updateSlaves();
 
        virtual void resizeGLObjectBuffers(unsigned int maxSize);
        virtual void releaseGLObjects(osg::State* = 0) const;
 
    protected :
 
        virtual ~View();
 
        virtual osg::GraphicsOperation* createRenderer(osg::Camera*) { return 0; }
 
        osg::ref_ptr<osg::Stats>        _stats;
 
        LightingMode                    _lightingMode;
        osg::ref_ptr<osg::Light>        _light;
 
        osg::ref_ptr<osg::Camera>       _camera;
 
        typedef std::vector<Slave>      Slaves;
        Slaves                          _slaves;
 
        osg::ref_ptr<osg::FrameStamp>   _frameStamp;
};
 
}
 
#endif