OpenSceneGraph/include/osg/Geometry

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 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_GEOMETRY
#define OSG_GEOMETRY 1

#include <osg/Drawable>
#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Vec4>
#include <osg/Array>
#include <osg/PrimitiveSet>

namespace osg {


class SG_EXPORT Geometry : public Drawable
{
    public:

        Geometry();

        /** Copy constructor using CopyOp to manage deep vs shallow copy.*/
        Geometry(const Geometry& geometry,const CopyOp& copyop=CopyOp::SHALLOW_COPY);
            
        virtual Object* cloneType() const { return new Geometry(); }
        virtual Object* clone(const CopyOp& copyop) const { return new Geometry(*this,copyop); }        
        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const Geometry*>(obj)!=NULL; }
        virtual const char* libraryName() const { return "osg"; }
        virtual const char* className() const { return "Geometry"; }

        virtual Geometry* asGeometry() { return this; }
        virtual const Geometry* asGeometry() const { return this; }

        enum AttributeBinding
        {
            BIND_OFF=0,
            BIND_OVERALL,
            BIND_PER_PRIMITIVE_SET,
            BIND_PER_PRIMITIVE,
            BIND_PER_VERTEX
        };
               
        void setVertexArray(Vec3Array* array) { _vertexArray = array; dirtyDisplayList(); dirtyBound(); }
        Vec3Array* getVertexArray() { return _vertexArray.get(); }
        const Vec3Array* getVertexArray() const  { return _vertexArray.get(); }

        void setVertexIndices(IndexArray* array) { _vertexIndices = array; _fastPathComputed=false; dirtyDisplayList(); dirtyBound(); }
        IndexArray* getVertexIndices() { return _vertexIndices.get(); }
        const IndexArray* getVertexIndices() const  { return _vertexIndices.get(); }


        void setNormalBinding(AttributeBinding ab) { _normalBinding = ab; dirtyDisplayList(); _fastPathComputed=false; }
        AttributeBinding getNormalBinding() const { return _normalBinding; }

        void setNormalArray(Vec3Array* array) { _normalArray = array; if (!_normalArray.valid()) _normalBinding=BIND_OFF; _fastPathComputed=false; dirtyDisplayList(); }
        Vec3Array* getNormalArray() { return _normalArray.get(); }
        const Vec3Array* getNormalArray() const { return _normalArray.get(); }

        void setNormalIndices(IndexArray* array) { _normalIndices = array; _fastPathComputed=false; dirtyDisplayList(); }
        IndexArray* getNormalIndices() { return _normalIndices.get(); }
        const IndexArray* getNormalIndices() const { return _normalIndices.get(); }


        void setColorBinding(AttributeBinding ab) { _colorBinding = ab; _fastPathComputed=false;}
        AttributeBinding getColorBinding() const { return _colorBinding; }

        void setColorArray(Array* array) { _colorArray = array;  if (!_colorArray.valid()) _colorBinding=BIND_OFF; _fastPathComputed=false; dirtyDisplayList(); }
        Array* getColorArray() { return _colorArray.get(); }
        const Array* getColorArray() const { return _colorArray.get(); }

        void setColorIndices(IndexArray* array) { _colorIndices = array;  _fastPathComputed=false; dirtyDisplayList(); }
        IndexArray* getColorIndices() { return _colorIndices.get(); }
        const IndexArray* getColorIndices() const { return _colorIndices.get(); }


        void setSecondaryColorBinding(AttributeBinding ab) { _secondaryColorBinding = ab; _fastPathComputed=false;}
        AttributeBinding getSecondaryColorBinding() const { return _secondaryColorBinding; }

        void setSecondaryColorArray(Array* array) { _secondaryColorArray = array;  if (!_secondaryColorArray.valid()) _secondaryColorBinding=BIND_OFF; _fastPathComputed=false; dirtyDisplayList(); }
        Array* getSecondaryColorArray() { return _secondaryColorArray.get(); }
        const Array* getSecondaryColorArray() const { return _secondaryColorArray.get(); }

        void setSecondaryColorIndices(IndexArray* array) { _secondaryColorIndices = array;  _fastPathComputed=false; dirtyDisplayList(); }
        IndexArray* getSecondaryColorIndices() { return _secondaryColorIndices.get(); }
        const IndexArray* getSecondaryColorIndices() const { return _secondaryColorIndices.get(); }


        void setFogCoordBinding(AttributeBinding ab) { _fogCoordBinding = ab; _fastPathComputed=false;}
        AttributeBinding getFogCoordBinding() const { return _fogCoordBinding; }

