OpenSceneGraph/include/osg/Drawable

//C++ header - Open Scene Graph - Copyright (C) 1998-2002 Robert Osfield
//Distributed under the terms of the GNU Library General Public License (LGPL)
//as published by the Free Software Foundation.

#ifndef OSG_DRAWABLE
#define OSG_DRAWABLE 1

#include <osg/BoundingBox>
#include <osg/State>
#include <osg/Types>
#include <osg/Vec2>
#include <osg/NodeVisitor>

#include <vector>
#include <map>
#include <set>

namespace osg {

class Vec2;
class Vec3;
class Vec4;
class Node;

// this is define 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 seperate COMPILE very well?!  Define it as default
// the use of a sperate COMPILE, then glCallList rather than use COMPILE_AND_EXECUTE.

#define USE_SEPERATE_COMPILE_AND_EXECUTE

/** Pure virtual base class for drawable Geometry.  Contains no drawing primitives
    directly, these are provided by subclasses such as osg::Geometry. State attributes 
    for a Drawable are maintained in StateSet which the Drawable maintains
    a referenced counted pointer to.  Both Drawable's and StateSet's can 
    be shared for optimal memory usage and graphics performance.
*/
class SG_EXPORT Drawable : public Object
{
    public:

        Drawable();

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

        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const Drawable*>(obj)!=NULL; }
        virtual const char* libraryName() const { return "osg"; }
        virtual const char* className() const { return "Drawable"; }


        /** A vector of osg::Node pointers which is used to store the parent(s) of drawable.*/
        typedef std::vector<Node*> ParentList;

        /** Get the parent list of drawable. */
        inline const ParentList& getParents() const { return _parents; }

        /** Get the a copy of parent list of node. A copy is returned to 
          * prevent modification of the parent list.*/
        inline ParentList getParents() { return _parents; }

        /** Get a single parent of Drawable.
          * @param i index of the parent to get.
          * @return the parent i.
          */
        inline Node* getParent(const unsigned int i)  { return _parents[i]; }
        /** Get a single const parent of Drawable.
          * @param i index of the parent to get.
          * @return the parent i.
          */
        inline const Node* getParent(const unsigned int i) const  { return _parents[i]; }

        /**
         * Get the number of parents of node.
         * @return the number of parents of this node.
         */
        inline const unsigned int getNumParents() const { return _parents.size(); }



        /** Set the StateSet attached to the Drawable.
            Previously attached StateSet are automatically unreferenced on 
            assignment of a new drawstate.*/
        inline void setStateSet(StateSet *state) { _dstate = state; }
        
        /** Get the attached StateSet.*/
        inline StateSet* getStateSet() { return _dstate.get();}

        /** Get the attached const StateSet.*/
        inline const StateSet* getStateSet() const { return _dstate.get();}


        /** Set the drawable to it can or cannot be used in conjunction with OpenGL
          * display lists.  With set to true, calls to Drawable::setUseDisplayList,
          * whereas when set to false, no display lists can be created and calls
          * to setUseDisplayList are ignored, and a warning is produced.  The later
          * is typically used to guard against the switching on of display lists
          * on objects with dynamic internal data such as continuous Level of Detail
          * algorithms.*/
        void setSupportsDisplayList(const bool flag);
      
        /** Get whether display lists are supported for this drawable instance.*/  
        inline const bool getSupportsDisplayList() const { return _supportsDisplayList; }


        /** When set to true, force the draw method to use OpenGL Display List for rendering.
            If false rendering directly.  If the display list has not been already
            compile the next call to draw will automatically create the display list.*/
        void setUseDisplayList(const bool flag);

        /** Return whether OpenGL display lists are being used for rendering.*/
        inline const bool getUseDisplayList() const { return _useDisplayList; }

        /** Force a recompile on next draw() of any OpenGL display list associated with this geoset.*/
        void dirtyDisplayList();
        
        
        /** Dirty the bounding box, forcing a computeBound() on the next call
          * to getBound(). Should be called in the internal geometry of the Drawable
          * is modified.*/        
        void dirtyBound();

