SceneView.h

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 OSGUTIL_SCENEVIEW
#define OSGUTIL_SCENEVIEW 1

#include <osg/Node>
#include <osg/StateSet>
#include <osg/Light>
#include <osg/FrameStamp>
#include <osg/DisplaySettings>
#include <osg/CollectOccludersVisitor>
#include <osg/CullSettings>
#include <osg/Camera>

#include <osgUtil/CullVisitor>

namespace osgUtil {

class OSGUTIL_EXPORT SceneView : public osg::Object, public osg::CullSettings
{
    public:

        SceneView(osg::DisplaySettings* ds=NULL);

        SceneView(const SceneView& sceneview, const osg::CopyOp& copyop = osg::CopyOp());

        META_Object(osgUtil, SceneView);

        enum Options
        {
            NO_SCENEVIEW_LIGHT = 0x0,
            HEADLIGHT = 0x1,
            SKY_LIGHT = 0x2,
            COMPILE_GLOBJECTS_AT_INIT = 0x4,
            APPLY_GLOBAL_DEFAULTS = 0x8,
            CLEAR_GLOBAL_STATESET = 0x10,
            STANDARD_SETTINGS = HEADLIGHT |
                                COMPILE_GLOBJECTS_AT_INIT |
                                APPLY_GLOBAL_DEFAULTS |
                                CLEAR_GLOBAL_STATESET

        };

        /* Set defaults. */
        virtual void setDefaults() { setDefaults(STANDARD_SETTINGS); }

        virtual void setDefaults(unsigned int options);

        void setCamera(osg::Camera* camera, bool assumeOwnershipOfCamera = true);

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

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

        void setSceneData(osg::Node* node);

        osg::Node* getSceneData(unsigned int childNo=0) { return (_camera->getNumChildren()>childNo) ? _camera->getChild(childNo) : 0; }

        const osg::Node* getSceneData(unsigned int childNo=0) const { return (_camera->getNumChildren()>childNo) ? _camera->getChild(childNo) : 0; }

        unsigned int getNumSceneData() const { return _camera->getNumChildren(); }

        void setViewport(osg::Viewport* viewport) { _camera->setViewport(viewport); }

        void setViewport(int x,int y,int width,int height) { _camera->setViewport(x,y,width,height); }


        osg::Viewport* getViewport() { return (_camera->getViewport()!=0) ? _camera->getViewport() : 0; }

        const osg::Viewport* getViewport() const { return (_camera->getViewport()!=0) ? _camera->getViewport() : 0; }

        inline void setDisplaySettings(osg::DisplaySettings* vs) { _displaySettings = vs; }

        inline const osg::DisplaySettings* getDisplaySettings() const { return _displaySettings.get(); }

        inline osg::DisplaySettings* getDisplaySettings() { return _displaySettings.get(); }


        void setClearColor(const osg::Vec4& color) { _camera->setClearColor(color); }

        const osg::Vec4& getClearColor() const { return _camera->getClearColor(); }


        void setRedrawInterlacedStereoStencilMask(bool flag) { _redrawInterlacedStereoStencilMask = flag; }

        bool getRedrawInterlacedStereoStencilMask() const { return _redrawInterlacedStereoStencilMask; }


        void setGlobalStateSet(osg::StateSet* state) { _globalStateSet = state; }
        osg::StateSet* getGlobalStateSet() { return _globalStateSet.get(); }
        const osg::StateSet* getGlobalStateSet() const { return _globalStateSet.get(); }

        void setSecondaryStateSet(osg::StateSet* state) { _secondaryStateSet = state; }
        osg::StateSet* getSecondaryStateSet() { return _secondaryStateSet.get(); }
        const osg::StateSet* getSecondaryStateSet() const { return _secondaryStateSet.get(); }

        void setLocalStateSet(osg::StateSet* state) { _localStateSet = state; }
        osg::StateSet* getLocalStateSet() { return _localStateSet.get(); }
        const osg::StateSet* getLocalStateSet() const { return _localStateSet.get(); }