        void setFogCoordArray(Array* array) { _fogCoordArray = array; if (!_fogCoordArray.valid()) _fogCoordBinding=BIND_OFF; dirtyDisplayList(); }
        Array* getFogCoordArray() { return _fogCoordArray.get(); }
        const Array* getFogCoordArray() const { return _fogCoordArray.get(); }


        void setFogCoordIndices(IndexArray* array) { _fogCoordIndices = array; dirtyDisplayList(); }
        IndexArray* getFogCoordIndices() { return _fogCoordIndices.get(); }
        const IndexArray* getFogCoordIndices() const { return _fogCoordIndices.get(); }



        typedef std::pair< ref_ptr<Array>, ref_ptr<IndexArray> >  TexCoordArrayPair;
        typedef std::vector< TexCoordArrayPair >  TexCoordArrayList;


        void setTexCoordArray(unsigned int unit,Array*);
        Array* getTexCoordArray(unsigned int unit);
        const Array* getTexCoordArray(unsigned int unit) const;
        
        void setTexCoordIndices(unsigned int unit,IndexArray*);
        IndexArray* getTexCoordIndices(unsigned int unit);
        const IndexArray* getTexCoordIndices(unsigned int unit) const;

        unsigned int getNumTexCoordArrays() const {  return _texCoordList.size(); }
        TexCoordArrayList& getTexCoordArrayList() { return _texCoordList; }
        const TexCoordArrayList& getTexCoordArrayList() const { return _texCoordList; }


#ifdef COMPILE_POSSIBLE_NEW_ARRAY_METHODS

        void setArray(AttributeType type, Array* array);
        Array* getArray(AttributeType type);
        const Array* getArray(AttributeType type) const;
        
        void setIndices(AttributeType type, IndexArray* indices);
        IndexArray* getIndices(AttributeType type);
        const IndexArray* getIndices(AttributeType type) const;
        
        void setNormalize(AttributeType type, GLboolean normalize);
        GLboolean getNormalize(AttributeType type) const;
        
        void setBinding(AttributeType type,AttributeBinding binding);
        AttributeBinding getBinding(AttributeType type) const;
        
        struct AttributeData
        {
            AttributeData():
                _normalize(GL_FALSE),
                _binding(BIND_OFF) {}
        
            ref_ptr<Array>          _array;
            ref_ptr<IndexArray>     _indices;
            GLboolean               _normalize;
            AttributeBinding        _binding;
        };
        
        unsigned int getNumArrays() const { return _attributeList.size(); }
        
        AttributeData& getAttributeData(unsigned int type) { return _attributeList[type]; }
        
        const AttributeData& getAttributeData(unsigned int type) const { return _attributeList[type]; }

        typedef std::vector<AttributeData> AttributeList;
        
        void setAttributeList(AttributeList& al) { _attributeList = al; }
                
        AttributeList& getAttributeList() { return _attributeList; }
        
        const AttributeList& getAttributeList() const { return _attributeList; }
        
#endif

        typedef std::pair< ref_ptr<Array>, ref_ptr<IndexArray> > VertexAttribArrayPair;
        typedef std::pair< GLboolean, VertexAttribArrayPair > VertexAttribNormArrayPair;
        typedef std::vector< VertexAttribNormArrayPair > VertexAttribArrayList;
        typedef std::vector< AttributeBinding > VertexAttribBindingList;

        void setVertexAttribArray(unsigned int index,bool normalize,Array* array,AttributeBinding ab=BIND_OFF);
        Array *getVertexAttribArray(unsigned int index);
        const Array *getVertexAttribArray(unsigned int index) const;

        bool getVertexAttribNormalize(unsigned int index, GLboolean &ret) const;
        bool getVertexAttribBinding(unsigned int index, AttributeBinding& ab) const;

        void setVertexAttribIndices(unsigned int index,IndexArray* array);
        IndexArray* getVertexAttribIndices(unsigned int index);
        const IndexArray* getVertexAttribIndices(unsigned int index) const;

        unsigned int getNumVertexAttribArrays() const { return _vertexAttribList.size(); }
        VertexAttribArrayList& getVertexAttribArrayList() { return _vertexAttribList; }
        const VertexAttribArrayList& getVertexAttribArrayList() const { return _vertexAttribList; }



        typedef std::vector< ref_ptr<PrimitiveSet> > PrimitiveSetList;

        void setPrimitiveSetList(const PrimitiveSetList& primitives) { _primitives = primitives; dirtyDisplayList(); dirtyBound(); }
        PrimitiveSetList& getPrimitiveSetList() { return _primitives; }
        const PrimitiveSetList& getPrimitiveSetList() const { return _primitives; }