        /** get bounding box of geoset. 
          * Note, now made virtual to make it possible to implement user-drawn
          * objects albeit so what crudely, to be improved later.
          */
        inline const BoundingBox& getBound() const
        {
            if( !_bbox_computed)
                computeBound();
            return _bbox;
        }

        /** draw OpenGL primitives. 
          * If the drawable has _useDisplayList set to true then use an OpenGL display
          * list, automatically compiling one if required.
          * Otherwise call drawImmediateMode().
          * Note, draw method should *not* be overridden in subclasses as it 
          * manages the optional display list.
          */
        inline void draw(State& state);
        
        /** Immediately compile this drawable into an OpenGL Display List.
            Note I, operation is ignored if _useDisplayList to false.
            Note II, compile is not intended to be overridden in subclasses.*/
        void compile(State& state);


        struct AppCallback : public osg::Referenced
        {
                /** do customized app code.*/
                virtual void app(osg::NodeVisitor *visitor, osg::Drawable* drawable) = 0;
        };

        /** Set the AppCallback which allows users to attach customize the undating of an object during the app traversal.*/
        void setAppCallback(AppCallback* ac);
        
        /** Get the non const AppCallback.*/
        AppCallback* getAppCallback() { return _appCallback.get(); }
        
        /** Get the const AppCallback.*/
        const AppCallback* getAppCallback() const { return _appCallback.get(); }


        struct CullCallback : public osg::Referenced
        {
                /** do customized cull code.*/
                virtual bool cull(osg::NodeVisitor *visitor, osg::Drawable* drawable, osg::State *state=NULL) const = 0;
        };

        /** Set the CullCallback which allows users to attach customize the culling of Drawable during the cull traversal.*/
        void setCullCallback(CullCallback* cc) { _cullCallback=cc; }
        
        /** Get the non const CullCallback.*/
        CullCallback* getCullCallback() { return _cullCallback.get(); }
        
        /** Get the const CullCallback.*/
        const CullCallback* getCullCallback() const { return _cullCallback.get(); }


        /** Callback attached to an Drawable which allows the users to customize the drawing of an exist Drawable object.
          * The draw callback is implement as a replacement to the Drawable's own drawImmediateMode() method, if the
          * the user intends to decorate the exist draw code then simple call the drawable->drawImmediateMode() from
          * with the callbacks drawImmediateMode() method.  This allows the users to do both pre and post callbacks
          * without fuss and can even diable the inner draw in required.*/
        struct DrawCallback : public osg::Referenced
        {
                /** do customized draw code.*/
                virtual void drawImmediateMode(State& state,osg::Drawable* drawable) const = 0;
        };

        /** Set the DrawCallback which allows users to attach customize the drawing of existing Drawable object.*/
        void setDrawCallback(DrawCallback* dc) { _drawCallback=dc; dirtyDisplayList(); }
        
        /** Get the non const DrawCallback.*/
        DrawCallback* getDrawCallback() { return _drawCallback.get(); }
        
        /** Get the const DrawCallback.*/
        const DrawCallback* getDrawCallback() const { return _drawCallback.get(); }


        /** draw directly ignoring an OpenGL display list which could be attached.
          * This is the internal draw method which does the drawing itself,
          * and is the method to override when deriving from Drawable.
          */
        virtual void drawImmediateMode(State& state) = 0;



        /** use deleteDisplayList instead of glDeleteList to allow
          * OpenGL display list to cached until they can be deleted
          * by the OpenGL context in which they were created, specified
          * by contextID.*/
        static void deleteDisplayList(uint contextID,uint globj);
        
        /** flush all the cached display list which need to be deleted
          * in the OpenGL context related to contextID.*/
        static void flushDeletedDisplayLists(uint contextID);

        typedef uint AttributeBitMask;

