diff --git a/VisualStudio/osgPlugins/osg/dot_osg.dsp b/VisualStudio/osgPlugins/osg/dot_osg.dsp index ad90fbc6f..7818661e5 100755 --- a/VisualStudio/osgPlugins/osg/dot_osg.dsp +++ b/VisualStudio/osgPlugins/osg/dot_osg.dsp @@ -150,6 +150,10 @@ SOURCE=..\..\..\src\osgPlugins\osg\GeoSet.cpp # End Source File # Begin Source File +SOURCE=..\..\..\src\osgPlugins\osg\Geometry.cpp +# End Source File +# Begin Source File + SOURCE=..\..\..\src\osgPlugins\osg\Group.cpp # End Source File # Begin Source File diff --git a/include/osg/Geometry b/include/osg/Geometry index 81c8fdaec..2842fca1e 100644 --- a/include/osg/Geometry +++ b/include/osg/Geometry @@ -28,22 +28,6 @@ enum ArrayType Vec4ArrayType = 11 }; -static char* s_classNames[] = -{ - "AttributeArray" // 0 - "ByteArray", // 1 - "ShortArray", // 2 - "IntArray", // 3 - "UByteArray", // 4 - "UShortArray", // 5 - "UIntArray", // 6 - "UByte4Array", // 7 - "FloatArray", // 8 - "Vec2Array", // 9 - "Vec3Array", // 10 - "Vec4Array" // 11 -}; - class AttributeArray : public Object { @@ -62,7 +46,7 @@ class AttributeArray : public Object 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 "AttributeArray"; } + virtual const char* className() const; ArrayType arrayType() const { return _arrayType; } @@ -102,8 +86,6 @@ class TemplateArray : public AttributeArray, public std::vector virtual Object* cloneType() const { return osgNew TemplateArray(); } virtual Object* clone(const CopyOp& copyop) const { return osgNew TemplateArray(*this,copyop); } - virtual const char* libraryName() const { return "osg"; } - virtual const char* className() const { return s_classNames[ARRAYTYPE]; } virtual const GLvoid* dataPointer() const { if (!empty()) return &front(); else return 0; } }; @@ -125,26 +107,17 @@ typedef TemplateArray Vec4Ar enum PrimitiveType { PrimitivePrimitiveType = 0, - DrawArraysPrimitiveType = 1, + DrawArraysPrimitiveType = 1, UByteDrawElementsPrimitiveType = 2, UShortDrawElementsPrimitiveType = 3, UIntDrawElementsPrimitiveType = 4, }; -static char* s_PrimitiveNames[] = -{ - "Primitive", // 0 - "DrawArrays", // 1 - "UByteDrawElements", // 2 - "UShortDrawElements", // 3 - "UIntDrawElements" // 4 -}; - class Primitive : public Object { public: - enum PrimitiveMode + enum Mode { POINTS = GL_POINTS, LINES = GL_LINES, @@ -165,9 +138,9 @@ class Primitive : public Object 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 "Primitive"; } + virtual const char* className() const; - PrimitiveType primitiveType; + PrimitiveType primitiveType() const { return _primitiveType; } virtual void draw() const = 0; @@ -200,6 +173,25 @@ class DrawArrays : public Primitive 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 setMode(GLenum mode) { _mode = mode; } + GLenum getMode() const { return _mode; } + + 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 { glDrawArrays(_mode,_first,_count); @@ -242,8 +234,10 @@ class DrawElements : public Primitive, public std::vector virtual Object* clone(const CopyOp& copyop) const { return osgNew DrawElements(*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 s_PrimitiveNames[PRIMTYPE]; } + void setMode(GLenum mode) { _mode = mode; } + GLenum getMode() const { return _mode; } + virtual void draw() const { glDrawElements(_mode,size(),_dataType,&front()); @@ -307,11 +301,16 @@ class SG_EXPORT Geometry : public Drawable const AttributeArray* getColorArray() const { return _colorArray.get(); } - typedef std::vector< ref_ptr > TexCoordList; + typedef std::vector< ref_ptr > TexCoordArrayList; + void setTexCoordArray(unsigned int unit,AttributeArray*); AttributeArray* getTexCoordArray(unsigned int unit); const AttributeArray* getTexCoordArray(unsigned int unit) const; + + unsigned int getNumTexCoordArrays() const { return _texCoordList.size(); } + TexCoordArrayList& getTexCoordArrayList() { return _texCoordList; } + const TexCoordArrayList& getTexCoordArrayList() const { return _texCoordList; } typedef std::vector< ref_ptr > PrimitiveList; @@ -362,7 +361,7 @@ class SG_EXPORT Geometry : public Drawable AttributeBinding _colorBinding; ref_ptr _colorArray; - TexCoordList _texCoordList; + TexCoordArrayList _texCoordList; }; diff --git a/src/osg/Geometry.cpp b/src/osg/Geometry.cpp index 8d13b1271..61eaf8a39 100644 --- a/src/osg/Geometry.cpp +++ b/src/osg/Geometry.cpp @@ -2,6 +2,49 @@ using namespace osg; +static char* s_ArrayNames[] = +{ + "AttributeArray", // 0 + "ByteArray", // 1 + "ShortArray", // 2 + "IntArray", // 3 + + "UByteArray", // 4 + "UShortArray", // 5 + "UIntArray", // 6 + "UByte4Array", // 7 + + "FloatArray", // 8 + "Vec2Array", // 9 + "Vec3Array", // 10 + "Vec4Array", // 11 +}; + +const char* AttributeArray::className() const +{ + if (_arrayType>=AttributeArrayType && _arrayType<=Vec4ArrayType) + return s_ArrayNames[_arrayType]; + else + return "UnkownAttributeArray"; +} + +static char* s_PrimitiveNames[] = +{ + "Primitive", // 0 + "DrawArrays", // 1 + "UByteDrawElements", // 2 + "UShortDrawElements", // 3 + "UIntDrawElements" // 4 +}; + +const char* Primitive::className() const +{ + if (_primitiveType>=PrimitivePrimitiveType && _primitiveType<=UIntDrawElementsPrimitiveType) + return s_PrimitiveNames[_primitiveType]; + else + return "UnkownAttributeArray"; +} + Geometry::Geometry() { _normalBinding = BIND_OFF; diff --git a/src/osg/Texture.cpp b/src/osg/Texture.cpp index f8e3d69d3..5fd8b7c9e 100644 --- a/src/osg/Texture.cpp +++ b/src/osg/Texture.cpp @@ -426,9 +426,7 @@ void Texture::applyTexImage(GLenum target, Image* image, State& state) const // when use 16 bit textures rather than 24/32bit textures. // internalFormat = GL_RGBA4; - // an experiment to look at the changes in performance - // when use 16 bit textures rather than 24/32bit textures. - // internalFormat = GL_RGBA4; + static MyCompressedTexImage2DArbProc glCompressedTexImage2D_ptr = (MyCompressedTexImage2DArbProc)getGLExtensionFuncPtr("glCompressedTexImage2DARB"); diff --git a/src/osgPlugins/osg/Geometry.cpp b/src/osgPlugins/osg/Geometry.cpp new file mode 100644 index 000000000..59ff0c44e --- /dev/null +++ b/src/osgPlugins/osg/Geometry.cpp @@ -0,0 +1,777 @@ +#include + +#include +#include +#include + +using namespace osg; +using namespace osgDB; + +// forward declare functions to use later. +bool Geometry_readLocalData(Object& obj, Input& fr); +bool Geometry_writeLocalData(const Object& obj, Output& fw); + +bool Geometry_matchBindingTypeStr(const char* str,Geometry::AttributeBinding& mode); +const char* Geometry_getBindingTypeStr(Geometry::AttributeBinding mode); + +bool Geometry_matchPrimitiveModeStr(const char* str,GLenum& mode); +const char* Geometry_getPrimitiveModeStr(GLenum mode); + +AttributeArray* AttributeArray_readLocalData(Input& fr); + +bool Primitve_readLocalData(Input& fr,osg::Geometry& geom); + +// register the read and write functions with the osgDB::Registry. +RegisterDotOsgWrapperProxy g_GeometryFuncProxy +( + osgNew osg::Geometry, + "Geometry", + "Object Drawable Geometry", + &Geometry_readLocalData, + &Geometry_writeLocalData, + DotOsgWrapper::READ_AND_WRITE +); + +bool Geometry_readLocalData(Object& obj, Input& fr) +{ + bool iteratorAdvanced = false; + + Geometry& geom = static_cast(obj); + + if (fr.matchSequence("Primitives %i {")) + { + int entry = fr[1].getNoNestedBrackets(); + + int capacity; + fr[1].getInt(capacity); + + Geometry::PrimitiveList& primitives = geom.getPrimitiveList(); + if (capacity>0) primitives.reserve(capacity); + + + fr += 3; + + + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + if (!Primitve_readLocalData(fr,geom)) ++fr; + } + + ++fr; + + iteratorAdvanced = true; + + } + + if (fr.matchSequence("VertexArray %i {")) + { + + int entry = fr[0].getNoNestedBrackets(); + + int capacity; + fr[1].getInt(capacity); + + Vec3Array* vertices = osgNew Vec3Array; + vertices->reserve(capacity); + + fr += 3; + + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + Vec3 v; + if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z())) + { + fr += 3; + vertices->push_back(v); + } + else + { + ++fr; + } + } + + geom.setVertexArray(vertices); + + iteratorAdvanced = true; + ++fr; + + + } + + Geometry::AttributeBinding normalBinding=Geometry::BIND_OFF; + if (fr[0].matchWord("NormalBinding") && Geometry_matchBindingTypeStr(fr[1].getStr(),normalBinding)) + { + geom.setNormalBinding(normalBinding); + fr+=2; + iteratorAdvanced = true; + } + + if (fr.matchSequence("NormalArray %i {")) + { + int entry = fr[0].getNoNestedBrackets(); + + int capacity; + fr[1].getInt(capacity); + + Vec3Array* normals = osgNew Vec3Array; + normals->reserve(capacity); + + fr += 3; + + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + Vec3 v; + if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z())) + { + fr += 3; + normals->push_back(v); + } + else + { + ++fr; + } + } + + geom.setNormalArray(normals); + + iteratorAdvanced = true; + ++fr; + } + + Geometry::AttributeBinding colorBinding=Geometry::BIND_OFF; + if (fr[0].matchWord("ColorBinding") && Geometry_matchBindingTypeStr(fr[1].getStr(),colorBinding)) + { + geom.setColorBinding(colorBinding); + fr+=2; + iteratorAdvanced = true; + } + + if (fr.matchSequence("ColorArray %w %i {")) + { + ++fr; + AttributeArray* colors = AttributeArray_readLocalData(fr); + if (colors) + { + geom.setColorArray(colors); + iteratorAdvanced++; + } + } + + if (fr.matchSequence("TexCoordArray %i %w %i {")) + { + int unit=0; + fr[1].getInt(unit); + + fr+=2; + AttributeArray* texcoords = AttributeArray_readLocalData(fr); + if (texcoords) + { + geom.setTexCoordArray(unit,texcoords); + iteratorAdvanced++; + } + + } + + return iteratorAdvanced; +} + + +AttributeArray* AttributeArray_readLocalData(Input& fr) +{ + int entry = fr[0].getNoNestedBrackets(); + + const char* arrayName = fr[0].getStr(); + + unsigned int capacity = 0; + fr[1].getUInt(capacity); + ++fr; + + fr += 2; + + if (strcmp(arrayName,"ByteArray")==0) + { + ByteArray* array = osgNew ByteArray; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + int int_value; + if (fr[0].getInt(int_value)) + { + ++fr; + array->push_back(int_value); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"ShortArray")==0) + { + ShortArray* array = osgNew ShortArray; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + int int_value; + if (fr[0].getInt(int_value)) + { + ++fr; + array->push_back(int_value); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"IntArray")==0) + { + IntArray* array = osgNew IntArray; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + int int_value; + if (fr[0].getInt(int_value)) + { + ++fr; + array->push_back(int_value); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"UByteArray")==0) + { + UByteArray* array = osgNew UByteArray; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + unsigned int uint_value; + if (fr[0].getUInt(uint_value)) + { + ++fr; + array->push_back(uint_value); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"UShortArray")==0) + { + UShortArray* array = osgNew UShortArray; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + unsigned int uint_value; + if (fr[0].getUInt(uint_value)) + { + ++fr; + array->push_back(uint_value); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"UIntArray")==0) + { + UIntArray* array = osgNew UIntArray; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + unsigned int uint_value; + if (fr[0].getUInt(uint_value)) + { + ++fr; + array->push_back(uint_value); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"UByte4Array")==0) + { + UByte4Array* array = osgNew UByte4Array; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + unsigned int uint_value; + if (fr[0].getUInt(uint_value)) + { + ++fr; + array->push_back(uint_value); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"FloatArray")==0) + { + FloatArray* array = osgNew FloatArray; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + float float_value; + if (fr[0].getFloat(float_value)) + { + ++fr; + array->push_back(float_value); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"Vec2Array")==0) + { + Vec2Array* array = osgNew Vec2Array; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + Vec2 v; + if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y())) + { + fr += 2; + array->push_back(v); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"Vec3Array")==0) + { + Vec3Array* array = osgNew Vec3Array; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + Vec3 v; + if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z())) + { + fr += 3; + array->push_back(v); + } + else ++fr; + } + ++fr; + return array; + } + else if (strcmp(arrayName,"Vec4Array")==0) + { + Vec4Array* array = osgNew Vec4Array; + array->reserve(capacity); + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + Vec4 v; + if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()) && fr[3].getFloat(v.w())) + { + fr += 4; + array->push_back(v); + } + else ++fr; + } + ++fr; + return array; + } + + return 0; +} + + +template +void Array_writeLocalData(Output& fw, Iterator first, Iterator last) +{ + fw.indent() << "{"<(array); + fw<(array); + fw<(array); + fw<(array); + fw<(array); + fw<(array); + fw<(array); + fw<(array); + fw<(array); + fw<(array); + fw<(array); + fw<setMode(mode); + prim->reserve(capacity); + + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + unsigned int i; + if (fr[0].getUInt(i)) + { + prim->push_back(i); + ++fr; + } + } + ++fr; + + geom.addPrimitive(prim); + + iteratorAdvanced = true; + } + else if (fr.matchSequence("UShortDrawElements %w %i {")) + { + int entry = fr[1].getNoNestedBrackets(); + + GLenum mode; + Geometry_matchPrimitiveModeStr(fr[1].getStr(),mode); + + int capacity; + fr[2].getInt(capacity); + + fr += 4; + + UShortDrawElements* prim = osgNew UShortDrawElements; + prim->setMode(mode); + prim->reserve(capacity); + + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + unsigned int i; + if (fr[0].getUInt(i)) + { + prim->push_back(i); + ++fr; + } + } + ++fr; + + geom.addPrimitive(prim); + + iteratorAdvanced = true; + } + else if (fr.matchSequence("UIntDrawElements %w %i {")) + { + int entry = fr[1].getNoNestedBrackets(); + + GLenum mode; + Geometry_matchPrimitiveModeStr(fr[1].getStr(),mode); + + int capacity; + fr[2].getInt(capacity); + + fr += 4; + + UIntDrawElements* prim = osgNew UIntDrawElements; + prim->setMode(mode); + prim->reserve(capacity); + + while (!fr.eof() && fr[0].getNoNestedBrackets()>entry) + { + unsigned int i; + if (fr[0].getUInt(i)) + { + prim->push_back(i); + ++fr; + } + } + ++fr; + + geom.addPrimitive(prim); + + iteratorAdvanced = true; + } + + return iteratorAdvanced; +} + +bool Primitve_writeLocalData(const Primitive& prim,Output& fw) +{ + + switch(prim.primitiveType()) + { + case(DrawArraysPrimitiveType): + { + const DrawArrays& cprim = static_cast(prim); + fw<(prim); + fw<(prim); + fw<(prim); + fw<(obj); + + const Geometry::PrimitiveList& primitives = geom.getPrimitiveList(); + if (!primitives.empty()) + { + fw.indent() << "Primitives "<accept(cgtg); +// // convert the old style GeoSet to Geometry +// ConvertGeoSetsToGeometryVisitor cgtg; +// node->accept(cgtg); if (options & SHARE_DUPLICATE_STATE)