        unsigned int getNumPrimitiveSets() const { return _primitives.size(); }
        PrimitiveSet* getPrimitiveSet(unsigned int pos) { return _primitives[pos].get(); }
        const PrimitiveSet* getPrimitiveSet(unsigned int pos) const { return _primitives[pos].get(); }
        
        /** Add a primitive set to the geometry.*/
        bool addPrimitiveSet(PrimitiveSet* primitiveset);
        
        /** Set a primitive set to the specified position in geometry's primitive set list.*/
        bool setPrimitiveSet(unsigned int i,PrimitiveSet* primitiveset);
        
        /** Insert a primitive set to the specified position in geometry's primitive set list.*/
        bool insertPrimitiveSet(unsigned int i,PrimitiveSet* primitiveset);
        
        /** Remove primitive set(s) from the specified position in geometry's primitive set list.*/
        bool removePrimitiveSet(unsigned int i,unsigned int numElementsToRemove=1);

        /** Get the index number of a primitive set, return a value between
          * 0 and getNumPrimitiveSet()-1 if found, if not found then return getNumPrimitiveSet().
          * When checking for a valid find value use if ((value=geoemtry->getPrimitiveSetIndex(primitive))!=geometry.getNumPrimitiveSet()) as*/
        unsigned int getPrimitiveSetIndex(const PrimitiveSet* primitiveset) const;


        /** return true if OpenGL fast paths will be used with drawing this Geometry.
          * Fast paths use vertex arrays, and glDrawArrays/glDrawElements.  Slow paths
          * use glBegin()/glVertex.../glEnd(). Use of per primitive bindings or per vertex indexed
          * arrays will drop the rendering path off the fast path.*/
        bool areFastPathsUsed() const;


        bool verifyBindings() const;
        void computeCorrectBindingsAndArraySizes();


        /** draw Geometry 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 Geometry for user-drawn objects.
          */
        virtual void drawImplementation(State& state) const;

        /** return true, osg::Geometry does support accept(AttributeFunctor&).*/
        virtual bool supports(AttributeFunctor&) const { return true; }

        /** accept an AttributeFunctor and call its methods to tell it about the interal attributes that this Drawable has.*/
        virtual void accept(AttributeFunctor& af);

        /** return true, osg::Geometry does support accept(ConstAttributeFunctor&).*/
        virtual bool supports(ConstAttributeFunctor&) const { return true; }

        /** accept an ConstAttributeFunctor and call its methods to tell it about the interal attributes that this Drawable has.*/
        virtual void accept(ConstAttributeFunctor& af) const;

        /** return true, osg::Geometry does support accept(PrimitiveFunctor&) .*/
        virtual bool supports(PrimitiveFunctor&) const { return true; }

        /** accept a PrimitiveFunctor and call its methods to tell it about the interal primitives that this Drawable has.*/
        virtual void accept(PrimitiveFunctor& pf) const;

        /** Extensions class which encapsulates the querring of extensions and
        * associated function pointers, and provide convinience wrappers to 
        * check for the extensions or use the associated functions.*/        
        class SG_EXPORT Extensions : public osg::Referenced
        {
        public:
            Extensions();

            Extensions(const Extensions& rhs);

            void lowestCommonDenominator(const Extensions& rhs);

            void setupGLExtenions();

            void setVertexProgramSupported(bool flag) { _isVertexProgramSupported=flag; }
            bool isVertexProgramSupported() const { return _isVertexProgramSupported; }

            void setSecondaryColorSupported(bool flag) { _isSecondaryColorSupported=flag; }
            bool isSecondaryColorSupported() const { return _isSecondaryColorSupported; }

            void setFogCoordSupported(bool flag) { _isFogCoordSupported=flag; }
            bool isFogCoordSupported() const { return _isFogCoordSupported; }

            void setMultiTexSupported(bool flag) { _isMultiTexSupported=flag; }
            bool isMultiTexSupported() const { return _isMultiTexSupported; }

            void glSecondaryColor3ubv(const GLubyte* coord) const;
            void glSecondaryColor3fv(const GLfloat* coord) const;

            void glFogCoordfv(const GLfloat* coord) const;

            void glMultiTexCoord1f(GLenum target,GLfloat coord) const;
            void glMultiTexCoord2fv(GLenum target,const GLfloat* coord) const;
            void glMultiTexCoord3fv(GLenum target,const GLfloat* coord) const;
            void glMultiTexCoord4fv(GLenum target,const GLfloat* coord) const;

