OpenSceneGraph/include/osg/CameraNode

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2005 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_CAMERANODE
#define OSG_CAMERANODE 1

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

namespace osg {

/** CameraNode - is a subclass of Transform which represents encapsulates the settings of a Camera.
*/
class OSG_EXPORT CameraNode : public Transform, public CullSettings
{
    public :


        CameraNode();

        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/
        CameraNode(const CameraNode&,const CopyOp& copyop=CopyOp::SHALLOW_COPY);

        META_Node(osg, CameraNode);


        /** Sets the clear color. */
        inline void setClearColor(const Vec4& color) { _clearColor = color; }

        /** Returns the clear color. */
        inline const Vec4& getClearColor() const { return _clearColor; }
        
        /** Set the clear mask used in glClear(..).
          * Defaults to GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT. */
        inline void setClearMask(GLbitfield mask) { _clearMask = mask; }

        /** Get the clear mask.*/
        inline GLbitfield getClearMask() const { return _clearMask; }


        /** Set the color mask of the camera to use specified osg::ColorMask. */
        void setColorMask(osg::ColorMask* colorMask);

        /** Set the color mask of the camera to specified values. */
        void setColorMask(bool red, bool green, bool blue, bool alpha);
        
        /** Get the const ColorMask. */
        const ColorMask* getColorMask() const { return _colorMask.get(); }

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


        /** Set the viewport of the camera to use specified osg::Viewport. */
        void setViewport(osg::Viewport* viewport);

        /** Set the viewport of the camera to specified dimensions. */
        void setViewport(int x,int y,int width,int height);
        
        /** Get the const viewport. */
        const Viewport* getViewport() const { return _viewport.get(); }

        /** Get the viewport. */
        Viewport* getViewport() { return _viewport.get(); }


        enum TransformOrder
        {
            PRE_MULTIPLE,
            POST_MULTIPLE  
        };
        
        void setTransformOrder(TransformOrder order) { _transformOrder = order; }
        TransformOrder getTransformOrder() const { return _transformOrder; }
        
        

        /** Set the projection matrix. Can be thought of as setting the lens of a camera. */
        inline void setProjectionMatrix(const osg::Matrixf& matrix) { _projectionMatrix.set(matrix); }

        /** Set the projection matrix. Can be thought of as setting the lens of a camera. */
        inline void setProjectionMatrix(const osg::Matrixd& matrix) { _projectionMatrix.set(matrix); }

        /** Set to an orthographic projection. See OpenGL glOrtho for documentation further details.*/
        void setProjectionMatrixAsOrtho(double left, double right,
                                        double bottom, double top,
                                        double zNear, double zFar);

        /** Set to a 2D orthographic projection. See OpenGL glOrtho2D documentation for further details.*/
        void setProjectionMatrixAsOrtho2D(double left, double right,
                                          double bottom, double top);

        /** Set to a perspective projection. See OpenGL glFrustum documentation for further details.*/
        void setProjectionMatrixAsFrustum(double left, double right,
                                          double bottom, double top,
                                          double zNear, double zFar);

        /** Create a symmetrical perspective projection, See OpenGL gluPerspective documentation for further details.
          * Aspect ratio is defined as width/height.*/
        void setProjectionMatrixAsPerspective(double fovy,double aspectRatio,
                                              double zNear, double zFar);

        /** Get the projection matrix.*/
        osg::Matrixd& getProjectionMatrix() { return _projectionMatrix; }

        /** Get the const projection matrix.*/
        const osg::Matrixd& getProjectionMatrix() const { return _projectionMatrix; }

        /** Get the othographic settings of the orthographic projection matrix. 
          * Returns false if matrix is not an orthographic matrix, where parameter values are undefined.*/
        bool getProjectionMatrixAsOrtho(double& left, double& right,
                                        double& bottom, double& top,
                                        double& zNear, double& zFar);

        /** Get the frustum setting of a perspective projection matrix.
          * Returns false if matrix is not a perspective matrix, where parameter values are undefined.*/
        bool getProjectionMatrixAsFrustum(double& left, double& right,
                                          double& bottom, double& top,
                                          double& zNear, double& zFar);

