/* -*-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 #include #include #include #include #include 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(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(Array* array) { _vertexArray = array; dirtyDisplayList(); dirtyBound(); } Array* getVertexArray() { return _vertexArray.get(); } const Array* 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, ref_ptr > 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; ref_ptr _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 AttributeList; void setAttributeList(AttributeList& al) { _attributeList = al; } AttributeList& getAttributeList() { return _attributeList; } const AttributeList& getAttributeList() const { return _attributeList; } #endif typedef std::pair< ref_ptr, ref_ptr > 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 > 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 _vertexArray; ref_ptr _vertexIndices; mutable AttributeBinding _normalBinding; ref_ptr _normalArray; ref_ptr _normalIndices; mutable AttributeBinding _colorBinding; ref_ptr _colorArray; ref_ptr _colorIndices; mutable AttributeBinding _secondaryColorBinding; ref_ptr _secondaryColorArray; ref_ptr _secondaryColorIndices; mutable AttributeBinding _fogCoordBinding; ref_ptr _fogCoordArray; ref_ptr _fogCoordIndices; TexCoordArrayList _texCoordList; VertexAttribArrayList _vertexAttribList; mutable VertexAttribBindingList _vertexAttribBindingList; mutable bool _fastPathComputed; mutable bool _fastPath; }; /** Convenience function to be used for creating quad geometry with texture coords. * Tex coords go from bottom left (0,0) to top right (1,1).*/ extern SG_EXPORT Geometry* createTexturedQuadGeometry(const Vec3& corner,const Vec3& widthVec,const Vec3& heightVec); } #endif