            void glVertexAttrib1s(unsigned int index, GLshort s) const;
            void glVertexAttrib1f(unsigned int index, GLfloat f) const;
            void glVertexAttrib2fv(unsigned int index, const GLfloat * v) const;
            void glVertexAttrib3fv(unsigned int index, const GLfloat * v) const;
            void glVertexAttrib4fv(unsigned int index, const GLfloat * v) const;
            void glVertexAttrib4ubv(unsigned int index, const GLubyte * v) const;
            void glVertexAttrib4Nubv(unsigned int index, const GLubyte * v) const;

        protected:

            typedef void (APIENTRY * FogCoordProc) (const GLfloat* coord);

            typedef void (APIENTRY * VertexAttrib1sProc) (unsigned int index, GLshort s);
            typedef void (APIENTRY * VertexAttrib1fProc) (unsigned int index, GLfloat f);
            typedef void (APIENTRY * VertexAttribfvProc) (unsigned int index, const GLfloat * v);
            typedef void (APIENTRY * VertexAttribubvProc) (unsigned int index, const GLubyte * v);

            typedef void (APIENTRY * SecondaryColor3ubvProc) (const GLubyte* coord);
            typedef void (APIENTRY * SecondaryColor3fvProc) (const GLfloat* coord);

            typedef void (APIENTRY * MultiTexCoord1fProc) (GLenum target,GLfloat coord);
            typedef void (APIENTRY * MultiTexCoordfvProc) (GLenum target,const GLfloat* coord);

            ~Extensions() {}

            bool _isVertexProgramSupported;
            bool _isSecondaryColorSupported;
            bool _isFogCoordSupported;
            bool _isMultiTexSupported;
 
            FogCoordProc _glFogCoordfv;

            SecondaryColor3ubvProc _glSecondaryColor3ubv;
            SecondaryColor3fvProc _glSecondaryColor3fv;

            VertexAttrib1sProc _glVertexAttrib1s;
            VertexAttrib1fProc _glVertexAttrib1f;
            VertexAttribfvProc _glVertexAttrib2fv;
            VertexAttribfvProc _glVertexAttrib3fv;
            VertexAttribfvProc _glVertexAttrib4fv;
            VertexAttribubvProc _glVertexAttrib4ubv;
            VertexAttribubvProc _glVertexAttrib4Nubv;

            MultiTexCoord1fProc _glMultiTexCoord1f;
            MultiTexCoordfvProc _glMultiTexCoord2fv;
            MultiTexCoordfvProc _glMultiTexCoord3fv;
            MultiTexCoordfvProc _glMultiTexCoord4fv;
        };

        /** Function to call to get the extension of a specified context.
        * If the Exentsion object for that context has not yet been created then 
        * and the 'createIfNotInitalized' flag been set to false then returns NULL.
        * If 'createIfNotInitalized' is true then the Extensions object is 
        * automatically created.  However, in this case the extension object 
        * only be created with the graphics context associated with ContextID..*/
        static Extensions* getExtensions(unsigned int contextID,bool createIfNotInitalized);

        /** setExtensions allows users to override the extensions across graphics contexts.
        * typically used when you have different extensions supported across graphics pipes
        * but need to ensure that they all use the same low common denominator extensions.*/
        static void setExtensions(unsigned int contextID,Extensions* extensions);


    protected:

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

        virtual ~Geometry();
       
        PrimitiveSetList                _primitives;
        
#ifdef COMPILE_POSSIBLE_NEW_ARRAY_METHODS
        AttributeList                   _attributeList;
#endif
        ref_ptr<Vec3Array>                _vertexArray;
        ref_ptr<IndexArray>                _vertexIndices;

        mutable AttributeBinding        _normalBinding;
        ref_ptr<Vec3Array>                _normalArray;
        ref_ptr<IndexArray>                _normalIndices;
        
        mutable AttributeBinding        _colorBinding;
        ref_ptr<Array>                    _colorArray;
        ref_ptr<IndexArray>                _colorIndices;
        
        mutable AttributeBinding        _secondaryColorBinding;
        ref_ptr<Array>                    _secondaryColorArray;
        ref_ptr<IndexArray>                _secondaryColorIndices;

        mutable AttributeBinding        _fogCoordBinding;
        ref_ptr<Array>                    _fogCoordArray;
        ref_ptr<IndexArray>                _fogCoordIndices;
        
        TexCoordArrayList                _texCoordList;
        
        VertexAttribArrayList            _vertexAttribList;
        mutable VertexAttribBindingList    _vertexAttribBindingList; 

        mutable bool                     _fastPathComputed;
        mutable bool                    _fastPath;
};


}

#endif