        enum ActiveUniforms
        {
            FRAME_NUMBER_UNIFORM            = 1,
            FRAME_TIME_UNIFORM              = 2,
            DELTA_FRAME_TIME_UNIFORM        = 4,
            SIMULATION_TIME_UNIFORM         = 8,
            DELTA_SIMULATION_TIME_UNIFORM   = 16,
            VIEW_MATRIX_UNIFORM             = 32,
            VIEW_MATRIX_INVERSE_UNIFORM     = 64,
            DEFAULT_UNIFORMS                = FRAME_NUMBER_UNIFORM |
                                              FRAME_TIME_UNIFORM |
                                              DELTA_FRAME_TIME_UNIFORM |
                                              SIMULATION_TIME_UNIFORM |
                                              DELTA_SIMULATION_TIME_UNIFORM |
                                              VIEW_MATRIX_UNIFORM |
                                              VIEW_MATRIX_INVERSE_UNIFORM,
            ALL_UNIFORMS                    = 0x7FFFFFFF
        };

        void setActiveUniforms(int activeUniforms) { _activeUniforms = activeUniforms; }

        int getActiveUniforms() const { return _activeUniforms; }

        void updateUniforms();


        typedef Options LightingMode;

        void setLightingMode(LightingMode mode);
        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 setState(osg::State* state) { _renderInfo.setState(state); }
        osg::State* getState() { return _renderInfo.getState(); }
        const osg::State* getState() const { return _renderInfo.getState(); }

        void setView(osg::View* view) { _camera->setView(view); }
        osg::View* getView() { return _camera->getView(); }
        const osg::View* getView() const { return _camera->getView(); }

        void setRenderInfo(osg::RenderInfo& renderInfo) { _renderInfo = renderInfo; }
        osg::RenderInfo& getRenderInfo() { return _renderInfo; }
        const osg::RenderInfo& getRenderInfo() const { return _renderInfo; }



        inline void setProjectionMatrix(const osg::Matrixf& matrix) { _camera->setProjectionMatrix(matrix); }

        inline void setProjectionMatrix(const osg::Matrixd& matrix) { _camera->setProjectionMatrix(matrix); }

        void setProjectionMatrixAsOrtho(double left, double right,
                                        double bottom, double top,
                                        double zNear, double zFar);

        void setProjectionMatrixAsOrtho2D(double left, double right,
                                          double bottom, double top);

        void setProjectionMatrixAsFrustum(double left, double right,
                                          double bottom, double top,
                                          double zNear, double zFar);

        void setProjectionMatrixAsPerspective(double fovy,double aspectRatio,
                                              double zNear, double zFar);

        osg::Matrixd& getProjectionMatrix() { return _camera->getProjectionMatrix(); }

        const osg::Matrixd& getProjectionMatrix() const { return _camera->getProjectionMatrix(); }

        bool getProjectionMatrixAsOrtho(double& left, double& right,
                                        double& bottom, double& top,
                                        double& zNear, double& zFar) const;

        bool getProjectionMatrixAsFrustum(double& left, double& right,
                                          double& bottom, double& top,
                                          double& zNear, double& zFar) const;

        bool getProjectionMatrixAsPerspective(double& fovy,double& aspectRatio,
                                              double& zNear, double& zFar) const;


        inline void setViewMatrix(const osg::Matrixf& matrix) { _camera->setViewMatrix(matrix); }

        inline void setViewMatrix(const osg::Matrixd& matrix) { _camera->setViewMatrix(matrix); }

        void setViewMatrixAsLookAt(const osg::Vec3& eye,const osg::Vec3& center,const osg::Vec3& up);

        osg::Matrixd& getViewMatrix() { return _camera->getViewMatrix(); }

        const osg::Matrixd& getViewMatrix() const { return _camera->getViewMatrix(); }

