Camera.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 OSG_CAMERA
#define OSG_CAMERA 1

#include <osg/Transform>
#include <osg/Viewport>
#include <osg/ColorMask>
#include <osg/CullSettings>
#include <osg/Texture>
#include <osg/Image>
#include <osg/GraphicsContext>
#include <osg/Stats>

#include <OpenThreads/Mutex>


#if defined(OSG_GLES1_AVAILABLE) || defined(OSG_GLES2_AVAILABLE) && !defined(OSG_GL3_AVAILABLE)
    #define GL_FRONT_LEFT       0x0400
    #define GL_FRONT_RIGHT      0x0401
    #define GL_BACK_LEFT        0x0402
    #define GL_BACK_RIGHT       0x0403
#endif

namespace osg {

// forward declare View to allow Camera to point back to the View that its within
class View;
class RenderInfo;

class OSG_EXPORT Camera : public Transform, public CullSettings
{
    public :


        Camera();

        Camera(const Camera&,const CopyOp& copyop=CopyOp::SHALLOW_COPY);

        META_Node(osg, Camera);

        virtual Camera* asCamera() { return this; }
        virtual const Camera* asCamera() const { return this; }

        void setView(View* view) { _view = view; }

        View* getView() { return _view; }

        const View* getView() const { return _view; }


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

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

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


        void setAllowEventFocus(bool focus) { _allowEventFocus = focus; }

        bool getAllowEventFocus() const { return _allowEventFocus; }


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

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

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


        inline void setClearMask(GLbitfield mask) { _clearMask = mask; applyMaskAction(CLEAR_MASK); }

        inline GLbitfield getClearMask() const { return _clearMask; }

        void setClearColor(const osg::Vec4& color) { _clearColor=color; applyMaskAction(CLEAR_COLOR); }

        const osg::Vec4& getClearColor() const { return _clearColor; }

        void setClearAccum(const osg::Vec4& color) { _clearAccum=color; }

        const osg::Vec4& getClearAccum() const { return _clearAccum; }

        void setClearDepth(double depth) { _clearDepth=depth; }

        double getClearDepth() const { return _clearDepth; }

        void setClearStencil(int stencil) { _clearStencil=stencil; }

        int getClearStencil() const { return _clearStencil; }


        void setColorMask(osg::ColorMask* colorMask);


        void setColorMask(bool red, bool green, bool blue, bool alpha);

        const ColorMask* getColorMask() const { return _colorMask.get(); }

        ColorMask* getColorMask() { return _colorMask.get(); }


        void setViewport(osg::Viewport* viewport);

        void setViewport(int x,int y,int width,int height);

        const Viewport* getViewport() const { return _viewport.get(); }

        Viewport* getViewport() { return _viewport.get(); }



        enum TransformOrder
        {
            PRE_MULTIPLY,
            POST_MULTIPLY
        };

        void setTransformOrder(TransformOrder order) { _transformOrder = order; }

        TransformOrder getTransformOrder() const { return _transformOrder; }

        enum ProjectionResizePolicy
        {
            FIXED, 
            HORIZONTAL, 
            VERTICAL 
        };

        inline void setProjectionResizePolicy(ProjectionResizePolicy policy) { _projectionResizePolicy = policy; }

        inline ProjectionResizePolicy getProjectionResizePolicy() const { return _projectionResizePolicy; }


        inline void setProjectionMatrix(const osg::Matrixf& matrix) { _projectionMatrix.set(matrix); }

        inline void setProjectionMatrix(const osg::Matrixd& matrix) { _projectionMatrix.set(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 _projectionMatrix; }

        const osg::Matrixd& getProjectionMatrix() const { return _projectionMatrix; }

        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) { _viewMatrix.set(matrix);  dirtyBound();}

        inline void setViewMatrix(const osg::Matrixd& matrix) { _viewMatrix.set(matrix);  dirtyBound();}

        osg::Matrixd& getViewMatrix() { return _viewMatrix; }

        const osg::Matrixd& getViewMatrix() const { return _viewMatrix; }

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

        void getViewMatrixAsLookAt(osg::Vec3d& eye,osg::Vec3d& center,osg::Vec3d& up,double lookDistance=1.0) const;

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

        Matrixd getInverseViewMatrix() const;


        enum RenderOrder
        {
            PRE_RENDER,
            NESTED_RENDER,
            POST_RENDER
        };

