Changeset 10650

Timestamp:

10/20/09 21:34:24 (4 years ago)

Author:

robert

Message:

Refactored osg::Geometry::drawImplementation(..) to use new osg::ArrayDispatchers? that encapsulate the task
of dispatch osg::Array data as OpenGL attributes.

Location:

OpenSceneGraph/trunk

Files:

• include/osg/Array (modified) (11 diffs)
• include/osg/ArrayDispatchers (added)
• include/osg/Drawable (modified) (3 diffs)
• include/osg/GLBeginEndAdapter (modified) (2 diffs)
• include/osg/State (modified) (2 diffs)
• runexamples.bat (modified) (1 diff)
• src/osg/ArrayDispatchers.cpp (added)
• src/osg/CMakeLists.txt (modified) (2 diffs)
• src/osg/Drawable.cpp (modified) (2 diffs)
• src/osg/GLBeginEndAdapter.cpp (modified) (2 diffs)
• src/osg/Geometry.cpp (modified) (12 diffs)

OpenSceneGraph/trunk/include/osg/Array

@@ -72 +72 @@
             Vec2dArrayType    = 19,
             Vec3dArrayType    = 20,
-            Vec4dArrayType    = 21            
+            Vec4dArrayType    = 21
         };
 
@@ -79 +79 @@
             _dataSize(dataSize),
             _dataType(dataType) {}
-    
+
         Array(const Array& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
             BufferData(array,copyop),
@@ -89 +89 @@
         virtual const char* libraryName() const { return "osg"; }
         virtual const char* className() const;
-        
+
         virtual void accept(ArrayVisitor&) = 0;
         virtual void accept(ConstArrayVisitor&) const = 0;
@@ -132 +132 @@
 {
     public:
-    
+
         TemplateArray() : Array(ARRAYTYPE,DataSize,DataType) {}
 
@@ -138 +138 @@
             Array(ta,copyop),
             MixinVector<T>(ta) {}
-        
+
         TemplateArray(unsigned int no) : 
             Array(ARRAYTYPE,DataSize,DataType),
@@ -182 +182 @@
             MixinVector<T>( *this ).swap( *this );
         }
-        
+
         virtual const GLvoid*   getDataPointer() const { if (!this->empty()) return &this->front(); else return 0; }
         virtual unsigned int    getTotalDataSize() const { return static_cast<unsigned int>(this->size()*sizeof(T)); }
@@ -201 +201 @@
         IndexArray(Type arrayType=ArrayType,GLint dataSize=0,GLenum dataType=0):
             Array(arrayType,dataSize,dataType) {}
-    
+
         IndexArray(const Array& array,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
             Array(array,copyop) {}
 
         virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const IndexArray*>(obj)!=NULL; }
-        
+
         virtual unsigned int index(unsigned int pos) const = 0;
 
     protected:
-    
+
         virtual ~IndexArray() {}
 };
@@ -218 +218 @@
 {
     public:
-    
+
         TemplateIndexArray() : IndexArray(ARRAYTYPE,DataSize,DataType) {}
 
@@ -224 +224 @@
             IndexArray(ta,copyop),
             MixinVector<T>(ta) {}
-        
+
         TemplateIndexArray(unsigned int no) : 
             IndexArray(ARRAYTYPE,DataSize,DataType),
@@ -268 +268 @@
             MixinVector<T>( *this ).swap( *this );
         }
-        
+
         virtual const GLvoid*   getDataPointer() const { if (!this->empty()) return &this->front(); else return 0; }
         virtual unsigned int    getTotalDataSize() const { return static_cast<unsigned int>(this->size()*sizeof(T)); }
@@ -278 +278 @@
 
     protected:
-    
+
         virtual ~TemplateIndexArray() {}
 };

OpenSceneGraph/trunk/include/osg/Drawable

@@ -667 +667 @@
             void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64EXT *params) const;
 
