Drawable

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_DRAWABLE
#define OSG_DRAWABLE 1
 
#include <osg/BoundingBox>
#include <osg/Shape>
#include <osg/BufferObject>
#include <osg/PrimitiveSet>
#include <osg/RenderInfo>
#include <osg/Group>
 
 
#ifndef GL_NV_occlusion_query
 
    #define GL_OCCLUSION_TEST_HP                0x8165
    #define GL_OCCLUSION_TEST_RESULT_HP         0x8166
    #define GL_PIXEL_COUNTER_BITS_NV            0x8864
    #define GL_CURRENT_OCCLUSION_QUERY_ID_NV    0x8865
    #define GL_PIXEL_COUNT_NV                   0x8866
    #define GL_PIXEL_COUNT_AVAILABLE_NV         0x8867
 
#endif
 
#ifndef GL_ARB_occlusion_query
 
    #define GL_SAMPLES_PASSED_ARB               0x8914
    #define GL_QUERY_COUNTER_BITS_ARB           0x8864
    #define GL_CURRENT_QUERY_ARB                0x8865
    #define GL_QUERY_RESULT_ARB                 0x8866
    #define GL_QUERY_RESULT_AVAILABLE_ARB       0x8867
 
#endif
 
 
#ifndef GL_TIME_ELAPSED
    #define GL_TIME_ELAPSED                    0x88BF
    #define GL_TIMESTAMP                       0x8E28
#endif
 
#ifndef GL_QUERY_RESULT
    #define GL_QUERY_RESULT                     0x8866
    #define GL_QUERY_RESULT_AVAILABLE           0x8867
#endif
 
 
#define INLINE_DRAWABLE_DRAW
 
namespace osg {
 
 
class Vec2f;
class Vec3f;
class Vec4f;
class Vec4ub;
class Geometry;
class NodeVisitor;
class ArrayDispatchers;

class OSG_EXPORT Drawable : public Node
{
    public:
 
        Drawable();