        void setRenderOrder(RenderOrder order, int orderNum = 0) { _renderOrder = order; _renderOrderNum = orderNum; }

        RenderOrder getRenderOrder() const { return _renderOrder; }

        int getRenderOrderNum() const { return _renderOrderNum; }

        bool isRenderToTextureCamera() const;

        enum RenderTargetImplementation
        {
            FRAME_BUFFER_OBJECT,
            PIXEL_BUFFER_RTT,
            PIXEL_BUFFER,
            FRAME_BUFFER,
            SEPARATE_WINDOW
        };

        void setRenderTargetImplementation(RenderTargetImplementation impl);

        void setRenderTargetImplementation(RenderTargetImplementation impl, RenderTargetImplementation fallback);

        RenderTargetImplementation getRenderTargetImplementation() const { return _renderTargetImplementation; }

        RenderTargetImplementation getRenderTargetFallback() const { return _renderTargetFallback; }


        void setDrawBuffer(GLenum buffer) { _drawBuffer = buffer; applyMaskAction( DRAW_BUFFER ); }

        GLenum getDrawBuffer() const { return _drawBuffer; }

        void setReadBuffer(GLenum buffer) { _readBuffer = buffer; applyMaskAction( READ_BUFFER ); }

        GLenum getReadBuffer() const { return _readBuffer; }

        enum BufferComponent
        {
            DEPTH_BUFFER,
            STENCIL_BUFFER,
            PACKED_DEPTH_STENCIL_BUFFER,
            COLOR_BUFFER,
            COLOR_BUFFER0,
            COLOR_BUFFER1 = COLOR_BUFFER0+1,
            COLOR_BUFFER2 = COLOR_BUFFER0+2,
            COLOR_BUFFER3 = COLOR_BUFFER0+3,
            COLOR_BUFFER4 = COLOR_BUFFER0+4,
            COLOR_BUFFER5 = COLOR_BUFFER0+5,
            COLOR_BUFFER6 = COLOR_BUFFER0+6,
            COLOR_BUFFER7 = COLOR_BUFFER0+7,
            COLOR_BUFFER8 = COLOR_BUFFER0+8,
            COLOR_BUFFER9 = COLOR_BUFFER0+9,
            COLOR_BUFFER10 = COLOR_BUFFER0+10,
            COLOR_BUFFER11 = COLOR_BUFFER0+11,
            COLOR_BUFFER12 = COLOR_BUFFER0+12,
            COLOR_BUFFER13 = COLOR_BUFFER0+13,
            COLOR_BUFFER14 = COLOR_BUFFER0+14,
            COLOR_BUFFER15 = COLOR_BUFFER0+15
        };

        static const unsigned int FACE_CONTROLLED_BY_GEOMETRY_SHADER;

        void attach(BufferComponent buffer, GLenum internalFormat);

        void attach(BufferComponent buffer, osg::Texture* texture, unsigned int level = 0, unsigned int face=0, bool mipMapGeneration=false,
            unsigned int multisampleSamples = 0,
            unsigned int multisampleColorSamples = 0);

        void attach(BufferComponent buffer, osg::Image* image,
            unsigned int multisampleSamples = 0,
            unsigned int multisampleColorSamples = 0);

        void detach(BufferComponent buffer);

        struct Attachment
        {
            Attachment():
                _internalFormat(GL_NONE),
                _level(0),
                _face(0),
                _mipMapGeneration(false),
                _multisampleSamples(0),
                _multisampleColorSamples(0) {}

            int width() const
            {
                if (_texture.valid()) return _texture->getTextureWidth();
                if (_image.valid()) return _image->s();
                return 0;
            };

            int height() const
            {
                if (_texture.valid()) return _texture->getTextureHeight();
                if (_image.valid()) return _image->t();
                return 0;
            };

            int depth() const
            {
                if (_texture.valid()) return _texture->getTextureDepth();
                if (_image.valid()) return _image->r();
                return 0;
            };

            GLenum              _internalFormat;
            ref_ptr<Image>      _image;
            ref_ptr<Texture>    _texture;
            unsigned int        _level;
            unsigned int        _face;
            bool                _mipMapGeneration;
            unsigned int        _multisampleSamples;
            unsigned int        _multisampleColorSamples;
        };

        typedef std::map< BufferComponent, Attachment> BufferAttachmentMap;

        BufferAttachmentMap& getBufferAttachmentMap() { return _bufferAttachmentMap; }