-        protected:
+        public:
 
             typedef void (APIENTRY * FogCoordProc) (const GLfloat* coord);
@@ -736 +736 @@
             VertexAttrib1fProc _glVertexAttrib1f;
             VertexAttrib1dProc _glVertexAttrib1d;
+            VertexAttribfvProc _glVertexAttrib1fv;
             VertexAttribfvProc _glVertexAttrib2fv;
             VertexAttribfvProc _glVertexAttrib3fv;
             VertexAttribfvProc _glVertexAttrib4fv;
+            VertexAttribdvProc _glVertexAttrib1dv;
             VertexAttribdvProc _glVertexAttrib2dv;
             VertexAttribdvProc _glVertexAttrib3dv;
@@ -746 +748 @@
 
             MultiTexCoord1fProc _glMultiTexCoord1f;
+            MultiTexCoordfvProc _glMultiTexCoord1fv;
             MultiTexCoordfvProc _glMultiTexCoord2fv;
             MultiTexCoordfvProc _glMultiTexCoord3fv;
             MultiTexCoordfvProc _glMultiTexCoord4fv;
             MultiTexCoord1dProc _glMultiTexCoord1d;
+            MultiTexCoorddvProc _glMultiTexCoord1dv;
             MultiTexCoorddvProc _glMultiTexCoord2dv;
             MultiTexCoorddvProc _glMultiTexCoord3dv;

OpenSceneGraph/trunk/include/osg/GLBeginEndAdapter

@@ -55 +55 @@
         void Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
 
-        void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-        void Color4fv(const GLfloat* c) { Color4f(c[0], c[1], c[2], c[3]); }
-
         void Vertex3f(GLfloat x, GLfloat y, GLfloat z);
         void Vertex3fv(const GLfloat* v) { Vertex3f(v[0], v[1], v[2]); }
 
-        void Normal3f(GLfloat x, GLfloat y, GLfloat z);
+        void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+        {
+            _normalAssigned = true;
+            _color.set(red,green,blue,alpha);
+        }
+
+        void Color4fv(const GLfloat* c) { Color4f(c[0], c[1], c[2], c[3]); }
+
+        void Normal3f(GLfloat x, GLfloat y, GLfloat z)
+        {
+            _normalAssigned = true;
+            _normal.set(x,y,z);
+        }
+
         void Normal3fv(const GLfloat* n) { Normal3f(n[0], n[1], n[2]); }
 
@@ -141 +151 @@
 };
 
-
 }
 

OpenSceneGraph/trunk/include/osg/State

@@ -477 +477 @@
         }
 
-        void TexCoord(float x, float y=0.0f, float z=0.0f, float w=0.0f)
+        void TexCoord(float x, float y=0.0f, float z=0.0f, float w=1.0f)
         {
             if (_useVertexAttributeAliasing) _glVertexAttrib4f( _texCoordAliasList[0]._location, x,y,z,w);
@@ -483 +483 @@
         }
 