        /** Get the frustum setting of a symmetric perspective projection matrix.
          * Returns false if matrix is not a perspective matrix, where parameter values are undefined. 
          * Note, if matrix is not a symmetric perspective matrix then the shear will be lost.
          * Asymmetric matrices occur when stereo, power walls, caves and reality center display are used.
          * In these configurations one should use the 'getProjectionMatrixAsFrustum' method instead.*/
        bool getProjectionMatrixAsPerspective(double& fovy,double& aspectRatio,
                                              double& zNear, double& zFar);



        /** Set the view matrix. Can be thought of as setting the position of the world relative to the camera in camera coordinates. */
        inline void setViewMatrix(const osg::Matrixf& matrix) { _viewMatrix.set(matrix);  dirtyBound();}
        
        /** Set the view matrix. Can be thought of as setting the position of the world relative to the camera in camera coordinates. */
        inline void setViewMatrix(const osg::Matrixd& matrix) { _viewMatrix.set(matrix);  dirtyBound();}

        /** Set to the position and orientation of view matrix, using the same convention as gluLookAt. */
        void setViewMatrixAsLookAt(const osg::Vec3& eye,const osg::Vec3& center,const osg::Vec3& up);

        /** Get the view matrix. */
        osg::Matrixd& getViewMatrix() { return _viewMatrix; }

        /** Get the const view matrix. */
        const osg::Matrixd& getViewMatrix() const { return _viewMatrix; }

        /** Get to the position and orientation of a modelview matrix, using the same convention as gluLookAt. */
        void getViewMatrixAsLookAt(osg::Vec3& eye,osg::Vec3& center,osg::Vec3& up,float lookDistance=1.0f);

        /** Get the inverse view matrix.*/
        Matrixd getInverseViewMatrix() const;

        
        enum RenderOrder
        {
            PRE_RENDER,
            NESTED_RENDER,
            POST_RENDER
        };
        
        /** Set the rendering order of this camera's subgraph relative to any camera that this subgraph is nested within.
          * For rendering to a texture, one typically uses PRE_RENDER.
          * For Head Up Displays, one would typically use POST_RENDER.*/
        void setRenderOrder(RenderOrder order) { _renderOrder = order; }
        
        /** Get the rendering order of this camera's subgraph relative to any camera that this subgraph is nested within.*/
        RenderOrder getRenderOrder() const { return _renderOrder; }

        enum RenderTargetImplementation
        {
            FRAME_BUFFER_OBJECT,
            PIXEL_BUFFER,
            FRAME_BUFFER,
            SEPERATE_WINDOW
        };

        void setRenderTargetImplmentation(RenderTargetImplementation impl) { _renderTargetImplementation = impl; }
        RenderTargetImplementation getRenderTargetImplmentation() const { return _renderTargetImplementation; }


        /** Set the draw buffer for a given fragment output position to specified draw buffer. */
        void setDrawBuffer(unsigned int pos, GLenum buffer) { _drawBufferList[pos] = buffer; }

        /** Get the draw buffer for a given fragment output position. */
        GLenum getDrawBuffer(unsigned int pos) const { return _drawBufferList[pos]; }
        
        typedef std::vector<GLenum> DrawBufferList;

        /** Get the list which draw buffer are active. */
        DrawBufferList& getDrawBufferList() { return _drawBufferList; }
        
        /** Get the const list which draw buffer are active. */
        const DrawBufferList& getDrawBufferList() const { return _drawBufferList; }


        /** Set the read buffer for any required copy operations to use. */
        void setReadBuffer(GLenum buffer) { _readBuffer = buffer; }

        /** Get the read buffer for any required copy operations to use. */
        GLenum getReadBuffer() const { return _readBuffer; }


        enum BufferComponent
        {
            DEPTH_BUFFER,
            STENCIL_BUFFER,
            COLOR_BUFFER,
            COLOR_BUFFER0 = COLOR_BUFFER,
            COLOR_BUFFER1 = COLOR_BUFFER+1,
            COLOR_BUFFER2 = COLOR_BUFFER+2,
            COLOR_BUFFER3 = COLOR_BUFFER+3,
            COLOR_BUFFER4 = COLOR_BUFFER+4,
            COLOR_BUFFER5 = COLOR_BUFFER+5,
            COLOR_BUFFER6 = COLOR_BUFFER+6,
            COLOR_BUFFER7 = COLOR_BUFFER+7            
        };