        const BufferAttachmentMap& getBufferAttachmentMap() const { return _bufferAttachmentMap; }


        void dirtyAttachmentMap() { ++_attachmentMapModifiedCount; }

        void setAttachmentMapModifiedCount(unsigned int v) { _attachmentMapModifiedCount = v; }

        unsigned int getAttachmentMapModifiedCount() const { return _attachmentMapModifiedCount; }

        void resizeAttachments(int width, int height);


        enum ResizeMask
        {
            RESIZE_VIEWPORT=1,
            RESIZE_ATTACHMENTS=2,
            RESIZE_PROJECTIONMATRIX=4,
            RESIZE_DEFAULT=RESIZE_VIEWPORT|RESIZE_ATTACHMENTS
        };

        void resize(int width, int height, int resizeMask=RESIZE_DEFAULT);


        enum ImplicitBufferAttachment
        {
            IMPLICIT_DEPTH_BUFFER_ATTACHMENT = DisplaySettings::IMPLICIT_DEPTH_BUFFER_ATTACHMENT,
            IMPLICIT_STENCIL_BUFFER_ATTACHMENT = DisplaySettings::IMPLICIT_STENCIL_BUFFER_ATTACHMENT,
            IMPLICIT_COLOR_BUFFER_ATTACHMENT = DisplaySettings::IMPLICIT_COLOR_BUFFER_ATTACHMENT,
            USE_DISPLAY_SETTINGS_MASK = (~0)
        };

        typedef int ImplicitBufferAttachmentMask;

        void setImplicitBufferAttachmentMask(ImplicitBufferAttachmentMask renderMask = DisplaySettings::DEFAULT_IMPLICIT_BUFFER_ATTACHMENT, ImplicitBufferAttachmentMask resolveMask = DisplaySettings::DEFAULT_IMPLICIT_BUFFER_ATTACHMENT)
        {
            _implicitBufferAttachmentRenderMask = renderMask;
            _implicitBufferAttachmentResolveMask = resolveMask;
        }

        void setImplicitBufferAttachmentRenderMask(ImplicitBufferAttachmentMask implicitBufferAttachmentRenderMask)
        {
            _implicitBufferAttachmentRenderMask = implicitBufferAttachmentRenderMask;
        }

        void setImplicitBufferAttachmentResolveMask(ImplicitBufferAttachmentMask implicitBufferAttachmentResolveMask)
        {
            _implicitBufferAttachmentResolveMask = implicitBufferAttachmentResolveMask;
        }

        ImplicitBufferAttachmentMask getImplicitBufferAttachmentRenderMask(bool effectiveMask = false) const
        {
            if( effectiveMask && _implicitBufferAttachmentRenderMask == USE_DISPLAY_SETTINGS_MASK )
            {
                const DisplaySettings * ds = _displaySettings.valid() ? _displaySettings.get() : DisplaySettings::instance().get();
                return ds->getImplicitBufferAttachmentRenderMask();
            }
            else
            {
                return _implicitBufferAttachmentRenderMask;
            }
        }

        ImplicitBufferAttachmentMask getImplicitBufferAttachmentResolveMask(bool effectiveMask = false) const
        {
            if( effectiveMask && _implicitBufferAttachmentResolveMask == USE_DISPLAY_SETTINGS_MASK )
            {
                const DisplaySettings * ds = _displaySettings.valid() ? _displaySettings.get() : DisplaySettings::instance().get();
                return ds->getImplicitBufferAttachmentResolveMask();
            }
            else
            {
                return _implicitBufferAttachmentResolveMask;
            }
        }

        void createCameraThread();

        void setCameraThread(OperationThread* gt);

        OperationThread* getCameraThread() { return _cameraThread.get(); }

        const OperationThread* getCameraThread() const { return _cameraThread.get(); }



        void setGraphicsContext(GraphicsContext* context);

        GraphicsContext* getGraphicsContext() { return _graphicsContext.get(); }

        const GraphicsContext* getGraphicsContext() const { return _graphicsContext.get(); }


        void setRenderer(osg::GraphicsOperation* rc) { _renderer = rc; }

        osg::GraphicsOperation* getRenderer() { return _renderer.get(); }

        const osg::GraphicsOperation* getRenderer() const { return _renderer.get(); }


        void setRenderingCache(osg::Object* rc) { _renderingCache = rc; }

