399 lines
17 KiB
C++
399 lines
17 KiB
C++
/* -*-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>
|
|
|
|
namespace osg {
|
|
|
|
class OSG_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; }
|
|
|
|
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);
|
|
Array* getNormalArray() { return _normalArray.get(); }
|
|
const Array* getNormalArray() const { return _normalArray.get(); }
|
|
|
|
|
|
|
|
void setColorArray(Array* array);
|
|
Array* getColorArray() { return _colorArray.get(); }
|
|
const Array* getColorArray() const { return _colorArray.get(); }
|
|
|
|
|
|
|
|
void setSecondaryColorArray(Array* array);
|
|
Array* getSecondaryColorArray() { return _secondaryColorArray.get(); }
|
|
const Array* getSecondaryColorArray() const { return _secondaryColorArray.get(); }
|
|
|
|
|
|
void setFogCoordArray(Array* array);
|
|
Array* getFogCoordArray() { return _fogCoordArray.get(); }
|
|
const Array* getFogCoordArray() const { return _fogCoordArray.get(); }
|
|
|
|
|
|
void setTexCoordArray(unsigned int unit,Array*);
|
|
Array* getTexCoordArray(unsigned int unit);
|
|
const Array* getTexCoordArray(unsigned int unit) const;
|
|
|
|
unsigned int getNumTexCoordArrays() const { return static_cast<unsigned int>(_texCoordList.size()); }
|
|
ArrayList& getTexCoordArrayList() { return _texCoordList; }
|
|
const ArrayList& getTexCoordArrayList() const { return _texCoordList; }
|
|
|
|
|
|
|
|
void setVertexAttribArray(unsigned int index,Array* array);
|
|
Array *getVertexAttribArray(unsigned int index);
|
|
const Array *getVertexAttribArray(unsigned int index) const;
|
|
|
|
|
|
unsigned int getNumVertexAttribArrays() const { return static_cast<unsigned int>(_vertexAttribList.size()); }
|
|
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(); }
|
|
|
|
/** 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=geometry->getPrimitiveSetIndex(primitive))!=geometry.getNumPrimitiveSet())
|
|
*/
|
|
unsigned int getPrimitiveSetIndex(const PrimitiveSet* primitiveset) const;
|
|
|
|
|
|
/** return true if any arrays are shared.*/
|
|
bool containsSharedArrays() const;
|
|
|
|
/** duplicate any shared arrays.*/
|
|
void duplicateSharedArrays();
|
|
|
|
|
|
/** When set to true, ignore the setUseDisplayList() settings, and hints to the drawImplementation
|
|
method to use OpenGL vertex buffer objects for rendering.*/
|
|
virtual void setUseVertexBufferObjects(bool flag);
|
|
|
|
/** Force a recompile on next draw() of any OpenGL display list associated with this geoset.*/
|
|
virtual void dirtyDisplayList();
|
|
|
|
|
|
/** Resize any per context GLObject buffers to specified size. */
|
|
virtual void resizeGLObjectBuffers(unsigned int maxSize);
|
|
|
|
/** If State is non-zero, this function releases OpenGL objects for
|
|
* the specified graphics context. Otherwise, releases OpenGL objects
|
|
* for all graphics contexts. */
|
|
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();
|
|
|
|
|
|
/** Return the estimated size of GLObjects (display lists/vertex buffer objects) that are associated with this drawable.
|
|
* This size is used a hint for reuse of deleted display lists/vertex buffer objects. */
|
|
virtual unsigned int getGLObjectSizeHint() const;
|
|
|
|
/** Immediately compile this \c Drawable into an OpenGL Display List/VertexBufferObjects.
|
|
* @note Operation is ignored if \c _useDisplayList is \c false or VertexBufferObjects are not used.
|
|
*/
|
|
virtual void compileGLObjects(RenderInfo& renderInfo) const;
|
|
|
|
/** 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(RenderInfo& renderInfo) const;
|
|
|
|
/** Return true, osg::Geometry does support accept(Drawable::AttributeFunctor&). */
|
|
virtual bool supports(const Drawable::AttributeFunctor&) const { return true; }
|
|
|
|
/** Accept an Drawable::AttributeFunctor and call its methods to tell it about the internal attributes that this Drawable has. */
|
|
virtual void accept(Drawable::AttributeFunctor& af);
|
|
|
|
/** Return true, osg::Geometry does support accept(Drawable::ConstAttributeFunctor&). */
|
|
virtual bool supports(const Drawable::ConstAttributeFunctor&) const { return true; }
|
|
|
|
/** Accept a Drawable::ConstAttributeFunctor and call its methods to tell it about the internal attributes that this Drawable has. */
|
|
virtual void accept(Drawable::ConstAttributeFunctor& af) const;
|
|
|
|
/** Return true, osg::Geometry does support accept(PrimitiveFunctor&). */
|
|
virtual bool supports(const PrimitiveFunctor&) const { return true; }
|
|
|
|
/** Accept a PrimitiveFunctor and call its methods to tell it about the internal primitives that this Drawable has. */
|
|
virtual void accept(PrimitiveFunctor& pf) const;
|
|
|
|
/** Return true, osg::Geometry does support accept(PrimitiveIndexFunctor&). */
|
|
virtual bool supports(const PrimitiveIndexFunctor&) const { return true; }
|
|
|
|
/** Accept a PrimitiveFunctor and call its methods to tell it about the internal primitives that this Drawable has. */
|
|
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:
|
|
|
|
|
|
/** Return true if the deprecated use array indicies or BIND_PER_PRIMITIVE binding has been assigned to arrays.*/
|
|
bool containsDeprecatedData() const { return _containsDeprecatedData; }
|
|
|
|
/** fallback for deprecated functionality. Return true if the Geometry contains any array indices or BIND_PER_PRIMITIVE arrays. */
|
|
bool checkForDeprecatedData();
|
|
|
|
/** fallback for deprecated functionality. Removes any array indices and BIND_PER_PRIMITIVE arrays.*/
|
|
void fixDeprecatedData();
|
|
|
|
/** Same values as Array::Binding.*/
|
|
enum AttributeBinding
|
|
{
|
|
BIND_OFF=0,
|
|
BIND_OVERALL=1,
|
|
BIND_PER_PRIMITIVE_SET=2,
|
|
#if defined(OSG_USE_DEPRECATED_GEOMETRY_METHODS)
|
|
BIND_PER_PRIMITIVE=3, /// no longer supported
|
|
#endif
|
|
BIND_PER_VERTEX=4
|
|
};
|
|
|
|
/** deprecated, use array->setBinding(..). */
|
|
void setNormalBinding(AttributeBinding ab);
|
|
AttributeBinding getNormalBinding() const;
|
|
|
|
/** deprecated, use array->setBinding(..). */
|
|
void setColorBinding(AttributeBinding ab);
|
|
AttributeBinding getColorBinding() const;
|
|
|
|
/** deprecated, use array->setBinding(..). */
|
|
void setSecondaryColorBinding(AttributeBinding ab);
|
|
AttributeBinding getSecondaryColorBinding() const;
|
|
|
|
/** deprecated, use array->setBinding(..). */
|
|
void setFogCoordBinding(AttributeBinding ab);
|
|
AttributeBinding getFogCoordBinding() const;
|
|
|
|
/** deprecated, use array->setBinding(..). */
|
|
void setVertexAttribBinding(unsigned int index,AttributeBinding ab);
|
|
AttributeBinding getVertexAttribBinding(unsigned int index) const;
|
|
|
|
/** deprecated, use array->setNormalize(..). */
|
|
void setVertexAttribNormalize(unsigned int index,GLboolean norm);
|
|
GLboolean getVertexAttribNormalize(unsigned int index) const;
|
|
|
|
#if defined(OSG_USE_DEPRECATED_GEOMETRY_METHODS)
|
|
/** no longer supported.*/
|
|
inline void setVertexIndices(IndexArray* array);
|
|
inline const IndexArray* getVertexIndices() const;
|
|
|
|
/** no longer supported.*/
|
|
inline void setNormalIndices(IndexArray* array);
|
|
inline const IndexArray* getNormalIndices() const;
|
|
|
|
/** no longer supported.*/
|
|
inline void setColorIndices(IndexArray* array);
|
|
inline const IndexArray* getColorIndices() const;
|
|
|
|
/** no longer supported.*/
|
|
inline void setSecondaryColorIndices(IndexArray* array);
|
|
inline const IndexArray* getSecondaryColorIndices() const;
|
|
|
|
/** no longer supported.*/
|
|
inline void setFogCoordIndices(IndexArray* array);
|
|
inline const IndexArray* getFogCoordIndices() const;
|
|
|
|
/** no longer supported.*/
|
|
inline void setTexCoordIndices(unsigned int unit,IndexArray*);
|
|
inline const IndexArray* getTexCoordIndices(unsigned int unit) const;
|
|
|
|
/** no longer supported.*/
|
|
inline void setVertexAttribIndices(unsigned int index,IndexArray* array);
|
|
inline const IndexArray* getVertexAttribIndices(unsigned int index) const;
|
|
#endif
|
|
};
|
|
|
|
/** Convenience function to be used for creating quad geometry with texture coords.
|
|
* Tex coords go from left bottom (l,b) to right top (r,t).
|
|
*/
|
|
extern OSG_EXPORT Geometry* createTexturedQuadGeometry(const Vec3& corner,const Vec3& widthVec,const Vec3& heightVec, float l, float b, float r, float t);
|
|
|
|
/** Convenience function to be used for creating quad geometry with texture coords.
|
|
* Tex coords go from bottom left (0,0) to top right (s,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);
|
|
}
|
|
|
|
|
|
#if defined(OSG_USE_DEPRECATED_GEOMETRY_METHODS)
|
|
|
|
#include <osg/Notify>
|
|
|
|
inline void Geometry::setVertexIndices(IndexArray* array)
|
|
{
|
|
if (_vertexArray.valid()) { _vertexArray->setUserData(array); if (array) _containsDeprecatedData = true; }
|
|
else { OSG_WARN<<"Geometry::setVertexIndicies(..) function failed as there is no vertex array to associate inidices with."<<std::endl; }
|
|
}
|
|
|
|
inline const IndexArray* Geometry::getVertexIndices() const
|
|
{
|
|
if (_vertexArray.valid()) return dynamic_cast<IndexArray*>(_vertexArray->getUserData());
|
|
else return 0;
|
|
}
|
|
|
|
inline void Geometry::setNormalIndices(IndexArray* array)
|
|
{
|
|
if (_normalArray.valid()) { _normalArray->setUserData(array); if (array) _containsDeprecatedData = true; }
|
|
else { OSG_WARN<<"Geometry::setNormalIndicies(..) function failed as there is no normal array to associate inidices with."<<std::endl; }
|
|
}
|
|
inline const IndexArray* Geometry::getNormalIndices() const
|
|
{
|
|
if (_normalArray.valid()) return dynamic_cast<IndexArray*>(_normalArray->getUserData());
|
|
else return 0;
|
|
}
|
|
|
|
inline void Geometry::setColorIndices(IndexArray* array)
|
|
{
|
|
if (_colorArray.valid()) { _colorArray->setUserData(array); if (array) _containsDeprecatedData = true; }
|
|
else { OSG_WARN<<"Geometry::setColorIndicies(..) function failed as there is no color array to associate inidices with."<<std::endl; }
|
|
}
|
|
inline const IndexArray* Geometry::getColorIndices() const
|
|
{
|
|
if (_colorArray.valid()) return dynamic_cast<IndexArray*>(_colorArray->getUserData());
|
|
else return 0;
|
|
}
|
|
|
|
inline void Geometry::setSecondaryColorIndices(IndexArray* array)
|
|
{
|
|
if (_secondaryColorArray.valid()) { _secondaryColorArray->setUserData(array); if (array) _containsDeprecatedData = true; }
|
|
else { OSG_WARN<<"Geometry::setSecondaryColorArray(..) function failed as there is no secondary color array to associate inidices with."<<std::endl; }
|
|
}
|
|
inline const IndexArray* Geometry::getSecondaryColorIndices() const
|
|
{
|
|
if (_secondaryColorArray.valid()) return dynamic_cast<IndexArray*>(_secondaryColorArray->getUserData());
|
|
else return 0;
|
|
}
|
|
|
|
inline void Geometry::setFogCoordIndices(IndexArray* array)
|
|
{
|
|
if (_fogCoordArray.valid()) { _fogCoordArray->setUserData(array); if (array) _containsDeprecatedData = true; }
|
|
else { OSG_WARN<<"Geometry::setFogCoordIndicies(..) function failed as there is no fog coord array to associate inidices with."<<std::endl; }
|
|
}
|
|
inline const IndexArray* Geometry::getFogCoordIndices() const
|
|
{
|
|
if (_fogCoordArray.valid()) return dynamic_cast<IndexArray*>(_fogCoordArray->getUserData());
|
|
else return 0;
|
|
}
|
|
|
|
inline void Geometry::setTexCoordIndices(unsigned int unit,IndexArray* array)
|
|
{
|
|
if (unit<_texCoordList.size() && _texCoordList[unit].valid()) { _texCoordList[unit]->setUserData(array); if (array) _containsDeprecatedData = true; }
|
|
else { OSG_WARN<<"Geometry::setTexCoordIndices(..) function failed as there is no texcoord array to associate inidices with."<<std::endl; }
|
|
}
|
|
inline const IndexArray* Geometry::getTexCoordIndices(unsigned int unit) const
|
|
{
|
|
if (unit<_texCoordList.size() && _texCoordList[unit].valid()) return dynamic_cast<IndexArray*>(_texCoordList[unit]->getUserData());
|
|
else return 0;
|
|
}
|
|
|
|
inline void Geometry::setVertexAttribIndices(unsigned int index,IndexArray* array)
|
|
{
|
|
if (index<_vertexAttribList.size() && _vertexAttribList[index].valid()) { _vertexAttribList[index]->setUserData(array); if (array) _containsDeprecatedData = true; }
|
|
else { OSG_WARN<<"Geometry::setVertexAttribIndices(..) function failed as there is no vertex attrib array to associate inidices with."<<std::endl; }
|
|
}
|
|
inline const IndexArray* Geometry::getVertexAttribIndices(unsigned int index) const
|
|
{
|
|
if (index<_vertexAttribList.size() && _vertexAttribList[index].valid()) return dynamic_cast<IndexArray*>(_vertexAttribList[index]->getUserData());
|
|
else return 0;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|