        Drawable(const Drawable& drawable,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
 
        META_Node(osg, Drawable);

        virtual Drawable* asDrawable() { return this; }

        virtual const Drawable* asDrawable() const { return this; }

        virtual void computeDataVariance();

        MatrixList getWorldMatrices(const osg::Node* haltTraversalAtNode=0) const;
 

        void setInitialBound(const osg::BoundingBox& bbox) { _initialBoundingBox = bbox; dirtyBound(); }

        const BoundingBox& getInitialBound() const { return _initialBoundingBox; }
 
        inline const BoundingSphere& getBound() const
        {
            if(!_boundingSphereComputed) getBoundingBox();
            return _boundingSphere;
        }

        inline const BoundingBox& getBoundingBox() const
        {
            if(!_boundingSphereComputed)
            {
                _boundingBox = _initialBoundingBox;
 
                if (_computeBoundingBoxCallback.valid())
                    _boundingBox.expandBy(_computeBoundingBoxCallback->computeBound(*this));
                else
                    _boundingBox.expandBy(computeBoundingBox());
 
                if(_boundingBox.valid()){
                    _boundingSphere.set(_boundingBox.center(), _boundingBox.radius());
                } else {
                    _boundingSphere.init();
                }
 
                _boundingSphereComputed = true;
            }
 
            return _boundingBox;
        }
 

        virtual BoundingSphere computeBound() const;

        virtual BoundingBox computeBoundingBox() const;

        struct ComputeBoundingBoxCallback : public osg::Object
        {
            ComputeBoundingBoxCallback() {}
 
            ComputeBoundingBoxCallback(const ComputeBoundingBoxCallback& org,const CopyOp& copyop):
                Object(org, copyop) {}
 
            META_Object(osg,ComputeBoundingBoxCallback);
 
            virtual BoundingBox computeBound(const osg::Drawable&) const  { return BoundingBox(); }
        };

        void setComputeBoundingBoxCallback(ComputeBoundingBoxCallback* callback) { _computeBoundingBoxCallback = callback; }

        ComputeBoundingBoxCallback* getComputeBoundingBoxCallback() { return _computeBoundingBoxCallback.get(); }

        const ComputeBoundingBoxCallback* getComputeBoundingBoxCallback() const { return _computeBoundingBoxCallback.get(); }
 

        virtual void setShape(Shape* shape) { _shape = shape; }
 
        template<class T> void setShape(const ref_ptr<T>& shape) { setShape(shape.get()); }

        inline Shape* getShape() { return _shape.get(); }

        inline const Shape* getShape() const { return _shape.get(); }
 
 

        void setSupportsDisplayList(bool flag);

        inline bool getSupportsDisplayList() const { return _supportsDisplayList; }
 

        void setUseDisplayList(bool flag);

        inline bool getUseDisplayList() const { return _useDisplayList; }

        inline GLuint& getDisplayList(unsigned int contextID) const { return _globjList[contextID]; }

        virtual void setUseVertexBufferObjects(bool flag);

        inline bool getUseVertexBufferObjects() const { return _useVertexBufferObjects; }
 

        void setUseVertexArrayObject(bool flag);

        bool getUseVertexArrayObject() const { return _useVertexArrayObject; }
 
#ifdef OSG_USE_DEPRECATED_API
        inline void dirtyDisplayList()
        {
            dirtyGLObjects();
        }
#endif

        virtual void dirtyGLObjects();
 

        virtual unsigned int getGLObjectSizeHint() const { return 0; }
 
 

#ifdef INLINE_DRAWABLE_DRAW
        inline void draw(RenderInfo& renderInfo) const;
#else
        void draw(RenderInfo& renderInfo) const;
#endif
 
        inline void drawInner(RenderInfo& renderInfo) const
        {
            if (_drawCallback.valid())
                _drawCallback->drawImplementation(renderInfo,this);
            else
                drawImplementation(renderInfo);
        }
 

        virtual void compileGLObjects(RenderInfo& renderInfo) const;
 

        struct CreateVertexArrayStateCallback : public virtual osg::Object
        {
            CreateVertexArrayStateCallback() {}
 
            CreateVertexArrayStateCallback(const CreateVertexArrayStateCallback& rhs,const CopyOp& copyop):
                Object(rhs, copyop) {}
 
            META_Object(osg, CreateVertexArrayStateCallback);

            virtual osg::VertexArrayState* createVertexArrayStateImplementation(osg::RenderInfo& renderInfo, const osg::Drawable* drawable) const
            {
                return drawable->createVertexArrayStateImplementation(renderInfo);
            }
        };
 

        void setCreateVertexArrayStateCallback(CreateVertexArrayStateCallback* cb) { _createVertexArrayStateCallback = cb; }

        CreateVertexArrayStateCallback* getCreateVertexArrayStateCallback() { return _createVertexArrayStateCallback.get(); }

        const CreateVertexArrayStateCallback* getCreateVertexArrayStateCallback() const { return _createVertexArrayStateCallback.get(); }
 

        inline VertexArrayState* createVertexArrayState(RenderInfo& renderInfo) const
        {
            if (_createVertexArrayStateCallback.valid()) return _createVertexArrayStateCallback->createVertexArrayStateImplementation(renderInfo, this);
            else return createVertexArrayStateImplementation(renderInfo);
        }

        virtual VertexArrayState* createVertexArrayStateImplementation(RenderInfo& renderInfo) const;
 
        void setVertexArrayStateList(VertexArrayStateList& vasl) { _vertexArrayStateList = vasl; }
 
        VertexArrayStateList& getVertexArrayStateList() { return _vertexArrayStateList; }
 
        const VertexArrayStateList& getVertexArrayStateList() const { return _vertexArrayStateList; }
 
 

        virtual void setThreadSafeRefUnref(bool threadSafe);

        virtual void resizeGLObjectBuffers(unsigned int maxSize);

        virtual void releaseGLObjects(State* state=0) const;
 
        // for backwards compatibility as local implementations are now found in osg namespace within the include/osg/Callback header
        typedef DrawableUpdateCallback UpdateCallback;
        typedef DrawableEventCallback EventCallback;
        typedef DrawableCullCallback CullCallback;

        struct DrawCallback : public virtual osg::Object
        {
            DrawCallback() {}
 
            DrawCallback(const DrawCallback& org,const CopyOp& copyop):
                Object(org, copyop) {}
 
            META_Object(osg,DrawCallback);

            virtual void drawImplementation(osg::RenderInfo& /*renderInfo*/,const osg::Drawable* /*drawable*/) const {}
        };

        virtual void setDrawCallback(DrawCallback* dc) { _drawCallback=dc; dirtyGLObjects(); }

        DrawCallback* getDrawCallback() { return _drawCallback.get(); }

        const DrawCallback* getDrawCallback() const { return _drawCallback.get(); }

        virtual void drawImplementation(RenderInfo& /*renderInfo*/) const {}
 

        static GLuint generateDisplayList(unsigned int contextID, unsigned int sizeHint = 0);

        static void deleteDisplayList(unsigned int contextID,GLuint globj, unsigned int sizeHint = 0);

        static void setMinimumNumberOfDisplayListsToRetainInCache(unsigned int minimum);

        static unsigned int getMinimumNumberOfDisplayListsToRetainInCache();
 
 
 
        typedef unsigned int AttributeType;
 
        enum AttributeTypes
        {
            VERTICES            = 0,
            WEIGHTS             = 1,
            NORMALS             = 2,
            COLORS              = 3,
            SECONDARY_COLORS    = 4,
            FOG_COORDS          = 5,
            ATTRIBUTE_6         = 6,
            ATTRIBUTE_7         = 7,
            TEXTURE_COORDS      = 8,
            TEXTURE_COORDS_0    = TEXTURE_COORDS,
            TEXTURE_COORDS_1    = TEXTURE_COORDS_0+1,
            TEXTURE_COORDS_2    = TEXTURE_COORDS_0+2,
            TEXTURE_COORDS_3    = TEXTURE_COORDS_0+3,
            TEXTURE_COORDS_4    = TEXTURE_COORDS_0+4,
            TEXTURE_COORDS_5    = TEXTURE_COORDS_0+5,
            TEXTURE_COORDS_6    = TEXTURE_COORDS_0+6,
            TEXTURE_COORDS_7    = TEXTURE_COORDS_0+7
            // only eight texture coord examples provided here, but underlying code can handle any no of texture units,
            // simply co them as (TEXTURE_COORDS_0+unit).
        };
 
        class AttributeFunctor
        {
        public:
            virtual ~AttributeFunctor() {}
 
            virtual void apply(AttributeType,unsigned int,GLbyte*) {}
            virtual void apply(AttributeType,unsigned int,GLshort*) {}
            virtual void apply(AttributeType,unsigned int,GLint*) {}
 
            virtual void apply(AttributeType,unsigned int,GLubyte*) {}
            virtual void apply(AttributeType,unsigned int,GLushort*) {}
            virtual void apply(AttributeType,unsigned int,GLuint*) {}
 
            virtual void apply(AttributeType,unsigned int,float*) {}
            virtual void apply(AttributeType,unsigned int,Vec2*) {}
            virtual void apply(AttributeType,unsigned int,Vec3*) {}
            virtual void apply(AttributeType,unsigned int,Vec4*) {}
            virtual void apply(AttributeType,unsigned int,Vec4ub*) {}
 
            virtual void apply(AttributeType,unsigned int,double*) {}
            virtual void apply(AttributeType,unsigned int,Vec2d*) {}
            virtual void apply(AttributeType,unsigned int,Vec3d*) {}
            virtual void apply(AttributeType,unsigned int,Vec4d*) {}
        };
 

        virtual bool supports(const AttributeFunctor&) const { return false; }

        virtual void accept(AttributeFunctor&) {}
 
 
        class ConstAttributeFunctor
        {
        public:
 
            virtual ~ConstAttributeFunctor() {}
 
            virtual void apply(AttributeType,unsigned int,const GLbyte*) {}
            virtual void apply(AttributeType,unsigned int,const GLshort*) {}
            virtual void apply(AttributeType,unsigned int,const GLint*) {}
 
            virtual void apply(AttributeType,unsigned int,const GLubyte*) {}
            virtual void apply(AttributeType,unsigned int,const GLushort*) {}
            virtual void apply(AttributeType,unsigned int,const GLuint*) {}
 
            virtual void apply(AttributeType,unsigned int,const float*) {}
            virtual void apply(AttributeType,unsigned int,const Vec2*) {}
            virtual void apply(AttributeType,unsigned int,const Vec3*) {}
            virtual void apply(AttributeType,unsigned int,const Vec4*) {}
            virtual void apply(AttributeType,unsigned int,const Vec4ub*) {}
 
            virtual void apply(AttributeType,unsigned int,const double*) {}
            virtual void apply(AttributeType,unsigned int,const Vec2d*) {}
            virtual void apply(AttributeType,unsigned int,const Vec3d*) {}
            virtual void apply(AttributeType,unsigned int,const Vec4d*) {}
        };

        virtual bool supports(const ConstAttributeFunctor&) const { return false; }

        virtual void accept(ConstAttributeFunctor&) const {}
 
 

        virtual bool supports(const PrimitiveFunctor&) const { return false; }

        virtual void accept(PrimitiveFunctor&) const {}

        virtual bool supports(const PrimitiveIndexFunctor&) const { return false; }

        virtual void accept(PrimitiveIndexFunctor&) const {}
 
    protected:
 
        Drawable& operator = (const Drawable&) { return *this;}
 
        virtual ~Drawable();

        void setBound(const BoundingBox& bb) const;
 
        friend class Node;
        friend class Geode;
        friend class StateSet;
 
        BoundingBox                         _initialBoundingBox;
        ref_ptr<ComputeBoundingBoxCallback> _computeBoundingBoxCallback;
        mutable BoundingBox                 _boundingBox;
 
        ref_ptr<Shape>          _shape;
 
        bool                    _supportsDisplayList;
        bool                    _useDisplayList;
        bool                    _supportsVertexBufferObjects;
        bool                    _useVertexBufferObjects;
        bool                    _useVertexArrayObject;
 
        typedef osg::buffered_value<GLuint> GLObjectList;
        mutable GLObjectList    _globjList;
 
        mutable VertexArrayStateList    _vertexArrayStateList;
 
        ref_ptr<DrawCallback>   _drawCallback;
        ref_ptr<CreateVertexArrayStateCallback> _createVertexArrayStateCallback;
};
 
#ifdef INLINE_DRAWABLE_DRAW
inline void Drawable::draw(RenderInfo& renderInfo) const
{
    State& state = *renderInfo.getState();
    bool useVertexArrayObject = state.useVertexArrayObject(_useVertexArrayObject);
    if (useVertexArrayObject)
    {
        unsigned int contextID = renderInfo.getContextID();
 
        VertexArrayState* vas = _vertexArrayStateList[contextID].get();
        if (!vas)
        {
            _vertexArrayStateList[contextID] = vas = createVertexArrayState(renderInfo);
        }
        else
        {
            // vas->setRequiresSetArrays(getDataVariance()==osg::Object::DYNAMIC);
        }
 
        State::SetCurrentVertexArrayStateProxy setVASProxy(state, vas);
 
        state.bindVertexArrayObject(vas);
 
        drawInner(renderInfo);
 
        vas->setRequiresSetArrays(getDataVariance()==osg::Object::DYNAMIC);
 
        return;
    }
 
    // TODO, add check against whether VAO is active and supported
    if (state.getCurrentVertexArrayState())
    {
        //OSG_NOTICE<<"state.getCurrentVertexArrayState()->getVertexArrayObject()="<< state.getCurrentVertexArrayState()->getVertexArrayObject()<<std::endl;
        state.bindVertexArrayObject(state.getCurrentVertexArrayState());
    }
 
 
#ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
    if (!state.useVertexBufferObject(_supportsVertexBufferObjects && _useVertexBufferObjects) && _useDisplayList)
    {
        // get the contextID (user defined ID of 0 upwards) for the
        // current OpenGL context.
        unsigned int contextID = renderInfo.getContextID();
 
        // get the globj for the current contextID.
        GLuint& globj = _globjList[contextID];
 
        if( globj == 0 )
        {
            // compile the display list
            globj = generateDisplayList(contextID, getGLObjectSizeHint());
            glNewList( globj, GL_COMPILE );
 
            drawInner(renderInfo);
 
            glEndList();
        }
 
        // call the display list
        glCallList( globj);
    }
    else
#endif
    {
        // if state.previousVertexArrayState() is different than currentVertexArrayState bind current
 
        // OSG_NOTICE<<"Fallback drawInner()........................"<<std::endl;
 
        drawInner(renderInfo);
    }
}
#endif
 
class AttributeFunctorArrayVisitor : public ArrayVisitor
{
    public:
 