        osg::Object* getRenderingCache() { return _renderingCache.get(); }

        const osg::Object* getRenderingCache() const { return _renderingCache.get(); }


        struct OSG_EXPORT DrawCallback : virtual public Object
        {
            DrawCallback() {}

            DrawCallback(const DrawCallback&,const CopyOp&) {}

            META_Object(osg, DrawCallback);

            virtual void operator () (osg::RenderInfo& renderInfo) const;

            virtual void operator () (const osg::Camera& /*camera*/) const {}
        };

        void setInitialDrawCallback(DrawCallback* cb) { _initialDrawCallback = cb; }

        DrawCallback* getInitialDrawCallback() { return _initialDrawCallback.get(); }

        const DrawCallback* getInitialDrawCallback() const { return _initialDrawCallback.get(); }


        void setPreDrawCallback(DrawCallback* cb) { _preDrawCallback = cb; }

        DrawCallback* getPreDrawCallback() { return _preDrawCallback.get(); }

        const DrawCallback* getPreDrawCallback() const { return _preDrawCallback.get(); }


        void setPostDrawCallback(DrawCallback* cb) { _postDrawCallback = cb; }

        DrawCallback* getPostDrawCallback() { return _postDrawCallback.get(); }

        const DrawCallback* getPostDrawCallback() const { return _postDrawCallback.get(); }


        void setFinalDrawCallback(DrawCallback* cb) { _finalDrawCallback = cb; }

        DrawCallback* getFinalDrawCallback() { return _finalDrawCallback.get(); }

        const DrawCallback* getFinalDrawCallback() const { return _finalDrawCallback.get(); }


        OpenThreads::Mutex* getDataChangeMutex() const { return &_dataChangeMutex; }

        virtual void resizeGLObjectBuffers(unsigned int maxSize);

        virtual void releaseGLObjects(osg::State* = 0) const;

    public:

        virtual bool computeLocalToWorldMatrix(Matrix& matrix,NodeVisitor*) const;

        virtual bool computeWorldToLocalMatrix(Matrix& matrix,NodeVisitor*) const;

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

    protected :

        virtual ~Camera();

        mutable OpenThreads::Mutex          _dataChangeMutex;


        View*                               _view;

        osg::ref_ptr<osg::Stats>            _stats;

        bool                                _allowEventFocus;

        osg::ref_ptr<osg::DisplaySettings>  _displaySettings;

        GLbitfield                          _clearMask;
        osg::Vec4                           _clearColor;
        osg::Vec4                           _clearAccum;
        double                              _clearDepth;
        int                                 _clearStencil;

        ref_ptr<ColorMask>                  _colorMask;
        ref_ptr<Viewport>                   _viewport;

        TransformOrder                      _transformOrder;
        ProjectionResizePolicy              _projectionResizePolicy;

        Matrixd                             _projectionMatrix;
        Matrixd                             _viewMatrix;

        RenderOrder                         _renderOrder;
        int                                 _renderOrderNum;

        GLenum                              _drawBuffer;
        GLenum                              _readBuffer;

        RenderTargetImplementation          _renderTargetImplementation;
        RenderTargetImplementation          _renderTargetFallback;
        BufferAttachmentMap                 _bufferAttachmentMap;
        ImplicitBufferAttachmentMask        _implicitBufferAttachmentRenderMask;
        ImplicitBufferAttachmentMask        _implicitBufferAttachmentResolveMask;

        unsigned int                        _attachmentMapModifiedCount;

        ref_ptr<OperationThread>            _cameraThread;

        ref_ptr<GraphicsContext>            _graphicsContext;

        ref_ptr<GraphicsOperation>          _renderer;
        ref_ptr<Object>                     _renderingCache;

        ref_ptr<DrawCallback>               _initialDrawCallback;
        ref_ptr<DrawCallback>               _preDrawCallback;
        ref_ptr<DrawCallback>               _postDrawCallback;
        ref_ptr<DrawCallback>               _finalDrawCallback;
};


struct CameraRenderOrderSortOp
{
    inline bool operator() (const Camera* lhs,const Camera* rhs) const
    {
        if (lhs->getRenderOrder()<rhs->getRenderOrder()) return true;
        if (rhs->getRenderOrder()<lhs->getRenderOrder()) return false;
        return lhs->getRenderOrderNum()<rhs->getRenderOrderNum();
    }
};


}

#endif