        void getViewMatrixAsLookAt(osg::Vec3& eye,osg::Vec3& center,osg::Vec3& up,float lookDistance=1.0f) const;




        void setInitVisitor(osg::NodeVisitor* av) { _initVisitor = av; }
        osg::NodeVisitor* getInitVisitor() { return _initVisitor.get(); }
        const osg::NodeVisitor* getInitVisitor() const { return _initVisitor.get(); }


        void setUpdateVisitor(osg::NodeVisitor* av) { _updateVisitor = av; }
        osg::NodeVisitor* getUpdateVisitor() { return _updateVisitor.get(); }
        const osg::NodeVisitor* getUpdateVisitor() const { return _updateVisitor.get(); }


        void setCullVisitor(osgUtil::CullVisitor* cv) { _cullVisitor = cv; }
        osgUtil::CullVisitor* getCullVisitor() { return _cullVisitor.get(); }
        const osgUtil::CullVisitor* getCullVisitor() const { return _cullVisitor.get(); }

        void setCullVisitorLeft(osgUtil::CullVisitor* cv) { _cullVisitorLeft = cv; }
        osgUtil::CullVisitor* getCullVisitorLeft() { return _cullVisitorLeft.get(); }
        const osgUtil::CullVisitor* getCullVisitorLeft() const { return _cullVisitorLeft.get(); }

        void setCullVisitorRight(osgUtil::CullVisitor* cv) { _cullVisitorRight = cv; }
        osgUtil::CullVisitor* getCullVisitorRight() { return _cullVisitorRight.get(); }
        const osgUtil::CullVisitor* getCullVisitorRight() const { return _cullVisitorRight.get(); }

        void setCollectOccludersVisitor(osg::CollectOccludersVisitor* cov) { _collectOccludersVisitor = cov; }
        osg::CollectOccludersVisitor* getCollectOccludersVisitor() { return _collectOccludersVisitor.get(); }
        const osg::CollectOccludersVisitor* getCollectOccludersVisitor() const { return _collectOccludersVisitor.get(); }


        void setStateGraph(osgUtil::StateGraph* rg) { _stateGraph = rg; }
        osgUtil::StateGraph* getStateGraph() { return _stateGraph.get(); }
        const osgUtil::StateGraph* getStateGraph() const { return _stateGraph.get(); }

        void setStateGraphLeft(osgUtil::StateGraph* rg) { _stateGraphLeft = rg; }
        osgUtil::StateGraph* getStateGraphLeft() { return _stateGraphLeft.get(); }
        const osgUtil::StateGraph* getStateGraphLeft() const { return _stateGraphLeft.get(); }

        void setStateGraphRight(osgUtil::StateGraph* rg) { _stateGraphRight = rg; }
        osgUtil::StateGraph* getStateGraphRight() { return _stateGraphRight.get(); }
        const osgUtil::StateGraph* getStateGraphRight() const { return _stateGraphRight.get(); }


        void setRenderStage(osgUtil::RenderStage* rs) { _renderStage = rs; }
        osgUtil::RenderStage* getRenderStage() { return _renderStage.get(); }
        const osgUtil::RenderStage* getRenderStage() const { return _renderStage.get(); }

        void setRenderStageLeft(osgUtil::RenderStage* rs) { _renderStageLeft = rs; }
        osgUtil::RenderStage* getRenderStageLeft() { return _renderStageLeft.get(); }
        const osgUtil::RenderStage* getRenderStageLeft() const { return _renderStageLeft.get(); }

        void setRenderStageRight(osgUtil::RenderStage* rs) { _renderStageRight = rs; }
        osgUtil::RenderStage* getRenderStageRight() { return _renderStageRight.get(); }
        const osgUtil::RenderStage* getRenderStageRight() const { return _renderStageRight.get(); }

        void collateReferencesToDependentCameras();

        void clearReferencesToDependentCameras();