        enum AttributeBitMaskValues
        {
            COORDS              = 0x1,
            NORMALS             = 0x2,
            COLORS              = 0x4,
            TEXTURE_COORDS      = 0x8,
            TEXTURE_COORDS_0    = TEXTURE_COORDS,
            TEXTURE_COORDS_1    = 0x10,
            TEXTURE_COORDS_2    = 0x20,
            TEXTURE_COORDS_3    = 0x40
        };
        
        class AttributeFunctor
        {
        public:
        
            AttributeFunctor(AttributeBitMask abm):_abm(abm) {}
            virtual ~AttributeFunctor() {}
        
            void setAttributeBitMask(AttributeBitMask abm) { _abm=abm; }
            AttributeBitMask getAttributeBitMask() const { return _abm; }
        
            virtual bool apply(AttributeBitMask,Vec2*,Vec2*) { return false; }
            virtual bool apply(AttributeBitMask,Vec3*,Vec3*) { return false; }
            virtual bool apply(AttributeBitMask,Vec4*,Vec4*) { return false; }
            
        protected:
        
            AttributeBitMask _abm;
        };

        /** return the attributes supported by applyAttrbuteOperation() as an AttributeBitMask.*/
        virtual AttributeBitMask suppportsAttributeOperation() const { return (AttributeBitMask)0; }

        /** return the attributes successully applied in applyAttributeUpdate.*/
        virtual AttributeBitMask applyAttributeOperation(AttributeFunctor&) { return 0; }
        

        class PrimitiveFunctor
        {
        public:
            
            virtual void setVertexArray(unsigned int count,Vec3* vertices) = 0;
            
            virtual void drawArrays(GLenum mode,GLint first,GLsizei count) = 0;
            virtual void drawElements(GLenum mode,GLsizei count,GLubyte* indices) = 0;
            virtual void drawElements(GLenum mode,GLsizei count,GLushort* indices) = 0;
            virtual void drawElements(GLenum mode,GLsizei count,GLuint* indices) = 0;
            
            virtual void begin(GLenum mode) = 0;
            virtual void vertex(const Vec3& vert) = 0;
            virtual void vertex(float x,float y,float z) = 0;
            virtual void end() = 0;
            
        };
        
        /** apply the internal geometry as basic primitives to a PrimitiveFunctor.*/
        virtual void applyPrimitiveOperation(PrimitiveFunctor&) {}


    protected:

        Drawable& operator = (const Drawable&) { return *this;}

        virtual ~Drawable();

        /** compute the bounding box of the drawable. Method must be 
            implemented by subclasses.*/
        virtual const bool computeBound() const = 0;
        
        void addParent(osg::Node* node);
        void removeParent(osg::Node* node);

        ParentList _parents;
        friend class Node;
        friend class Geode;

        ref_ptr<StateSet>       _dstate;

        bool                    _supportsDisplayList;
        bool                    _useDisplayList;

        typedef std::vector<uint> GLObjectList;
        mutable GLObjectList _globjList;

        mutable BoundingBox     _bbox;
        mutable bool            _bbox_computed;
        
        ref_ptr<AppCallback>    _appCallback;
        ref_ptr<DrawCallback>   _drawCallback;
        ref_ptr<CullCallback>   _cullCallback;
        
        // static cache of deleted display lists which can only 
        // by completely deleted once the appropriate OpenGL context
        // is set.
        typedef std::map<uint,std::set<uint> > DeletedDisplayListCache;
        static DeletedDisplayListCache s_deletedDisplayListCache;

};