-        void MultiTexCoord(unsigned int unit, float x, float y=0.0f, float z=0.0f, float w=0.0f)
+        void MultiTexCoord(unsigned int unit, float x, float y=0.0f, float z=0.0f, float w=1.0f)
         {
             if (_useVertexAttributeAliasing) _glVertexAttrib4f( _texCoordAliasList[unit]._location, x,y,z,w);

OpenSceneGraph/trunk/runexamples.bat

@@ -26 +26 @@
 
 echo osgcatch
-osgcatch
+# osgcatch
 
 echo osgclip

OpenSceneGraph/trunk/src/osg/CMakeLists.txt

@@ -26 +26 @@
     ${HEADER_PATH}/ArgumentParser
     ${HEADER_PATH}/Array
+    ${HEADER_PATH}/ArrayDispatchers
     ${HEADER_PATH}/AudioStream
     ${HEADER_PATH}/AutoTransform
@@ -196 +197 @@
     ArgumentParser.cpp
     Array.cpp
+    ArrayDispatchers.cpp
     AudioStream.cpp
     AutoTransform.cpp

OpenSceneGraph/trunk/src/osg/Drawable.cpp

@@ -935 +935 @@
     setGLExtensionFuncPtr(_glSecondaryColor3fv, "glSecondaryColor3fv","glSecondaryColor3fvEXT");
     setGLExtensionFuncPtr(_glMultiTexCoord1f, "glMultiTexCoord1f","glMultiTexCoord1fARB");
+    setGLExtensionFuncPtr(_glMultiTexCoord1fv, "glMultiTexCoord1fv","glMultiTexCoord1fvARB");
     setGLExtensionFuncPtr(_glMultiTexCoord2fv, "glMultiTexCoord2fv","glMultiTexCoord2fvARB");
     setGLExtensionFuncPtr(_glMultiTexCoord3fv, "glMultiTexCoord3fv","glMultiTexCoord3fvARB");
@@ -946 +947 @@
     setGLExtensionFuncPtr(_glVertexAttrib1f, "glVertexAttrib1f","glVertexAttrib1fARB");
     setGLExtensionFuncPtr(_glVertexAttrib1d, "glVertexAttrib1d","glVertexAttrib1dARB");
+    setGLExtensionFuncPtr(_glVertexAttrib1fv, "glVertexAttrib1fv","glVertexAttrib1fvARB");
     setGLExtensionFuncPtr(_glVertexAttrib2fv, "glVertexAttrib2fv","glVertexAttrib2fvARB");
     setGLExtensionFuncPtr(_glVertexAttrib3fv, "glVertexAttrib3fv","glVertexAttrib3fvARB");

OpenSceneGraph/trunk/src/osg/GLBeginEndAdapter.cpp

@@ -98 +98 @@
 }
 
