Drawable.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_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


namespace osg {


class Vec2f;
class Vec3f;
class Vec4f;
class Vec4ub;
class Geometry;
class NodeVisitor;
class ArrayDispatchers;

// this is defined to alter the way display lists are compiled inside the
// the draw method, it has been found that the NVidia drivers fail completely
// to optimize COMPILE_AND_EXECUTE in fact make it go slower than for no display
// lists, but optimize a separate COMPILE very well?!  Define it as default
// the use of a separate COMPILE, then glCallList rather than use COMPILE_AND_EXECUTE.

#define USE_SEPARATE_COMPILE_AND_EXECUTE

class OSG_EXPORT Drawable : public Node
{
    public:

        static unsigned int s_numberDrawablesReusedLastInLastFrame;
        static unsigned int s_numberNewDrawablesInLastFrame;
        static unsigned int s_numberDeletedDrawablesInLastFrame;

        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) { _initialBound = bbox; dirtyBound(); }

        const BoundingBox& getInitialBound() const { return _initialBound; }

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

        inline const BoundingBox& getBoundingBox() const
        {
            if(!_boundingSphereComputed)
            {
                _boundingBox = _initialBound;

                if (_computeBoundCallback.valid())
                    _boundingBox.expandBy(_computeBoundCallback->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&,const CopyOp&) {}

            META_Object(osg,ComputeBoundingBoxCallback);

            virtual BoundingBox computeBound(const osg::Drawable&) const  { return BoundingBox(); }
        };

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

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

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


        inline void setShape(Shape* shape) { _shape = shape; }

        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; }


        virtual void dirtyDisplayList();


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



        inline void draw(RenderInfo& renderInfo) const;

        virtual void compileGLObjects(RenderInfo& renderInfo) const;

        virtual void setThreadSafeRefUnref(bool threadSafe);

        virtual void resizeGLObjectBuffers(unsigned int maxSize);

        virtual void releaseGLObjects(State* state=0) const;

        struct OSG_EXPORT UpdateCallback : public virtual Callback
        {
            UpdateCallback() {}

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

            META_Object(osg,UpdateCallback);

            virtual bool run(osg::Object* object, osg::Object* data);

            virtual void update(osg::NodeVisitor*, osg::Drawable*) {}
        };


        struct OSG_EXPORT EventCallback : public virtual Callback
        {
            EventCallback() {}

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

            META_Object(osg,EventCallback);

            virtual bool run(osg::Object* object, osg::Object* data);

            virtual void event(osg::NodeVisitor*, osg::Drawable*) {}
        };

        struct CullCallback : public virtual Callback
        {
            CullCallback() {}

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

            META_Object(osg,CullCallback);

            // just use the standard run implementation to passes run onto any nested callbacks.
            using Callback::run;

            virtual bool cull(osg::NodeVisitor*, osg::Drawable*, osg::State*) const { return false; }

            virtual bool cull(osg::NodeVisitor* nv, osg::Drawable* drawable, osg::RenderInfo* renderInfo) const { return cull(nv, drawable, renderInfo? renderInfo->getState():0); }
        };


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

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

            META_Object(osg,DrawCallback);

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

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

        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 setMinimumNumberOfDisplayListsToRetainInCache(unsigned int minimum);

        static unsigned int getMinimumNumberOfDisplayListsToRetainInCache();

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

        static void flushAllDeletedDisplayLists(unsigned int contextID);

        static void discardAllDeletedDisplayLists(unsigned int contextID);

        static void flushDeletedDisplayLists(unsigned int contextID,double& availableTime);

        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                         _initialBound;
        ref_ptr<ComputeBoundingBoxCallback> _computeBoundCallback;
        mutable BoundingBox                 _boundingBox;
        mutable bool                        _boundingBoxComputed;

        ref_ptr<Shape>          _shape;

        bool                    _supportsDisplayList;
        bool                    _useDisplayList;
        bool                    _supportsVertexBufferObjects;
        bool                    _useVertexBufferObjects;

        typedef osg::buffered_value<GLuint> GLObjectList;
        mutable GLObjectList    _globjList;

        ref_ptr<UpdateCallback> _drawableUpdateCallback;
        ref_ptr<EventCallback>  _drawableEventCallback;

        ref_ptr<CullCallback>   _drawableCullCallback;
        ref_ptr<DrawCallback>   _drawCallback;
};

inline void Drawable::draw(RenderInfo& renderInfo) const
{
#ifdef OSG_GL_DISPLAYLISTS_AVAILABLE
    if (_useDisplayList && !(_supportsVertexBufferObjects && _useVertexBufferObjects && renderInfo.getState()->isVertexBufferObjectSupported()))
    {
        // 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];

        // call the globj if already set otherwise compile and execute.
        if( globj != 0 )
        {
            glCallList( globj );
        }
        else if (_useDisplayList)
        {
#ifdef USE_SEPARATE_COMPILE_AND_EXECUTE
            globj = generateDisplayList(contextID, getGLObjectSizeHint());
            glNewList( globj, GL_COMPILE );
            if (_drawCallback.valid())
                _drawCallback->drawImplementation(renderInfo,this);
            else
                drawImplementation(renderInfo);
            glEndList();

            glCallList( globj);
#else
            globj = generateDisplayList(contextID, getGLObjectSizeHint());
            glNewList( globj, GL_COMPILE_AND_EXECUTE );
            if (_drawCallback.valid())
                _drawCallback->drawImplementation(renderInfo,this);
            else
                drawImplementation(renderInfo);
            glEndList();
#endif
        }

        return;

    }
#endif

    // draw object as nature intended..
    if (_drawCallback.valid())
        _drawCallback->drawImplementation(renderInfo,this);
    else
        drawImplementation(renderInfo);
}

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