inline void Drawable::draw(State& state)
{
    if (_useDisplayList)
    {

        // get the contextID (user defined ID of 0 upwards) for the 
        // current OpenGL context.
        uint contextID = state.getContextID();

        // fill in array if required.
        while (_globjList.size()<=contextID) _globjList.push_back(0);

        // get the globj for the current contextID.
        uint& globj = _globjList[contextID];

        // call the globj if already set otherwise compile and execute.
        if( globj != 0 )
        {
            glCallList( globj );
        }
        else if (_useDisplayList)
        {
#ifdef USE_SEPERATE_COMPILE_AND_EXECUTE
            globj = glGenLists( 1 );
            glNewList( globj, GL_COMPILE );
            if (_drawCallback.valid())
                _drawCallback->drawImmediateMode(state,this);
            else 
                drawImmediateMode(state);
            glEndList();
            
            glCallList( globj);
#else
            globj = glGenLists( 1 );
            glNewList( globj, GL_COMPILE_AND_EXECUTE );
            if (_drawCallback.valid())
                _drawCallback->drawImmediateMode(state,this);
            else 
                drawImmediateMode(state);
            glEndList();
#endif
        }

    }
    else
    {
        // draw object as nature intended..
        if (_drawCallback.valid())
            _drawCallback->drawImmediateMode(state,this);
        else 
            drawImmediateMode(state);
    }
};

template<class T>
class TriangleFunctor : public Drawable::PrimitiveFunctor, public T
{
public:

    TriangleFunctor()
    {
        _vertexArraySize=0;
        _vertexArrayPtr=0;
        _modeCache=0;
    }
    
    virtual ~TriangleFunctor() {}

    virtual void setVertexArray(unsigned int count,Vec3* vertices)
    {
        _vertexArraySize = count;
        _vertexArrayPtr = vertices;
    }

    virtual void drawArrays(GLenum mode,GLint first,GLsizei count)
    {
        if (_vertexArrayPtr==0 && count==0) return;
    
        switch(mode)
        {
            case(GL_TRIANGLES):
            {
                Vec3* vlast = &_vertexArrayPtr[first+count];
                for(Vec3* vptr=&_vertexArrayPtr[first];vptr<vlast;vptr+=3)
                    operator()(*(vptr),*(vptr+1),*(vptr+2));
                break;
            }
            case(GL_TRIANGLE_STRIP):
            {
                Vec3* vptr = &_vertexArrayPtr[first];
                for(GLsizei i=2;i<count;++i,++vptr)
                {
		    if ((i%2)) operator()(*(vptr),*(vptr+2),*(vptr+1));
		    else       operator()(*(vptr),*(vptr+1),*(vptr+2));
                }
                break;
            }
            case(GL_QUADS):
            {
                Vec3* vptr = &_vertexArrayPtr[first];
                for(GLsizei i=3;i<count;i+=4,vptr+=4)
                {
                    operator()(*(vptr),*(vptr+1),*(vptr+2));
                    operator()(*(vptr),*(vptr+2),*(vptr+3));
                }
                break;
            }
            case(GL_QUAD_STRIP):
            {
                Vec3* vptr = &_vertexArrayPtr[first];
                for(GLsizei i=3;i<count;i+=2,vptr+=2)
                {
                    operator()(*(vptr),*(vptr+1),*(vptr+2));
                    operator()(*(vptr+1),*(vptr+3),*(vptr+2));
                }
                break;
            }
            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
            case(GL_TRIANGLE_FAN):
            {
                Vec3* vfirst = &_vertexArrayPtr[first];
                Vec3* vptr = vfirst+1;
                for(GLsizei i=2;i<count;++i,++vptr)
                {
                    operator()(*(vfirst),*(vptr),*(vptr+1));
                }
                break;
            }
            case(GL_POINTS):
            case(GL_LINES):
            case(GL_LINE_STRIP):
            case(GL_LINE_LOOP):
            default:
                // can't be converted into to triangles.
                break;
        }
    }
    