-void GLBeginEndAdapter::Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-{
-    _normalAssigned = true;
-    _color.set(red,green,blue,alpha);
-}
-
-void GLBeginEndAdapter::Normal3f(GLfloat x, GLfloat y, GLfloat z)
-{
-    _normalAssigned = true;
-    _normal.set(x,y,z);
-}
-
 void GLBeginEndAdapter::MultiTexCoord4f(unsigned int unit, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
@@ -133 +121 @@
 
     if (!_vertices) _vertices = new osg::Vec3Array;
-
 
     if (_normalAssigned)

OpenSceneGraph/trunk/src/osg/Geometry.cpp

@@ -14 +14 @@
 
 #include <osg/Geometry>
+#include <osg/ArrayDispatchers>
 #include <osg/Notify>
 
@@ -224 +225 @@
 public:
 
-    DrawVertexAttrib(const Drawable::Extensions * extensions,unsigned int vertAttribIndex,GLboolean normalized,const Array* attribcoords,const IndexArray* indices):    
+    DrawVertexAttrib(const Drawable::Extensions * extensions,unsigned int vertAttribIndex,GLboolean normalized,const Array* attribcoords,const IndexArray* indices):
             _vertAttribIndex(vertAttribIndex),
             _normalized(normalized),
@@ -337 +338 @@
         virtual void apply(const Vec4& v)   { _extensions->glMultiTexCoord4fv(_target,v.ptr()); }
         
-        GLenum _target;
+        GLenum              _target;
         const Array*        _texcoords;
         const IndexArray*   _indices;
@@ -413 +414 @@
 Geometry::Geometry()
 {
+    // temporary test
+    // setSupportsDisplayList(false);
+
     _fastPath = false;
     _fastPathHint = true;
@@ -427 +431 @@
     _fastPathHint(geometry._fastPathHint)
 {
+    // temporary test
+    // setSupportsDisplayList(false);
+
     for(PrimitiveSetList::const_iterator pitr=geometry._primitives.begin();
         pitr!=geometry._primitives.end();
@@ -1273 +1280 @@
 }
 
+#if 1
 void Geometry::drawImplementation(RenderInfo& renderInfo) const
 {
     State& state = *renderInfo.getState();
     bool vertexAttribAlias = state.getUseVertexAttributeAliasing();
+    Drawable::Extensions* extensions = Drawable::getExtensions(state.getContextID(),true);
+
+    bool useFastPath = areFastPathsUsed();
+    bool usingVertexBufferObjects = _useVertexBufferObjects && state.isVertexBufferObjectSupported();
+    bool handleVertexAttributes = !_vertexAttribList.empty() && extensions->isVertexProgramSupported();
+
+    osg::ref_ptr<ArrayDispatchers> s_ArrayDispatchers = 0;
+    if (!s_ArrayDispatchers) s_ArrayDispatchers = new ArrayDispatchers(state);
+
+    ArrayDispatchers& arrayDispatchers = *s_ArrayDispatchers;
+
+    arrayDispatchers.reset();
+    arrayDispatchers.setUseGLBeginEndAdapter(!useFastPath);
+
+    arrayDispatchers.activateNormalArray(_normalData.binding, _normalData.array.get(), _normalData.indices.get());
+    arrayDispatchers.activateColorArray(_colorData.binding, _colorData.array.get(), _colorData.indices.get());
+    arrayDispatchers.activateSecondaryColorArray(_secondaryColorData.binding, _secondaryColorData.array.get(), _secondaryColorData.indices.get());
+    arrayDispatchers.activateFogCoordArray(_fogCoordData.binding, _fogCoordData.array.get(), _fogCoordData.indices.get());
+
+    for(unsigned int unit=0;unit<_texCoordList.size();++unit)
+    {
+        arrayDispatchers.activateTexCoordArray(BIND_PER_VERTEX, unit, _texCoordList[unit].array.get(), _texCoordList[unit].indices.get());
+    }
+
+    for(unsigned int unit=0;unit<_vertexAttribList.size();++unit)
+    {
+        arrayDispatchers.activateVertexAttribArray(_vertexAttribList[unit].binding, unit, _vertexAttribList[unit].array.get(), _vertexAttribList[unit].indices.get());
+    }
+
+    arrayDispatchers.activateVertexArray(BIND_PER_VERTEX, _vertexData.array.get(), _vertexData.indices.get());
+
+
+    // dispatch any attributes that are bound overall
+    arrayDispatchers.dispatch(BIND_OVERALL);
+
+    state.lazyDisablingOfVertexAttributes();
+
+    if (useFastPath)
+    {
+        // set up arrays
+        if( _vertexData.array.valid() )
+            state.setVertexPointer(_vertexData.array.get());
+
+        if (_normalData.binding==BIND_PER_VERTEX && _normalData.array.valid())
+            state.setNormalPointer(_normalData.array.get());
+
+        if (_colorData.binding==BIND_PER_VERTEX && _colorData.array.valid())
+            state.setColorPointer(_colorData.array.get());
+
+        if (_secondaryColorData.binding==BIND_PER_VERTEX && _secondaryColorData.array.valid())
+            state.setSecondaryColorPointer(_secondaryColorData.array.get());
+
+        if (_fogCoordData.binding==BIND_PER_VERTEX && _fogCoordData.array.valid())
+            state.setFogCoordPointer(_fogCoordData.array.get());
+
+        for(unsigned int unit=0;unit<_texCoordList.size();++unit)
+        {
+            const Array* array = _texCoordList[unit].array.get();
+            if (array) state.setTexCoordPointer(unit,array);
+        }
+
+        if( handleVertexAttributes )
+        {
+            for(unsigned int index = 0; index < _vertexAttribList.size(); ++index )
+            {
+                const Array* array = _vertexAttribList[index].array.get();
+                const AttributeBinding ab = _vertexAttribList[index].binding;
+                if( ab == BIND_PER_VERTEX && array )
+                {
+                    state.setVertexAttribPointer( index, array, _vertexAttribList[index].normalize );
+                }
+            }
+        }
+    }
+
+    state.applyDisablingOfVertexAttributes();
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //
+    // draw the primitives themselves.
+    //
+    for(PrimitiveSetList::const_iterator itr=_primitives.begin();
+        itr!=_primitives.end();
+        ++itr)
+    {
+        // dispatch any attributes that are bound per primitive
+        arrayDispatchers.dispatch(BIND_PER_PRIMITIVE_SET);
+
+        const PrimitiveSet* primitiveset = itr->get();
+
+        if (useFastPath)
+        {
+            primitiveset->draw(state, usingVertexBufferObjects);
+        }
+        else
+        {
+            GLenum mode=primitiveset->getMode();
+
+            unsigned int primLength;
+            switch(mode)
+            {
+                case(GL_POINTS):    primLength=1; break;
+                case(GL_LINES):     primLength=2; break;
+                case(GL_TRIANGLES): primLength=3; break;
+                case(GL_QUADS):     primLength=4; break;
+                default:            primLength=0; break; // compute later when =0.
+            }
+
+            // draw primitives by the more flexible "slow" path,
+            // sending OpenGL glBegin/glVertex.../glEnd().
+            switch(primitiveset->getType())
+            {
+                case(PrimitiveSet::DrawArraysPrimitiveType):
+                {
+                    if (primLength==0) primLength=primitiveset->getNumIndices();
+
+                    const DrawArrays* drawArray = static_cast<const DrawArrays*>(primitiveset);
+                    arrayDispatchers.Begin(mode);
+
+                    unsigned int primCount=0;
+                    unsigned int indexEnd = drawArray->getFirst()+drawArray->getCount();
+                    for(unsigned int vindex=drawArray->getFirst();
+                        vindex<indexEnd;
+                        ++vindex,++primCount)
+                    {
+                        if ((primCount%primLength)==0)
+                        {
+                            arrayDispatchers.dispatch(BIND_PER_PRIMITIVE);
+                        }
+
+                        arrayDispatchers.dispatch(BIND_PER_VERTEX, vindex);
+                    }
+
+                    arrayDispatchers.End();
+                    break;
+                }
+                case(PrimitiveSet::DrawArrayLengthsPrimitiveType):
+                {
+                    const DrawArrayLengths* drawArrayLengths = static_cast<const DrawArrayLengths*>(primitiveset);
+                    unsigned int vindex=drawArrayLengths->getFirst();
+                    for(DrawArrayLengths::const_iterator primItr=drawArrayLengths->begin();
+                        primItr!=drawArrayLengths->end();
+                        ++primItr)
+                    {
+                        unsigned int localPrimLength;
+                        if (primLength==0) localPrimLength=*primItr;
+                        else localPrimLength=primLength;
+
+                        arrayDispatchers.Begin(mode);
+
+                        for(GLsizei primCount=0;
+                            primCount<*primItr;
+                            ++vindex,++primCount)
+                        {
+                            if ((primCount%localPrimLength)==0)
+                            {
+                                arrayDispatchers.dispatch(BIND_PER_PRIMITIVE);
+                            }
+                            arrayDispatchers.dispatch(BIND_PER_VERTEX, vindex);
+                        }
+
+                        arrayDispatchers.End();
+
+                    }
+                    break;
+                }
+                case(PrimitiveSet::DrawElementsUBytePrimitiveType):
+                {
+                    if (primLength==0) primLength=primitiveset->getNumIndices();
+
+                    const DrawElementsUByte* drawElements = static_cast<const DrawElementsUByte*>(primitiveset);
+                    arrayDispatchers.Begin(mode);
+
+                    unsigned int primCount=0;
+                    for(DrawElementsUByte::const_iterator primItr=drawElements->begin();
+                        primItr!=drawElements->end();
+                        ++primCount,++primItr)
+                    {
+
+                        if ((primCount%primLength)==0)
+                        {
+                            arrayDispatchers.dispatch(BIND_PER_PRIMITIVE);
+                        }
+
+                        unsigned int vindex=*primItr;
+                        arrayDispatchers.dispatch(BIND_PER_VERTEX, vindex);
+                    }
+
+                    arrayDispatchers.End();
+                    break;
+                }
+                case(PrimitiveSet::DrawElementsUShortPrimitiveType):
+                {
+                    if (primLength==0) primLength=primitiveset->getNumIndices();
+
+                    const DrawElementsUShort* drawElements = static_cast<const DrawElementsUShort*>(primitiveset);
+                    arrayDispatchers.Begin(mode);
+
+                    unsigned int primCount=0;
+                    for(DrawElementsUShort::const_iterator primItr=drawElements->begin();
+                        primItr!=drawElements->end();
+                        ++primCount,++primItr)
+                    {
+                        if ((primCount%primLength)==0)
+                        {
+                            arrayDispatchers.dispatch(BIND_PER_PRIMITIVE);
+                        }
+
+                        unsigned int vindex=*primItr;
+                        arrayDispatchers.dispatch(BIND_PER_VERTEX, vindex);
+                    }
+
+                    arrayDispatchers.End();
+                    break;
+                }
+                case(PrimitiveSet::DrawElementsUIntPrimitiveType):
+                {
+                    if (primLength==0) primLength=primitiveset->getNumIndices();
+
+                    const DrawElementsUInt* drawElements = static_cast<const DrawElementsUInt*>(primitiveset);
+                    arrayDispatchers.Begin(mode);
+
+                    unsigned int primCount=0;
+                    for(DrawElementsUInt::const_iterator primItr=drawElements->begin();
+                        primItr!=drawElements->end();
+                        ++primCount,++primItr)
+                    {
+                        if ((primCount%primLength)==0)
+                        {
+                            arrayDispatchers.dispatch(BIND_PER_PRIMITIVE);
+                        }
+
+                        unsigned int vindex=*primItr;
+                        arrayDispatchers.dispatch(BIND_PER_VERTEX, vindex);
+                    }
+
+                    arrayDispatchers.End();
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    }
+}
+#else
+void Geometry::drawImplementation(RenderInfo& renderInfo) const
+{
+    State& state = *renderInfo.getState();
+    bool vertexAttribAlias = state.getUseVertexAttributeAliasing();
+
 
 //    unsigned int contextID = state.getContextID();
@@ -1339 +1600 @@
 
 
+
     unsigned int normalIndex = 0;
     unsigned int colorIndex = 0;
@@ -1367 +1629 @@
         if (normalBinding!=BIND_OFF && normalBinding!=BIND_PER_VERTEX)
         { 
-            osg::notify(osg::NOTICE)<<"normal assign"<<std::endl;
             drawVertexAttribMap[normalBinding].push_back( new DrawVertexAttrib(extensions,2,false,_normalData.array.get(),_normalData.indices.get()) );
             normalBinding = BIND_OFF;
@@ -1374 +1635 @@
         if (colorBinding!=BIND_OFF && colorBinding!=BIND_PER_VERTEX)
         {
-            osg::notify(osg::NOTICE)<<"color assign"<<std::endl;
             drawVertexAttribMap[colorBinding].push_back( new DrawVertexAttrib(extensions,3,false,_colorData.array.get(),_colorData.indices.get()) );
             colorBinding = BIND_OFF;
@@ -1383 +1643 @@
     }
 
-
-    if (areFastPathsUsed())
+    // force the use of the slow path code to test the glBegin/glEnd replacement codes.
+    bool forceSlowPath = false;
+
+    if (areFastPathsUsed() && !forceSlowPath)
     {
 
@@ -1815 +2077 @@
             }
 
-
             // draw primitives by the more flexible "slow" path,
             // sending OpenGL glBegin/glVertex.../glEnd().
@@ -2168 +2429 @@
 
 }
+#endif
 
 class AttributeFunctorArrayVisitor : public ArrayVisitor