        void setDrawBufferValue( GLenum drawBufferValue ) { _camera->setDrawBuffer(drawBufferValue); }

        GLenum getDrawBufferValue() const { return _camera->getDrawBuffer(); }


        enum FusionDistanceMode
        {
            USE_FUSION_DISTANCE_VALUE,
            PROPORTIONAL_TO_SCREEN_DISTANCE
        };

        void setFusionDistance(FusionDistanceMode mode,float value=1.0f)
        {
            _fusionDistanceMode = mode;
            _fusionDistanceValue = value;
        }

        FusionDistanceMode getFusionDistanceMode() const { return _fusionDistanceMode; }

        float getFusionDistanceValue() const { return _fusionDistanceValue; }


        void setPrioritizeTextures(bool pt) { _prioritizeTextures = pt; }

        bool getPrioritizeTextures() const { return _prioritizeTextures; }

        struct ComputeStereoMatricesCallback : public osg::Referenced
        {
            virtual osg::Matrixd computeLeftEyeProjection(const osg::Matrixd& projection) const = 0;
            virtual osg::Matrixd computeLeftEyeView(const osg::Matrixd& view) const = 0;

            virtual osg::Matrixd computeRightEyeProjection(const osg::Matrixd& projection) const = 0;
            virtual osg::Matrixd computeRightEyeView(const osg::Matrixd& view) const = 0;
        };

        void setComputeStereoMatricesCallback(ComputeStereoMatricesCallback* callback) { _computeStereoMatricesCallback=callback; }
        ComputeStereoMatricesCallback* getComputeStereoMatricesCallback() { return _computeStereoMatricesCallback.get(); }
        const ComputeStereoMatricesCallback* getComputeStereoMatricesCallback() const { return _computeStereoMatricesCallback.get(); }

        bool projectWindowIntoObject(const osg::Vec3& window,osg::Vec3& object) const;

        bool projectWindowXYIntoObject(int x,int y,osg::Vec3& near_point,osg::Vec3& far_point) const;

        bool projectObjectIntoWindow(const osg::Vec3& object,osg::Vec3& window) const;


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

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


        inline osg::Matrixd computeLeftEyeProjection(const osg::Matrixd& projection)  const
        {
            if (_computeStereoMatricesCallback.valid()) return _computeStereoMatricesCallback->computeLeftEyeProjection(projection);
            else return computeLeftEyeProjectionImplementation(projection);
        }

        inline osg::Matrixd computeLeftEyeView(const osg::Matrixd& view) const
        {
            if (_computeStereoMatricesCallback.valid()) return _computeStereoMatricesCallback->computeLeftEyeView(view);
            else return computeLeftEyeViewImplementation(view);
        }

        inline osg::Matrixd computeRightEyeProjection(const osg::Matrixd& projection)  const
        {
            if (_computeStereoMatricesCallback.valid()) return _computeStereoMatricesCallback->computeRightEyeProjection(projection);
            else return computeRightEyeProjectionImplementation(projection);
        }

        inline osg::Matrixd computeRightEyeView(const osg::Matrixd& view) const
        {
            if (_computeStereoMatricesCallback.valid()) return _computeStereoMatricesCallback->computeRightEyeView(view);
            else return computeRightEyeViewImplementation(view);
        }

        virtual osg::Matrixd computeLeftEyeProjectionImplementation(const osg::Matrixd& projection) const;

        virtual osg::Matrixd computeLeftEyeViewImplementation(const osg::Matrixd& view) const;

        virtual osg::Matrixd computeRightEyeProjectionImplementation(const osg::Matrixd& projection) const;

        virtual osg::Matrixd computeRightEyeViewImplementation(const osg::Matrixd& view) const;


        virtual void inheritCullSettings(const osg::CullSettings& settings) { inheritCullSettings(settings, _inheritanceMask); }

        virtual void inheritCullSettings(const osg::CullSettings& settings, unsigned int inheritanceMask);


        virtual void init();

