Geometry.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_GEOMETRY
#define OSG_GEOMETRY 1

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

// leave defined for OpenSceneGraph-3.2 release, post 3.2 associated methods will be only be available in deprecated_osg::Geometry
#define OSG_DEPRECATED_GEOMETRY_BINDING 1

namespace osg {


class OSG_EXPORT Geometry : public Drawable
{
    public:

        Geometry();

        Geometry(const Geometry& geometry,const CopyOp& copyop=CopyOp::SHALLOW_COPY);

        META_Node(osg, Geometry);

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

        bool empty() const;

        typedef std::vector< osg::ref_ptr<osg::Array> >  ArrayList;

        void setVertexArray(Array* array);
        Array* getVertexArray() { return _vertexArray.get(); }
        const Array* getVertexArray() const  { return _vertexArray.get(); }


        void setNormalArray(Array* array) { setNormalArray(array, osg::Array::BIND_UNDEFINED); }
        void setNormalArray(Array* array, osg::Array::Binding binding);
        Array* getNormalArray() { return _normalArray.get(); }
        const Array* getNormalArray() const { return _normalArray.get(); }



        void setColorArray(Array* array) { setColorArray(array, osg::Array::BIND_UNDEFINED); }
        void setColorArray(Array* array, osg::Array::Binding binding);
        Array* getColorArray() { return _colorArray.get(); }
        const Array* getColorArray() const { return _colorArray.get(); }



        void setSecondaryColorArray(Array* array) { setSecondaryColorArray(array, osg::Array::BIND_UNDEFINED); }
        void setSecondaryColorArray(Array* array, osg::Array::Binding binding);
        Array* getSecondaryColorArray() { return _secondaryColorArray.get(); }
        const Array* getSecondaryColorArray() const  { return _secondaryColorArray.get(); }


        void setFogCoordArray(Array* array) { setFogCoordArray(array, osg::Array::BIND_UNDEFINED); }
        void setFogCoordArray(Array* array, osg::Array::Binding binding);
        Array* getFogCoordArray() { return _fogCoordArray.get(); }
        const Array* getFogCoordArray() const { return _fogCoordArray.get(); }


        void setTexCoordArray(unsigned int unit, Array* array) { setTexCoordArray(unit, array, osg::Array::BIND_UNDEFINED); }
        void setTexCoordArray(unsigned int unit, Array* array, osg::Array::Binding binding);
        Array* getTexCoordArray(unsigned int unit);
        const Array* getTexCoordArray(unsigned int unit) const;

        unsigned int getNumTexCoordArrays() const {  return static_cast<unsigned int>(_texCoordList.size()); }
        void setTexCoordArrayList(const ArrayList& arrrayList);
        ArrayList& getTexCoordArrayList() { return _texCoordList; }
        const ArrayList& getTexCoordArrayList() const { return _texCoordList; }

        void setVertexAttribArray(unsigned int index, Array* array) { setVertexAttribArray(index, array, osg::Array::BIND_UNDEFINED); }
        void setVertexAttribArray(unsigned int index, Array* array, osg::Array::Binding binding);
        Array *getVertexAttribArray(unsigned int index);
        const Array *getVertexAttribArray(unsigned int index) const;


        unsigned int getNumVertexAttribArrays() const { return static_cast<unsigned int>(_vertexAttribList.size()); }
        void setVertexAttribArrayList(const ArrayList& arrayList);
        ArrayList& getVertexAttribArrayList() { return _vertexAttribList; }
        const ArrayList& getVertexAttribArrayList() const { return _vertexAttribList; }



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

        void setPrimitiveSetList(const PrimitiveSetList& primitives);

        PrimitiveSetList& getPrimitiveSetList() { return _primitives; }
        const PrimitiveSetList& getPrimitiveSetList() const { return _primitives; }

        unsigned int getNumPrimitiveSets() const { return static_cast<unsigned int>(_primitives.size()); }
        PrimitiveSet* getPrimitiveSet(unsigned int pos) { return _primitives[pos].get(); }
        const PrimitiveSet* getPrimitiveSet(unsigned int pos) const { return _primitives[pos].get(); }

        bool addPrimitiveSet(PrimitiveSet* primitiveset);

        bool setPrimitiveSet(unsigned int i,PrimitiveSet* primitiveset);

        bool insertPrimitiveSet(unsigned int i,PrimitiveSet* primitiveset);

        bool removePrimitiveSet(unsigned int i,unsigned int numElementsToRemove=1);

        unsigned int getPrimitiveSetIndex(const PrimitiveSet* primitiveset) const;


        bool containsSharedArrays() const;

        void duplicateSharedArrays();


        virtual void setUseVertexBufferObjects(bool flag);

        virtual void dirtyDisplayList();


        virtual void resizeGLObjectBuffers(unsigned int maxSize);

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

        bool getArrayList(ArrayList& arrayList) const;

        typedef std::vector<osg::DrawElements*>  DrawElementsList;
        bool getDrawElementsList(DrawElementsList& drawElementsList) const;

        osg::VertexBufferObject* getOrCreateVertexBufferObject();
        osg::ElementBufferObject* getOrCreateElementBufferObject();