    virtual void drawElements(GLenum mode,GLsizei count,GLubyte* indices)
    {
        if (indices==0 || count==0) return;
    
        typedef GLubyte* IndexPointer;
    
        switch(mode)
        {
            case(GL_TRIANGLES):
            {
                IndexPointer ilast = &indices[count];
                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                break;
            }
            case(GL_TRIANGLE_STRIP):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=2;i<count;++i,++iptr)
                {
		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                }
                break;
            }
            case(GL_QUADS):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=3;i<count;i+=4,iptr+=4)
                {
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
                }
                break;
            }
            case(GL_QUAD_STRIP):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=3;i<count;i+=2,iptr+=2)
                {
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
                }
                break;
            }
            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
            case(GL_TRIANGLE_FAN):
            {
                IndexPointer iptr = indices;
                Vec3& vfirst = _vertexArrayPtr[*iptr];
                ++iptr;
                for(GLsizei i=2;i<count;++i,++iptr)
                {
                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
                }
                break;
            }
            case(GL_POINTS):
            case(GL_LINES):
            case(GL_LINE_STRIP):
            case(GL_LINE_LOOP):
            default:
                // can't be converted into to triangles.
                break;
        }
    }    

    virtual void drawElements(GLenum mode,GLsizei count,GLushort* indices)
    {
        if (indices==0 || count==0) return;
    
        typedef GLushort* IndexPointer;
    
        switch(mode)
        {
            case(GL_TRIANGLES):
            {
                IndexPointer ilast = &indices[count];
                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
                {
                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                }    
                break;
            }
            case(GL_TRIANGLE_STRIP):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=2;i<count;++i,++iptr)
                {
		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                }
                break;
            }
            case(GL_QUADS):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=3;i<count;i+=4,iptr+=4)
                {
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
                }
                break;
            }
            case(GL_QUAD_STRIP):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=3;i<count;i+=2,iptr+=2)
                {
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
                }
                break;
            }
            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
            case(GL_TRIANGLE_FAN):
            {
                IndexPointer iptr = indices;
                Vec3& vfirst = _vertexArrayPtr[*iptr];
                ++iptr;
                for(GLsizei i=2;i<count;++i,++iptr)
                {
                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
                }
                break;
            }
            case(GL_POINTS):
            case(GL_LINES):
            case(GL_LINE_STRIP):
            case(GL_LINE_LOOP):
            default:
                // can't be converted into to triangles.
                break;
        }
    }    

    virtual void drawElements(GLenum mode,GLsizei count,GLuint* indices)
    {
        if (indices==0 || count==0) return;
    
        typedef GLuint* IndexPointer;
    
        switch(mode)
        {
            case(GL_TRIANGLES):
            {
                IndexPointer ilast = &indices[count];
                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                break;
            }
            case(GL_TRIANGLE_STRIP):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=2;i<count;++i,++iptr)
                {
		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                }
                break;
            }
            case(GL_QUADS):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=3;i<count;i+=4,iptr+=4)
                {
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
                }
                break;
            }
            case(GL_QUAD_STRIP):
            {
                IndexPointer iptr = indices;
                for(GLsizei i=3;i<count;i+=2,iptr+=2)
                {
                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
                }
                break;
            }
            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
            case(GL_TRIANGLE_FAN):
            {
                IndexPointer iptr = indices;
                Vec3& vfirst = _vertexArrayPtr[*iptr];
                ++iptr;
                for(GLsizei i=2;i<count;++i,++iptr)
                {
                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
                }
                break;
            }
            case(GL_POINTS):
            case(GL_LINES):
            case(GL_LINE_STRIP):
            case(GL_LINE_LOOP):
            default:
                // can't be converted into to triangles.
                break;
        }
    }    



    /** begin(..),vertex(..) & end() are convinience methods for adapting 
     *  non vertex array primitives to vertex array based primitives.
     * this is done to simplify the implementation of primtive functor
     * subclasses - users only need override drawArray and drawElements.*/
    inline void begin(GLenum mode)
    {
        _modeCache = mode;
        _vertexCache.clear();
    }

    inline void vertex(const Vec3& vert) { _vertexCache.push_back(vert); }
    inline void vertex(float x,float y,float z) { _vertexCache.push_back(osg::Vec3(x,y,z)); }
    inline void end()
    {
        if (!_vertexCache.empty())
        {
            setVertexArray(_vertexCache.size(),&_vertexCache.front());
            drawArrays(_modeCache,0,_vertexCache.size());
        }
    }

protected:


    unsigned int        _vertexArraySize;
    Vec3*               _vertexArrayPtr;

    GLenum              _modeCache;
    std::vector<Vec3>   _vertexCache;

};


}

#endif