        virtual void update();

        virtual void cull();

        virtual void draw();

        unsigned int getDynamicObjectCount() const { return _dynamicObjectCount; }

        virtual void releaseAllGLObjects();

        virtual void flushAllDeletedGLObjects();

        virtual void flushDeletedGLObjects(double& availableTime);

        bool getStats(Statistics& primStats);

        void setAutomaticFlush(bool automaticFlush) { _automaticFlush = automaticFlush; }
        bool getAutomaticFlush() const { return _automaticFlush; }

        void setResetColorMaskToAllOn(bool enable) { _resetColorMaskToAllEnabled = enable; }
        bool getResetColorMaskToAllOn() const { return _resetColorMaskToAllEnabled; }

    protected:

        virtual ~SceneView();

        virtual bool cullStage(const osg::Matrixd& projection,const osg::Matrixd& modelview,osgUtil::CullVisitor* cullVisitor, osgUtil::StateGraph* rendergraph, osgUtil::RenderStage* renderStage, osg::Viewport *viewport);

        void computeLeftEyeViewport(const osg::Viewport *viewport);
        void computeRightEyeViewport(const osg::Viewport *viewport);

        const osg::Matrix computeMVPW() const;

        void clearArea(int x,int y,int width,int height,const osg::Vec4& color);

        osg::ref_ptr<osg::StateSet>                 _localStateSet;
        osg::RenderInfo                             _renderInfo;

        bool                                        _initCalled;
        osg::ref_ptr<osg::NodeVisitor>              _initVisitor;
        osg::ref_ptr<osg::NodeVisitor>              _updateVisitor;
        osg::ref_ptr<osgUtil::CullVisitor>          _cullVisitor;
        osg::ref_ptr<osgUtil::StateGraph>           _stateGraph;
        osg::ref_ptr<osgUtil::RenderStage>          _renderStage;

        osg::ref_ptr<ComputeStereoMatricesCallback> _computeStereoMatricesCallback;

        osg::ref_ptr<osgUtil::CullVisitor>          _cullVisitorLeft;
        osg::ref_ptr<osgUtil::StateGraph>           _stateGraphLeft;
        osg::ref_ptr<osgUtil::RenderStage>          _renderStageLeft;
        osg::ref_ptr<osg::Viewport>                 _viewportLeft;

        osg::ref_ptr<osgUtil::CullVisitor>          _cullVisitorRight;
        osg::ref_ptr<osgUtil::StateGraph>           _stateGraphRight;
        osg::ref_ptr<osgUtil::RenderStage>          _renderStageRight;
        osg::ref_ptr<osg::Viewport>                 _viewportRight;

        osg::ref_ptr<osg::CollectOccludersVisitor>  _collectOccludersVisitor;

        osg::ref_ptr<osg::FrameStamp>               _frameStamp;

        osg::observer_ptr<osg::Camera>              _camera;
        osg::ref_ptr<osg::Camera>                   _cameraWithOwnership;

        osg::ref_ptr<osg::StateSet>                 _globalStateSet;
        osg::ref_ptr<osg::Light>                    _light;
        osg::ref_ptr<osg::DisplaySettings>          _displaySettings;

        osg::ref_ptr<osg::StateSet>                 _secondaryStateSet;

        FusionDistanceMode                          _fusionDistanceMode;
        float                                       _fusionDistanceValue;

        LightingMode                                _lightingMode;

        bool                                        _prioritizeTextures;

        bool                                        _automaticFlush;
        bool                                        _requiresFlush;

        int                                         _activeUniforms;
        double                                      _previousFrameTime;
        double                                      _previousSimulationTime;

        bool                                        _redrawInterlacedStereoStencilMask;
        int                                         _interlacedStereoStencilWidth;
        int                                         _interlacedStereoStencilHeight;

        unsigned int                                _dynamicObjectCount;

        bool                                        _resetColorMaskToAllEnabled;
};

}

#endif