346 lines
12 KiB
Plaintext
346 lines
12 KiB
Plaintext
//C++ header - Open Scene Graph - Copyright (C) 1998-2001 Robert Osfield
|
|
//Distributed under the terms of the GNU Library General Public License (LGPL)
|
|
//as published by the Free Software Foundation.
|
|
|
|
#ifndef OSG_PRIMTIVE
|
|
#define OSG_PRIMTIVE 1
|
|
|
|
#include <osg/Drawable>
|
|
|
|
namespace osg {
|
|
|
|
#ifndef _MSC_VER
|
|
|
|
typedef std::vector<GLsizei> VectorSizei;
|
|
typedef std::vector<GLubyte> VectorUByte;
|
|
typedef std::vector<GLushort> VectorUShort;
|
|
typedef std::vector<GLuint> VectorUInt;
|
|
|
|
#else // _MSC_VER
|
|
|
|
// Following Vector wrapper classes are work arounds for MS linker problems with
|
|
// multiply implemented methods.
|
|
//
|
|
// An alternative, sent in by Clay Fowler, is workaround in VS to prevent the problem:
|
|
// the following changes have to be made to the project to make it compile,
|
|
// but NO changes are required to the actual source code:
|
|
// In the osgUtil project, go to the project properties, select the Linker/Command Line property page,
|
|
// and add the following switch in the "Additional Options" field:
|
|
// FORCE:MULTIPLE
|
|
|
|
class VectorSizei: public std::vector<GLsizei> {
|
|
typedef std::vector<value_type> inherited;
|
|
public:
|
|
VectorSizei(): inherited() {}
|
|
explicit VectorSizei(size_type n): inherited(n) {}
|
|
VectorSizei(const VectorSizei ©): inherited(copy) {}
|
|
VectorSizei(value_type *beg_, value_type *end_): inherited(beg_, end_) {}
|
|
template<class InputIterator>
|
|
VectorSizei(InputIterator beg_, InputIterator end_): inherited(beg_, end_) {}
|
|
};
|
|
|
|
class VectorUByte: public std::vector<GLubyte> {
|
|
typedef std::vector<value_type> inherited;
|
|
public:
|
|
VectorUByte(): inherited() {}
|
|
explicit VectorUByte(size_type n): inherited(n) {}
|
|
VectorUByte(const VectorUByte ©): inherited(copy) {}
|
|
VectorUByte(value_type *beg_, value_type *end_): inherited(beg_, end_) {}
|
|
template<class InputIterator>
|
|
VectorUByte(InputIterator beg_, InputIterator end_): inherited(beg_, end_) {}
|
|
};
|
|
|
|
class VectorUShort: public std::vector<GLushort> {
|
|
typedef std::vector<value_type> inherited;
|
|
public:
|
|
VectorUShort(): inherited() {}
|
|
explicit VectorUShort(size_type n): inherited(n) {}
|
|
VectorUShort(const VectorUShort ©): inherited(copy) {}
|
|
VectorUShort(value_type *beg_, value_type *end_): inherited(beg_, end_) {}
|
|
template<class InputIterator>
|
|
VectorUShort(InputIterator beg_, InputIterator end_): inherited(beg_, end_) {}
|
|
};
|
|
|
|
class VectorUInt: public std::vector<GLuint> {
|
|
typedef std::vector<value_type> inherited;
|
|
public:
|
|
VectorUInt(): inherited() {}
|
|
explicit VectorUInt(size_type n): inherited(n) {}
|
|
VectorUInt(const VectorUInt ©): inherited(copy) {}
|
|
VectorUInt(value_type *beg_, value_type *end_): inherited(beg_, end_) {}
|
|
template<class InputIterator>
|
|
VectorUInt(InputIterator beg_, InputIterator end_): inherited(beg_, end_) {}
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
class Primitive : public Object
|
|
{
|
|
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
|
|
};
|
|
|
|
Primitive(Type primType=PrimitiveType,GLenum mode=0):
|
|
_primitiveType(primType),
|
|
_mode(mode) {}
|
|
|
|
Primitive(const Primitive& prim,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
|
|
Object(prim,copyop),
|
|
_primitiveType(prim._primitiveType),
|
|
_mode(prim._mode) {}
|
|
|
|
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const Primitive*>(obj)!=NULL; }
|
|
virtual const char* libraryName() const { return "osg"; }
|
|
virtual const char* className() const { return "Primitve"; }
|
|
|
|
Type getType() const { return _primitiveType; }
|
|
|
|
void setMode(GLenum mode) { _mode = mode; }
|
|
GLenum getMode() const { return _mode; }
|
|
|
|
virtual void draw() const = 0;
|
|
|
|
virtual void applyPrimitiveOperation(Drawable::PrimitiveFunctor&) {}
|
|
|
|
protected:
|
|
|
|
Type _primitiveType;
|
|
GLenum _mode;
|
|
};
|
|
|
|
class SG_EXPORT DrawArrays : public Primitive
|
|
{
|
|
public:
|
|
|
|
DrawArrays(GLenum mode=0):
|
|
Primitive(DrawArraysPrimitiveType,mode),
|
|
_first(0),
|
|
_count(0) {}
|
|
|
|
DrawArrays(GLenum mode, GLint first, GLsizei count):
|
|
Primitive(DrawArraysPrimitiveType,mode),
|
|
_first(first),
|
|
_count(count) {}
|
|
|
|
DrawArrays(const DrawArrays& da,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
|
|
Primitive(da,copyop),
|
|
_first(da._first),
|
|
_count(da._count) {}
|
|
|
|
virtual Object* cloneType() const { return osgNew DrawArrays(); }
|
|
virtual Object* clone(const CopyOp& copyop) const { return osgNew 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() const;
|
|
|
|
virtual void applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor);
|
|
|
|
protected:
|
|
|
|
GLint _first;
|
|
GLsizei _count;
|
|
};
|
|
|
|
class SG_EXPORT DrawArrayLengths : public Primitive, public VectorSizei
|
|
{
|
|
public:
|
|
|
|
DrawArrayLengths(GLenum mode=0):
|
|
Primitive(DrawArrayLengthsPrimitiveType,mode),
|
|
_first(0) {}
|
|
|
|
DrawArrayLengths(const DrawArrayLengths& dal,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
|
|
Primitive(dal,copyop),
|
|
VectorSizei(dal),
|
|
_first(dal._first) {}
|
|
|
|
DrawArrayLengths(GLenum mode, GLint first, unsigned int no, GLsizei* ptr) :
|
|
Primitive(DrawArrayLengthsPrimitiveType,mode),
|
|
VectorSizei(ptr,ptr+no),
|
|
_first(first) {}
|
|
|
|
DrawArrayLengths(GLenum mode,GLint first, unsigned int no) :
|
|
Primitive(DrawArrayLengthsPrimitiveType,mode),
|
|
VectorSizei(no),
|
|
_first(first) {}
|
|
|
|
template <class InputIterator>
|
|
DrawArrayLengths(GLenum mode, GLint first, InputIterator firstItr,InputIterator lastItr) :
|
|
Primitive(DrawArrayLengthsPrimitiveType,mode),
|
|
VectorSizei(firstItr,lastItr),
|
|
_first(first) {}
|
|
|
|
virtual Object* cloneType() const { return osgNew DrawArrayLengths(); }
|
|
virtual Object* clone(const CopyOp& copyop) const { return osgNew 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() const;
|
|
|
|
virtual void applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor);
|
|
|
|
protected:
|
|
|
|
GLint _first;
|
|
};
|
|
|
|
class SG_EXPORT DrawElementsUByte : public Primitive, public VectorUByte
|
|
{
|
|
public:
|
|
|
|
DrawElementsUByte(GLenum mode=0):
|
|
Primitive(DrawElementsUBytePrimitiveType,mode) {}
|
|
|
|
DrawElementsUByte(const DrawElementsUByte& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
|
|
Primitive(array,copyop),
|
|
VectorUByte(array) {}
|
|
|
|
DrawElementsUByte(GLenum mode,unsigned int no,unsigned char* ptr) :
|
|
Primitive(DrawElementsUBytePrimitiveType,mode),
|
|
VectorUByte(ptr,ptr+no) {}
|
|
|
|
DrawElementsUByte(GLenum mode,unsigned int no) :
|
|
Primitive(DrawElementsUBytePrimitiveType,mode),
|
|
VectorUByte(no) {}
|
|
|
|
template <class InputIterator>
|
|
DrawElementsUByte(GLenum mode, InputIterator first,InputIterator last) :
|
|
Primitive(DrawElementsUBytePrimitiveType,mode),
|
|
VectorUByte(first,last) {}
|
|
|
|
virtual Object* cloneType() const { return osgNew DrawElementsUByte(); }
|
|
virtual Object* clone(const CopyOp& copyop) const { return osgNew 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 void draw() const ;
|
|
|
|
virtual void applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor);
|
|
};
|
|
|
|
|
|
class SG_EXPORT DrawElementsUShort : public Primitive, public VectorUShort
|
|
{
|
|
public:
|
|
|
|
DrawElementsUShort(GLenum mode=0):
|
|
Primitive(DrawElementsUShortPrimitiveType,mode) {}
|
|
|
|
DrawElementsUShort(const DrawElementsUShort& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
|
|
Primitive(array,copyop),
|
|
VectorUShort(array) {}
|
|
|
|
DrawElementsUShort(GLenum mode,unsigned int no,unsigned short* ptr) :
|
|
Primitive(DrawElementsUShortPrimitiveType,mode),
|
|
VectorUShort(ptr,ptr+no) {}
|
|
|
|
DrawElementsUShort(GLenum mode,unsigned int no) :
|
|
Primitive(DrawElementsUShortPrimitiveType,mode),
|
|
VectorUShort(no) {}
|
|
|
|
template <class InputIterator>
|
|
DrawElementsUShort(GLenum mode, InputIterator first,InputIterator last) :
|
|
Primitive(DrawElementsUShortPrimitiveType,mode),
|
|
VectorUShort(first,last) {}
|
|
|
|
virtual Object* cloneType() const { return osgNew DrawElementsUShort(); }
|
|
virtual Object* clone(const CopyOp& copyop) const { return osgNew 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 void draw() const;
|
|
|
|
virtual void applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor);
|
|
};
|
|
|
|
class SG_EXPORT DrawElementsUInt : public Primitive, public VectorUInt
|
|
{
|
|
public:
|
|
|
|
DrawElementsUInt(GLenum mode=0):
|
|
Primitive(DrawElementsUIntPrimitiveType,mode) {}
|
|
|
|
DrawElementsUInt(const DrawElementsUInt& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
|
|
Primitive(array,copyop),
|
|
VectorUInt(array) {}
|
|
|
|
DrawElementsUInt(GLenum mode,unsigned int no,unsigned int* ptr) :
|
|
Primitive(DrawElementsUIntPrimitiveType,mode),
|
|
VectorUInt(ptr,ptr+no) {}
|
|
|
|
DrawElementsUInt(GLenum mode,unsigned int no) :
|
|
Primitive(DrawElementsUIntPrimitiveType,mode),
|
|
VectorUInt(no) {}
|
|
|
|
template <class InputIterator>
|
|
DrawElementsUInt(GLenum mode, InputIterator first,InputIterator last) :
|
|
Primitive(DrawElementsUIntPrimitiveType,mode),
|
|
VectorUInt(first,last) {}
|
|
|
|
virtual Object* cloneType() const { return osgNew DrawElementsUInt(); }
|
|
virtual Object* clone(const CopyOp& copyop) const { return osgNew 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 void draw() const;
|
|
|
|
virtual void applyPrimitiveOperation(Drawable::PrimitiveFunctor& functor);
|
|
|
|
};
|
|
|
|
// backwards compatibility with first incarnation of DrawElements nameing convention.
|
|
typedef DrawElementsUByte UByteDrawElements;
|
|
typedef DrawElementsUShort UShortDrawElements;
|
|
typedef DrawElementsUInt UIntDrawElements;
|
|
|
|
}
|
|
|
|
#endif
|