        void attach(BufferComponent buffer, GLenum internalFormat);

        void attach(BufferComponent buffer, osg::Texture* texture, unsigned int level = 0, unsigned int face=0);

        void attach(BufferComponent buffer, osg::Image* image);

        void detach(BufferComponent buffer);
        
        struct Attachment
        {
            Attachment():
                _internalFormat(GL_NONE),
                _level(0),
                _face(0) {}
        
            GLenum              _internalFormat;
            ref_ptr<Image>      _image;
            ref_ptr<Texture>    _texture;
            unsigned int        _level;
            unsigned int        _face;
        };
        
        typedef std::map< BufferComponent, Attachment> BufferAttachmentMap;
        
        /** Get the BufferAttachmentMap, used to configure frame buffer objects, pbuffers and texture reads.*/
        BufferAttachmentMap& getBufferAttachmentMap() { return _bufferAttachmentMap; }

        /** Get the const BufferAttachmentMap, used to configure frame buffer objects, pbuffers and texture reads.*/
        const BufferAttachmentMap& getBufferAttachmentMap() const { return _bufferAttachmentMap; }
        
        
        /** Set the GraphicsContext that provides the mechansim for managing the OpenGL graphics context associated with this camera.*/
        void setGraphicsContext(GraphicsContext* context) { _graphicsContext = context; }

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

        /** Get the const GraphicsContext.*/
        const GraphicsContext* getGraphicsContext() const { return _graphicsContext.get(); }
        
        
        /** Set the Rendering object that is used to implement rendering of the subgraph.*/
        void setRenderingCache(osg::Object* rc) { _renderingCache = rc; }

        /** Get the Rendering object that is used to implement rendering of the subgraph.*/
        osg::Object* getRenderingCache() { return _renderingCache.get(); }

        /** Get the const Rendering object that is used to implement rendering of the subgraph.*/
        const osg::Object* getRenderingCache() const { return _renderingCache.get(); }
 

        /** Draw callback for custom operations.*/
        struct DrawCallback : public Object
        {
            DrawCallback() {}

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

            META_Object(osg,DrawCallback)
        
            virtual void operator () (const osg::CameraNode& camera) const {}
        };
        
        /** Set the post draw callback for custom operations to do done after the drawing of the camera's subgraph has been completed.*/
        void setPostDrawCallback(DrawCallback* cb) { _postDrawCallback = cb; }

        /** Get the post draw callback.*/
        DrawCallback* getPostDrawCallback() { return _postDrawCallback.get(); }

        /** Get the const post draw callback.*/
        const DrawCallback* getPostDrawCallback() const { return _postDrawCallback.get(); }
 

    public:

        /** Transform method that must be defined to provide generic interface for scene graph traversals.*/
        virtual bool computeLocalToWorldMatrix(Matrix& matrix,NodeVisitor*) const;

        /** Transform method that must be defined to provide generic interface for scene graph traversals.*/
        virtual bool computeWorldToLocalMatrix(Matrix& matrix,NodeVisitor*) const;

    protected :
    
        virtual ~CameraNode();

        Vec4                        _clearColor;
        GLbitfield                  _clearMask;
        ref_ptr<ColorMask>           _colorMask;
        ref_ptr<Viewport>           _viewport;

        TransformOrder              _transformOrder;
        Matrixd                     _projectionMatrix;
        Matrixd                     _viewMatrix;
        
        RenderOrder                 _renderOrder;
        
        DrawBufferList              _drawBufferList;
        GLenum                      _readBuffer;
        
        RenderTargetImplementation  _renderTargetImplementation;
        BufferAttachmentMap         _bufferAttachmentMap;

        ref_ptr<GraphicsContext>    _graphicsContext;
        ref_ptr<Object>             _renderingCache;
        
        ref_ptr<DrawCallback>       _postDrawCallback;
};

}

#endif