        AttributeFunctorArrayVisitor(Drawable::AttributeFunctor& af):
            _af(af),
            _type(0) {}
 
        virtual ~AttributeFunctorArrayVisitor() {}
 
        virtual void apply(ByteArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(ShortArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(IntArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(UByteArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(UShortArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(UIntArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(Vec4ubArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(FloatArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(Vec2Array& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(Vec3Array& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(Vec4Array& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(DoubleArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(Vec2dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(Vec3dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(Vec4dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
 
 
        inline void applyArray(Drawable::AttributeType type,Array* array)
        {
            if (array)
            {
                _type = type;
                array->accept(*this);
            }
        }
 
    protected:
 
        AttributeFunctorArrayVisitor& operator = (const AttributeFunctorArrayVisitor&) { return *this; }
        Drawable::AttributeFunctor&   _af;
        Drawable::AttributeType       _type;
};
 
class ConstAttributeFunctorArrayVisitor : public ConstArrayVisitor
{
    public:
 
        ConstAttributeFunctorArrayVisitor(Drawable::ConstAttributeFunctor& af):
            _af(af),
            _type(0) {}
 
        virtual ~ConstAttributeFunctorArrayVisitor() {}
 
        virtual void apply(const ByteArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const ShortArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const IntArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const UByteArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const UShortArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const UIntArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const Vec4ubArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const FloatArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const Vec2Array& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const Vec3Array& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const Vec4Array& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const DoubleArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const Vec2dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const Vec3dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
        virtual void apply(const Vec4dArray& array) {  if (!array.empty()) _af.apply(_type,array.size(),&(array.front())); }
 
 
        inline void applyArray(Drawable::AttributeType type,const Array* array)
        {
            if (array)
            {
                _type = type;
                array->accept(*this);
            }
        }
 
protected:
 
        ConstAttributeFunctorArrayVisitor& operator = (const ConstAttributeFunctorArrayVisitor&) { return *this; }
 
        Drawable::ConstAttributeFunctor&    _af;
        Drawable::AttributeType             _type;
};
 
}
 
#endif