        virtual unsigned int getGLObjectSizeHint() const;

        virtual void compileGLObjects(RenderInfo& renderInfo) const;

        virtual void drawImplementation(RenderInfo& renderInfo) const;

        void drawVertexArraysImplementation(RenderInfo& renderInfo) const;

        void drawPrimitivesImplementation(RenderInfo& renderInfo) const;

        virtual bool supports(const Drawable::AttributeFunctor&) const { return true; }

        virtual void accept(Drawable::AttributeFunctor& af);

        virtual bool supports(const Drawable::ConstAttributeFunctor&) const { return true; }

        virtual void accept(Drawable::ConstAttributeFunctor& af) const;

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

        virtual void accept(PrimitiveFunctor& pf) const;

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

        virtual void accept(PrimitiveIndexFunctor& pf) const;


    protected:

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

        virtual ~Geometry();


        void addVertexBufferObjectIfRequired(osg::Array* array);
        void addElementBufferObjectIfRequired(osg::PrimitiveSet* primitiveSet);


        PrimitiveSetList                _primitives;
        osg::ref_ptr<Array>             _vertexArray;
        osg::ref_ptr<Array>             _normalArray;
        osg::ref_ptr<Array>             _colorArray;
        osg::ref_ptr<Array>             _secondaryColorArray;
        osg::ref_ptr<Array>             _fogCoordArray;
        ArrayList                       _texCoordList;
        ArrayList                       _vertexAttribList;

        bool                            _containsDeprecatedData;

    public:


        bool containsDeprecatedData() const { return  _containsDeprecatedData; }

        bool checkForDeprecatedData();

        void fixDeprecatedData();

#if defined(OSG_DEPRECATED_GEOMETRY_BINDING)

        enum AttributeBinding
        {
            BIND_OFF=0,
            BIND_OVERALL=1,
            BIND_PER_PRIMITIVE_SET=2,
            BIND_PER_VERTEX=4
        };

        void setNormalBinding(AttributeBinding ab);
        void setColorBinding(AttributeBinding ab);
        void setSecondaryColorBinding(AttributeBinding ab);
        void setFogCoordBinding(AttributeBinding ab);
        void setVertexAttribBinding(unsigned int index,AttributeBinding ab);

        AttributeBinding getNormalBinding() const;
        AttributeBinding getColorBinding() const;
        AttributeBinding getSecondaryColorBinding() const;
        AttributeBinding getFogCoordBinding() const;
        AttributeBinding getVertexAttribBinding(unsigned int index) const;

        void setVertexAttribNormalize(unsigned int index,GLboolean norm);

        GLboolean getVertexAttribNormalize(unsigned int index) const;
#endif
};

extern OSG_EXPORT Geometry* createTexturedQuadGeometry(const Vec3& corner,const Vec3& widthVec,const Vec3& heightVec, float l, float b, float r, float t);

inline Geometry* createTexturedQuadGeometry(const Vec3& corner,const Vec3& widthVec,const Vec3& heightVec, float s=1.0f, float t=1.0f)
{
    return createTexturedQuadGeometry(corner,widthVec,heightVec, 0.0f, 0.0f, s, t);
}

} // namespace osg



namespace deprecated_osg {

class OSG_EXPORT Geometry : public osg::Geometry
{
    public:
        Geometry() : osg::Geometry() {}
        Geometry(const Geometry& geometry,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY) : osg::Geometry(geometry, copyop) {}

        enum AttributeBinding
        {
            BIND_OFF=0,
            BIND_OVERALL=1,
            BIND_PER_PRIMITIVE_SET=2,
            BIND_PER_PRIMITIVE=3,
            BIND_PER_VERTEX=4
        };

        void setNormalBinding(AttributeBinding ab);
        AttributeBinding getNormalBinding() const;

        void setColorBinding(AttributeBinding ab);
        AttributeBinding getColorBinding() const;

        void setSecondaryColorBinding(AttributeBinding ab);
        AttributeBinding getSecondaryColorBinding() const;

        void setFogCoordBinding(AttributeBinding ab);
        AttributeBinding getFogCoordBinding() const;

        void setVertexAttribBinding(unsigned int index,AttributeBinding ab);
        AttributeBinding getVertexAttribBinding(unsigned int index) const;

        void setVertexAttribNormalize(unsigned int index,GLboolean norm);
        GLboolean getVertexAttribNormalize(unsigned int index) const;

        void setVertexIndices(osg::IndexArray* array);
        const osg::IndexArray* getVertexIndices() const;

        void setNormalIndices(osg::IndexArray* array);
        const osg::IndexArray* getNormalIndices() const;

        void setColorIndices(osg::IndexArray* array);
        const osg::IndexArray* getColorIndices() const;

        void setSecondaryColorIndices(osg::IndexArray* array);
        const osg::IndexArray* getSecondaryColorIndices() const;

        void setFogCoordIndices(osg::IndexArray* array);
        const osg::IndexArray* getFogCoordIndices() const;

        void setTexCoordIndices(unsigned int unit,osg::IndexArray* array);
        const osg::IndexArray* getTexCoordIndices(unsigned int unit) const;

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

};

} // namespace deprecated_osg

#endif