Hi Robert -- A recent change to add the new geometry shader primitive
types has broken the build on Windows. On Windows, those types are
declared in the header GL2Extensions, but the PrimitiveSet header (which
uses those types) fails to include that header, causing compile errors.
Attached is a version of PrimitiveSet that includes GL2Extensions.
--
Paul Martz
Skew Matrix Software LLC
_http://www.skew-matrix.com_ <http://www.skew-matrix.com/>
+1 303 859 9466
/* -*-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_PRIMITIVESET
#define OSG_PRIMITIVESET 1
#include <osg/GL>
#include <osg/Object>
#include <osg/buffered_value>
#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Vec4>
#include <osg/Vec2d>
#include <osg/Vec3d>
#include <osg/Vec4d>
#include <osg/MixinVector>
#include <osg/GL2Extensions>
#include <osg/BufferObject>
#include <vector>
namespace osg {
typedef MixinVector<GLsizei> VectorGLsizei;
typedef MixinVector<GLubyte> VectorGLubyte;
typedef MixinVector<GLushort> VectorGLushort;
typedef MixinVector<GLuint> VectorGLuint;
class State;
/** A \c PrimitiveFunctor is used (in conjunction with
* <tt>osg::Drawable::accept (PrimitiveFunctor&)</tt>) to get access to the
* primitives that compose the things drawn by OSG.
* <p>If \c osg::Drawable::accept() is called with a \c PrimitiveFunctor
* parameter, the \c Drawable will "pretend" it is drawing itself, but instead
* of calling real OpenGL functions, it will call <tt>PrimitiveFunctor</tt>'s
* member functions that "mimic" the OpenGL calls.
* <p>Concrete subclasses of \c PrimitiveFunctor must implement these methods
* so that they performs whatever they want.
*/
class PrimitiveFunctor
{
public:
virtual ~PrimitiveFunctor() {}
/** Sets the array of vertices used to describe the primitives. Somehow
* mimics the OpenGL \c glVertexPointer() function.
*/
virtual void setVertexArray(unsigned int count,const Vec2* vertices) = 0;
/** Sets the array of vertices used to describe the primitives. Somehow
* mimics the OpenGL \c glVertexPointer() function.
*/
virtual void setVertexArray(unsigned int count,const Vec3* vertices) = 0;
/** Sets the array of vertices used to describe the primitives. Somehow
* mimics the OpenGL \c glVertexPointer() function.
*/
virtual void setVertexArray(unsigned int count,const Vec4* vertices) = 0;
/** Sets the array of vertices used to describe the primitives. Somehow
* mimics the OpenGL \c glVertexPointer() function.
*/
virtual void setVertexArray(unsigned int count,const Vec2d* vertices) = 0;
/** Sets the array of vertices used to describe the primitives. Somehow
* mimics the OpenGL \c glVertexPointer() function.
*/
virtual void setVertexArray(unsigned int count,const Vec3d* vertices) = 0;
/** Sets the array of vertices used to describe the primitives. Somehow
* mimics the OpenGL \c glVertexPointer() function.
*/
virtual void setVertexArray(unsigned int count,const Vec4d* vertices) = 0;
/// Mimics the OpenGL \c glDrawArrays() function.
virtual void drawArrays(GLenum mode,GLint first,GLsizei count) = 0;
/// Mimics the OpenGL \c glDrawElements() function.
virtual void drawElements(GLenum mode,GLsizei count,const GLubyte* indices)
= 0;
/// Mimics the OpenGL \c glDrawElements() function.
virtual void drawElements(GLenum mode,GLsizei count,const GLushort*
indices) = 0;
/// Mimics the OpenGL \c glDrawElements() function.
virtual void drawElements(GLenum mode,GLsizei count,const GLuint* indices)
= 0;
/// Mimics the OpenGL \c glBegin() function.
virtual void begin(GLenum mode) = 0;
/// Mimics the OpenGL \c glVertex() "family of functions".
virtual void vertex(const Vec2& vert) = 0;
/// Mimics the OpenGL \c glVertex() "family of functions".
virtual void vertex(const Vec3& vert) = 0;
/// Mimics the OpenGL \c glVertex() "family of functions".
virtual void vertex(const Vec4& vert) = 0;
/// Mimics the OpenGL \c glVertex() "family of functions".
virtual void vertex(float x,float y) = 0;
/// Mimics the OpenGL \c glVertex() "family of functions".
virtual void vertex(float x,float y,float z) = 0;
/// Mimics the OpenGL \c glVertex() "family of functions".
virtual void vertex(float x,float y,float z,float w) = 0;
/// Mimics the OpenGL \c glEnd() function.
virtual void end() = 0;
};
class PrimitiveIndexFunctor
{
public:
virtual ~PrimitiveIndexFunctor() {}
virtual void setVertexArray(unsigned int count,const Vec2* vertices) = 0;
virtual void setVertexArray(unsigned int count,const Vec3* vertices) = 0;
virtual void setVertexArray(unsigned int count,const Vec4* vertices) = 0;
virtual void setVertexArray(unsigned int count,const Vec2d* vertices) = 0;
virtual void setVertexArray(unsigned int count,const Vec3d* vertices) = 0;
virtual void setVertexArray(unsigned int count,const Vec4d* vertices) = 0;
virtual void drawArrays(GLenum mode,GLint first,GLsizei count) = 0;
virtual void drawElements(GLenum mode,GLsizei count,const GLubyte* indices)
= 0;
virtual void drawElements(GLenum mode,GLsizei count,const GLushort*
indices) = 0;
virtual void drawElements(GLenum mode,GLsizei count,const GLuint* indices)
= 0;
virtual void begin(GLenum mode) = 0;
virtual void vertex(unsigned int pos) = 0;
virtual void end() = 0;
};
class DrawElements;
class OSG_EXPORT PrimitiveSet : public BufferData
{
public:
enum Type
{
PrimitiveType,
DrawArraysPrimitiveType,
DrawArrayLengthsPrimitiveType,
DrawElementsUBytePrimitiveType,
DrawElementsUShortPrimitiveType,
DrawElementsUIntPrimitiveType
};
enum Mode
{
POINTS = GL_POINTS,
LINES = GL_LINES,
LINE_STRIP = GL_LINE_STRIP,
LINE_LOOP = GL_LINE_LOOP,
TRIANGLES = GL_TRIANGLES,
TRIANGLE_STRIP = GL_TRIANGLE_STRIP,
TRIANGLE_FAN = GL_TRIANGLE_FAN,
QUADS = GL_QUADS,
QUAD_STRIP = GL_QUAD_STRIP,
POLYGON = GL_POLYGON,
LINES_ADJACENCY = GL_LINES_ADJACENCY_EXT,
LINE_STRIP_ADJACENCY = GL_LINE_STRIP_ADJACENCY_EXT,
TRIANGLES_ADJACENCY = GL_TRIANGLES_ADJACENCY_EXT,
TRIANGLE_STRIP_ADJECENCY = GL_TRIANGLE_STRIP_ADJACENCY_EXT
};
PrimitiveSet(Type primType=PrimitiveType,GLenum mode=0, int
numInstances=0):
_primitiveType(primType),
_numInstances(numInstances),
_mode(mode),
_rangeModifiedCount(0) {}
PrimitiveSet(const PrimitiveSet& prim,const CopyOp&
copyop=CopyOp::SHALLOW_COPY):
BufferData(prim,copyop),
_primitiveType(prim._primitiveType),
_numInstances(prim._numInstances),
_mode(prim._mode),
_rangeModifiedCount(0) {}
virtual bool isSameKindAs(const Object* obj) const { return
dynamic_cast<const PrimitiveSet*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "PrimitiveSet"; }
Type getType() const { return _primitiveType; }
virtual const GLvoid* getDataPointer() const { return 0; }
virtual unsigned int getTotalDataSize() const { return 0; }
virtual bool supportsBufferObject() const { return false; }
virtual DrawElements* getDrawElements() { return 0; }
virtual const DrawElements* getDrawElements() const { return 0; }
void setNumInstances(int n) { _numInstances = n; }
int getNumInstances() const { return _numInstances; }
void setMode(GLenum mode) { _mode = mode; }
GLenum getMode() const { return _mode; }
virtual void draw(State& state, bool useVertexBufferObjects) const = 0;
virtual void accept(PrimitiveFunctor& functor) const = 0;
virtual void accept(PrimitiveIndexFunctor& functor) const = 0;
virtual unsigned int index(unsigned int pos) const = 0;
virtual unsigned int getNumIndices() const = 0;
virtual void offsetIndices(int offset) = 0;
virtual unsigned int getNumPrimitives() const;
virtual void computeRange() const {}
protected:
virtual ~PrimitiveSet() {}
Type _primitiveType;
int _numInstances;
GLenum _mode;
mutable unsigned int _rangeModifiedCount;
};
class OSG_EXPORT DrawArrays : public PrimitiveSet
{
public:
DrawArrays(GLenum mode=0):
PrimitiveSet(DrawArraysPrimitiveType,mode),
_first(0),
_count(0) {}
DrawArrays(GLenum mode, GLint first, GLsizei count, int numInstances=0):
PrimitiveSet(DrawArraysPrimitiveType, mode, numInstances),
_first(first),
_count(count) {}
DrawArrays(const DrawArrays& da,const CopyOp&
copyop=CopyOp::SHALLOW_COPY):
PrimitiveSet(da,copyop),
_first(da._first),
_count(da._count) {}
virtual Object* cloneType() const { return new DrawArrays(); }
virtual Object* clone(const CopyOp& copyop) const { return new
DrawArrays(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return
dynamic_cast<const DrawArrays*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "DrawArrays"; }
void set(GLenum mode,GLint first, GLsizei count)
{
_mode = mode;
_first = first;
_count = count;
}
void setFirst(GLint first) { _first = first; }
GLint getFirst() const { return _first; }
void setCount(GLsizei count) { _count = count; }
GLsizei getCount() const { return _count; }
virtual void draw(State& state, bool useVertexBufferObjects) const;
virtual void accept(PrimitiveFunctor& functor) const;
virtual void accept(PrimitiveIndexFunctor& functor) const;
virtual unsigned int getNumIndices() const { return
static_cast<unsigned int>(_count); }
virtual unsigned int index(unsigned int pos) const { return
static_cast<unsigned int>(_first)+pos; }
virtual void offsetIndices(int offset) { _first += offset; }
protected:
virtual ~DrawArrays() {}
GLint _first;
GLsizei _count;
};
class OSG_EXPORT DrawArrayLengths : public PrimitiveSet, public VectorGLsizei
{
public:
typedef VectorGLsizei vector_type;
DrawArrayLengths(GLenum mode=0):
PrimitiveSet(DrawArrayLengthsPrimitiveType,mode),
_first(0) {}
DrawArrayLengths(const DrawArrayLengths& dal,const CopyOp&
copyop=CopyOp::SHALLOW_COPY):
PrimitiveSet(dal,copyop),
vector_type(dal),
_first(dal._first) {}
DrawArrayLengths(GLenum mode, GLint first, unsigned int no, GLsizei*
ptr) :
PrimitiveSet(DrawArrayLengthsPrimitiveType,mode),
vector_type(ptr,ptr+no),
_first(first) {}
DrawArrayLengths(GLenum mode,GLint first, unsigned int no) :
PrimitiveSet(DrawArrayLengthsPrimitiveType,mode),
vector_type(no),
_first(first) {}
DrawArrayLengths(GLenum mode,GLint first) :
PrimitiveSet(DrawArrayLengthsPrimitiveType,mode),
vector_type(),
_first(first) {}
virtual Object* cloneType() const { return new DrawArrayLengths(); }
virtual Object* clone(const CopyOp& copyop) const { return new
DrawArrayLengths(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return
dynamic_cast<const DrawArrayLengths*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "DrawArrayLengths"; }
void setFirst(GLint first) { _first = first; }
GLint getFirst() const { return _first; }
virtual void draw(State& state, bool useVertexBufferObjects) const;
virtual void accept(PrimitiveFunctor& functor) const;
virtual void accept(PrimitiveIndexFunctor& functor) const;
virtual unsigned int getNumIndices() const;
virtual unsigned int index(unsigned int pos) const { return _first+pos;
}
virtual void offsetIndices(int offset) { _first += offset; }
virtual unsigned int getNumPrimitives() const;
protected:
virtual ~DrawArrayLengths() {}
GLint _first;
};
class DrawElements : public PrimitiveSet
{
public:
DrawElements(Type primType=PrimitiveType, GLenum mode=0, int
numInstances=0):
PrimitiveSet(primType,mode, numInstances) {}
DrawElements(const DrawElements& copy,const CopyOp&
copyop=CopyOp::SHALLOW_COPY):
PrimitiveSet(copy,copyop) {}
virtual DrawElements* getDrawElements() { return this; }
virtual const DrawElements* getDrawElements() const { return this; }
/** Set the ElementBufferObject.*/
inline void setElementBufferObject(osg::ElementBufferObject* ebo) {
setBufferObject(ebo); }
/** Get the ElementBufferObject. If no EBO is assigned returns NULL*/
inline osg::ElementBufferObject* getElementBufferObject() { return
dynamic_cast<osg::ElementBufferObject*>(_bufferObject.get()); }
/** Get the const ElementBufferObject. If no EBO is assigned returns
NULL*/
inline const osg::ElementBufferObject* getElementBufferObject() const {
return dynamic_cast<const osg::ElementBufferObject*>(_bufferObject.get()); }
virtual void reserveElements(unsigned int numIndices) = 0;
virtual void setElement(unsigned int, unsigned int) = 0;
virtual unsigned int getElement(unsigned int) = 0;
virtual void addElement(unsigned int) = 0;
protected:
virtual ~DrawElements() {}
};
class OSG_EXPORT DrawElementsUByte : public DrawElements, public VectorGLubyte
{
public:
typedef VectorGLubyte vector_type;
DrawElementsUByte(GLenum mode=0):
DrawElements(DrawElementsUBytePrimitiveType,mode) {}
DrawElementsUByte(const DrawElementsUByte& array, const CopyOp&
copyop=CopyOp::SHALLOW_COPY):
DrawElements(array,copyop),
vector_type(array) {}
DrawElementsUByte(GLenum mode, unsigned int no, const GLubyte* ptr, int
numInstances=0) :
DrawElements(DrawElementsUBytePrimitiveType,mode,numInstances),
vector_type(ptr,ptr+no) {}
DrawElementsUByte(GLenum mode, unsigned int no) :
DrawElements(DrawElementsUBytePrimitiveType,mode),
vector_type(no) {}
virtual Object* cloneType() const { return new DrawElementsUByte(); }
virtual Object* clone(const CopyOp& copyop) const { return new
DrawElementsUByte(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return
dynamic_cast<const DrawElementsUByte*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "DrawElementsUByte"; }
virtual const GLvoid* getDataPointer() const { return
empty()?0:&front(); }
virtual unsigned int getTotalDataSize() const { return
static_cast<unsigned int>(size()); }
virtual bool supportsBufferObject() const { return false; }
virtual void draw(State& state, bool useVertexBufferObjects) const ;
virtual void accept(PrimitiveFunctor& functor) const;
virtual void accept(PrimitiveIndexFunctor& functor) const;
virtual unsigned int getNumIndices() const { return
static_cast<unsigned int>(size()); }
virtual unsigned int index(unsigned int pos) const { return
(*this)[pos]; }
virtual void offsetIndices(int offset);
virtual void computeRange() const
{
if (empty())
{
_minIndex = 0;
_maxIndex = 0;
_rangeModifiedCount = _modifiedCount;
return;
}
_minIndex = front();
_maxIndex = _minIndex;
for(vector_type::const_iterator itr=begin(); itr!=end(); ++itr)
{
if (*itr<_minIndex) _minIndex = *itr;
if (*itr>_maxIndex) _maxIndex = *itr;
}
_rangeModifiedCount = _modifiedCount;
}
virtual void reserveElements(unsigned int numIndices) {
reserve(numIndices); }
virtual void setElement(unsigned int i, unsigned int v) { (*this)[i] =
v; }
virtual unsigned int getElement(unsigned int i) { return (*this)[i]; }
virtual void addElement(unsigned int v) { push_back(GLubyte(v)); }
protected:
virtual ~DrawElementsUByte();
mutable unsigned int _minIndex;
mutable unsigned int _maxIndex;
};
class OSG_EXPORT DrawElementsUShort : public DrawElements, public VectorGLushort
{
public:
typedef VectorGLushort vector_type;
DrawElementsUShort(GLenum mode=0):
DrawElements(DrawElementsUShortPrimitiveType,mode) {}
DrawElementsUShort(const DrawElementsUShort& array,const CopyOp&
copyop=CopyOp::SHALLOW_COPY):
DrawElements(array,copyop),
vector_type(array) {}
DrawElementsUShort(GLenum mode, unsigned int no, const GLushort* ptr,
int numInstances=0) :
DrawElements(DrawElementsUShortPrimitiveType,mode,numInstances),
vector_type(ptr,ptr+no) {}
DrawElementsUShort(GLenum mode, unsigned int no) :
DrawElements(DrawElementsUShortPrimitiveType,mode),
vector_type(no) {}
template <class InputIterator>
DrawElementsUShort(GLenum mode, InputIterator first,InputIterator last)
:
DrawElements(DrawElementsUShortPrimitiveType,mode),
vector_type(first,last) {}
virtual Object* cloneType() const { return new DrawElementsUShort(); }
virtual Object* clone(const CopyOp& copyop) const { return new
DrawElementsUShort(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return
dynamic_cast<const DrawElementsUShort*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "DrawElementsUShort"; }
virtual const GLvoid* getDataPointer() const { return
empty()?0:&front(); }
virtual unsigned int getTotalDataSize() const { return
2u*static_cast<unsigned int>(size()); }
virtual bool supportsBufferObject() const { return false; }
virtual void draw(State& state, bool useVertexBufferObjects) const;
virtual void accept(PrimitiveFunctor& functor) const;
virtual void accept(PrimitiveIndexFunctor& functor) const;
virtual unsigned int getNumIndices() const { return
static_cast<unsigned int>(size()); }
virtual unsigned int index(unsigned int pos) const { return
(*this)[pos]; }
virtual void offsetIndices(int offset);
virtual void computeRange() const
{
if (empty())
{
_minIndex = 0;
_maxIndex = 0;
_rangeModifiedCount = _modifiedCount;
return;
}
_minIndex = front();
_maxIndex = _minIndex;
for(vector_type::const_iterator itr=begin(); itr!=end(); ++itr)
{
if (*itr<_minIndex) _minIndex = *itr;
if (*itr>_maxIndex) _maxIndex = *itr;
}
_rangeModifiedCount = _modifiedCount;
}
virtual void reserveElements(unsigned int numIndices) {
reserve(numIndices); }
virtual void setElement(unsigned int i, unsigned int v) { (*this)[i] =
v; }
virtual unsigned int getElement(unsigned int i) { return (*this)[i]; }
virtual void addElement(unsigned int v) { push_back(GLushort(v)); }
protected:
virtual ~DrawElementsUShort();
mutable unsigned int _minIndex;
mutable unsigned int _maxIndex;
};
class OSG_EXPORT DrawElementsUInt : public DrawElements, public VectorGLuint
{
public:
typedef VectorGLuint vector_type;
DrawElementsUInt(GLenum mode=0):
DrawElements(DrawElementsUIntPrimitiveType,mode) {}
DrawElementsUInt(const DrawElementsUInt& array,const CopyOp&
copyop=CopyOp::SHALLOW_COPY):
DrawElements(array,copyop),
vector_type(array) {}
DrawElementsUInt(GLenum mode, unsigned int no, const GLuint* ptr, int
numInstances=0) :
DrawElements(DrawElementsUIntPrimitiveType,mode,numInstances),
vector_type(ptr,ptr+no) {}
DrawElementsUInt(GLenum mode, unsigned int no) :
DrawElements(DrawElementsUIntPrimitiveType,mode),
vector_type(no) {}
template <class InputIterator>
DrawElementsUInt(GLenum mode, InputIterator first,InputIterator last) :
DrawElements(DrawElementsUIntPrimitiveType,mode),
vector_type(first,last) {}
virtual Object* cloneType() const { return new DrawElementsUInt(); }
virtual Object* clone(const CopyOp& copyop) const { return new
DrawElementsUInt(*this,copyop); }
virtual bool isSameKindAs(const Object* obj) const { return
dynamic_cast<const DrawElementsUInt*>(obj)!=NULL; }
virtual const char* libraryName() const { return "osg"; }
virtual const char* className() const { return "DrawElementsUInt"; }
virtual const GLvoid* getDataPointer() const { return
empty()?0:&front(); }
virtual unsigned int getTotalDataSize() const { return
4u*static_cast<unsigned int>(size()); }
virtual bool supportsBufferObject() const { return false; }
virtual void draw(State& state, bool useVertexBufferObjects) const;
virtual void accept(PrimitiveFunctor& functor) const;
virtual void accept(PrimitiveIndexFunctor& functor) const;
virtual unsigned int getNumIndices() const { return
static_cast<unsigned int>(size()); }
virtual unsigned int index(unsigned int pos) const { return
(*this)[pos]; }
virtual void offsetIndices(int offset);
virtual void computeRange() const
{
if (empty())
{
_minIndex = 0;
_maxIndex = 0;
_rangeModifiedCount = _modifiedCount;
return;
}
_minIndex = front();
_maxIndex = _minIndex;
for(vector_type::const_iterator itr=begin(); itr!=end(); ++itr)
{
if (*itr<_minIndex) _minIndex = *itr;
if (*itr>_maxIndex) _maxIndex = *itr;
}
_rangeModifiedCount = _modifiedCount;
}
virtual void reserveElements(unsigned int numIndices) {
reserve(numIndices); }
virtual void setElement(unsigned int i, unsigned int v) { (*this)[i] =
v; }
virtual unsigned int getElement(unsigned int i) { return (*this)[i]; }
virtual void addElement(unsigned int v) { push_back(GLuint(v)); }
protected:
virtual ~DrawElementsUInt();
mutable unsigned int _minIndex;
mutable unsigned int _maxIndex;
};
}
#endif
_______________________________________________
osg-submissions mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-submissions-openscenegraph.org
