Added dirty methods for vertex arrays to better support external OpenGL

code which modifies the OpenGL state and needs to tell the osg::State about it to ensure that the OSG doesn't make any errors during lazy state updating.
2002-09-13 13:50:58 +00:00
parent ee93b70033
commit 6d21fbd6cf
2 changed files with 119 additions and 28 deletions
--- a/include/osg/State
+++ b/include/osg/State
@@ -215,91 +215,117 @@ class SG_EXPORT State : public Referenced
        const StateAttribute* getLastAppliedTextureAttribute(unsigned int unit, StateAttribute::Type type) const;


+        /** disable the vertex, normal, color, tex coords, secenday color, fog coord and index arrays.*/
+        void disableAllVertexArrays();
+
+        /** dirty the vertex, normal, color, tex coords, secenday color, fog coord and index arrays.*/
+        void dirtyAllVertexArrays();

        /** wrapper around glEnableClientState(GL_VERTEX_ARRAY);glVertexPointer(..);
          * note, only updates values that change.*/
        inline void setVertexPointer( GLint size, GLenum type,
                                      GLsizei stride, const GLvoid *ptr )
        {
-            if (!_vertexArray._enabled)
+            if (!_vertexArray._enabled || _vertexArray._dirty)
            {
                _vertexArray._enabled = true;
                glEnableClientState(GL_VERTEX_ARRAY);
            }
-            if (_vertexArray._pointer!=ptr)
+            if (_vertexArray._pointer!=ptr || _vertexArray._dirty)
            {
                _vertexArray._pointer=ptr;
                glVertexPointer( size, type, stride, ptr );
            }
+            _vertexArray._dirty = false;
        }
        
        /** wrapper glDisableClientState(GL_VERTEX_ARRAY).
          * note, only updates values that change.*/
        inline void disableVertexPointer()
        {
-            if (_vertexArray._enabled)
+            if (_vertexArray._enabled || _vertexArray._dirty)
            {
                _vertexArray._enabled = false;
+                _vertexArray._dirty = false;
                glDisableClientState(GL_VERTEX_ARRAY);
            }
        }

+        inline void dirtyVertexPointer()
+        {
+            _vertexArray._dirty = true; 
+        }
+
        /** wrapper around glEnableClientState(GL_NORMAL_ARRAY);glNormalPointer(..);
          * note, only updates values that change.*/
        inline void setNormalPointer( GLenum type, GLsizei stride,
                                      const GLvoid *ptr )
        {
-            if (!_normalArray._enabled)
+            if (!_normalArray._enabled || _normalArray._dirty)
            {
                _normalArray._enabled = true;
                glEnableClientState(GL_NORMAL_ARRAY);
            }
-            if (_normalArray._pointer!=ptr)
+            if (_normalArray._pointer!=ptr || _normalArray._dirty)
            {
                _normalArray._pointer=ptr;
                glNormalPointer( type, stride, ptr );
            }
+            _normalArray._dirty = false;
        }

        /** wrapper around glDisableClientState(GL_NORMAL_ARRAY);
          * note, only updates values that change.*/
        inline void disableNormalPointer()
        {
-            if (_normalArray._enabled)
+            if (_normalArray._enabled || _normalArray._dirty)
            {
                _normalArray._enabled = false;
+                _normalArray._dirty = false;
                glDisableClientState(GL_NORMAL_ARRAY);
            }
        }

+        inline void dirtyNormalPointer()
+        {
+            _normalArray._dirty = true;
+        }
+
        /** wrapper around glEnableClientState(GL_COLOR_ARRAY);glColorPointer(..);
          * note, only updates values that change.*/
        inline void setColorPointer( GLint size, GLenum type,
                                     GLsizei stride, const GLvoid *ptr )
        {
-            if (!_colorArray._enabled)
+            if (!_colorArray._enabled || _colorArray._dirty)
            {
                _colorArray._enabled = true;
                glEnableClientState(GL_COLOR_ARRAY);
            }
-            if (_colorArray._pointer!=ptr)
+            if (_colorArray._pointer!=ptr || _colorArray._dirty)
            {
                _colorArray._pointer=ptr;
                glColorPointer( size, type, stride, ptr );
            }
+            _colorArray._dirty = false;
        }

        /** wrapper around glDisableClientState(GL_COLOR_ARRAY);
          * note, only updates values that change.*/
        inline void disableColorPointer()
        {
-            if (_colorArray._enabled)
+            if (_colorArray._enabled || _colorArray._dirty)
            {
                _colorArray._enabled = false;
+                _colorArray._dirty = false;
                glDisableClientState(GL_COLOR_ARRAY);
            }
        }

+        inline void dirtyColorPointer()
+        {
+            _colorArray._dirty = true;
+        }
+
        /** wrapper around glEnableClientState(GL_SECONDARY_COLOR_ARRAY);glSecondayColorPointer(..);
          * note, only updates values that change.*/
        void setSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *ptr );
@@ -308,41 +334,55 @@ class SG_EXPORT State : public Referenced
          * note, only updates values that change.*/
        inline void disableSecondaryColorPointer()
        {
-            if (_secondaryColorArray._enabled)
+            if (_secondaryColorArray._enabled || _secondaryColorArray._dirty)
            {
                _secondaryColorArray._enabled = false;
+                _secondaryColorArray._dirty = false;
                glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
            }
        }

+        inline void dirtySecondaryColorPointer()
+        {
+            _secondaryColorArray._dirty = true;
+        }
+
        /** wrapper around glEnableClientState(GL_INDEX_ARRAY);glIndexPointer(..);
          * note, only updates values that change.*/
        inline void setIndexPointer( GLenum type, GLsizei stride,
                              const GLvoid *ptr )
        {
-            if (!_indexArray._enabled)
+            if (!_indexArray._enabled || _indexArray._dirty)
            {
                _indexArray._enabled = true;
                glEnableClientState(GL_INDEX_ARRAY);
            }
-            if (_indexArray._pointer!=ptr)
+            if (_indexArray._pointer!=ptr || _indexArray._dirty)
            {
                _indexArray._pointer=ptr;
                glIndexPointer( type, stride, ptr );
            }
+            _indexArray._dirty = false;
        }

        /** wrapper around glDisableClientState(GL_INDEX_ARRAY);
          * note, only updates values that change.*/
        inline void disableIndexPointer()
        {
-            if (_indexArray._enabled)
+            if (_indexArray._enabled || _indexArray._dirty)
            {
                _indexArray._enabled = false;
+                _indexArray._dirty = false;
                glDisableClientState(GL_INDEX_ARRAY);
            }
        }

+        inline void dirtyIndexPointer()
+        {
+            _indexArray._dirty = true;
+        }
+
+
        /** wrapper around glEnableClientState(GL_FOG_COORDINATE_ARRAY);glFogCoordPointer(..);
          * note, only updates values that change.*/
        void setFogCoordPointer( GLenum type, GLsizei stride, const GLvoid *ptr );
@@ -351,14 +391,19 @@ class SG_EXPORT State : public Referenced
          * note, only updates values that change.*/
        inline void disableFogCoordPointer()
        {
-            if (_fogArray._enabled)
+            if (_fogArray._enabled || _fogArray._dirty)
            {
                _fogArray._enabled = false;
+                _fogArray._dirty = false;
                glDisableClientState(GL_FOG_COORDINATE_ARRAY);
            }
        }

-        
+        inline void dirtyFogCoordPointer()
+        {
+            _fogArray._dirty = true;
+        }
+

        /** wrapper around glEnableClientState(GL_TEXTURE_COORD_ARRAY);glTexCoordPointer(..);
          * note, only updates values that change.*/
@@ -371,16 +416,17 @@ class SG_EXPORT State : public Referenced
                if ( unit >= _texCoordArrayList.size()) _texCoordArrayList.resize(unit+1);
                EnabledArrayPair& eap = _texCoordArrayList[unit];

-                if (!eap._enabled)
+                if (!eap._enabled || eap._dirty)
                {
                    eap._enabled = true;
                    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
                }
-                if (eap._pointer!=ptr)
+                if (eap._pointer!=ptr || eap._dirty)
                {
                    glTexCoordPointer( size, type, stride, ptr );
                    eap._pointer = ptr;
                }
+                eap._dirty = false;
            }
        }
        
@@ -393,24 +439,34 @@ class SG_EXPORT State : public Referenced
                if ( unit >= _texCoordArrayList.size()) _texCoordArrayList.resize(unit+1);
                EnabledArrayPair& eap = _texCoordArrayList[unit];

-                if (eap._enabled)
+                if (eap._enabled || eap._dirty)
                {
                    eap._enabled = false;
+                    eap._dirty = false;
                    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
                }
            }
        }

+        inline void dirtyTexCoordPointer( unsigned int unit )
+        {
+            if ( unit >= _texCoordArrayList.size()) return; // _texCoordArrayList.resize(unit+1);
+            EnabledArrayPair& eap = _texCoordArrayList[unit];
+            eap._dirty = true;
+        }
+
+
        inline void disableTexCoordPointersAboveAndIncluding( unsigned int unit )
        {
            while (unit<_texCoordArrayList.size())
            {
                EnabledArrayPair& eap = _texCoordArrayList[unit];
-                if (eap._enabled)
+                if (eap._enabled || eap._dirty)
                {
                    if (setClientActiveTextureUnit(unit))
                    {
                        eap._enabled = false;
+                        eap._dirty = false;
                        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
                    }
                }
@@ -418,6 +474,16 @@ class SG_EXPORT State : public Referenced
            }
        }

+        inline void dirtyTexCoordPointersAboveAndIncluding( unsigned int unit )
+        {
+            while (unit<_texCoordArrayList.size())
+            {
+                EnabledArrayPair& eap = _texCoordArrayList[unit];
+                eap._dirty = true;
+                ++unit;
+            }
+        }
+
        /** set the current tex coord array texture unit, return true if selected, false if selection failed such as when multitexturing is not supported.
          * note, only updates values that change.*/
        bool setClientActiveTextureUnit( unsigned int unit );
@@ -568,12 +634,13 @@ class SG_EXPORT State : public Referenced
        
        struct EnabledArrayPair
        {
-            EnabledArrayPair():_enabled(false),_pointer(0) {}
-            EnabledArrayPair(const EnabledArrayPair& eap):_enabled(eap._enabled),_pointer(eap._pointer) {}
-            EnabledArrayPair& operator = (const EnabledArrayPair& eap) { _enabled=eap._enabled; _pointer=eap._pointer; return *this; }
+            EnabledArrayPair():_dirty(true),_enabled(false),_pointer(0) {}
+            EnabledArrayPair(const EnabledArrayPair& eap):_dirty(eap._dirty), _enabled(eap._enabled),_pointer(eap._pointer) {}
+            EnabledArrayPair& operator = (const EnabledArrayPair& eap) { _dirty=eap._dirty; _enabled=eap._enabled; _pointer=eap._pointer; return *this; }
            
-            bool          _enabled;
-            const GLvoid* _pointer;
+            bool            _dirty;
+            bool            _enabled;
+            const GLvoid*   _pointer;
        };
        
        typedef std::vector<EnabledArrayPair>                   EnabledTexCoordArrayList;
--- a/src/osg/State.cpp
+++ b/src/osg/State.cpp
@@ -396,6 +396,28 @@ Polytope State::getViewFrustum() const
    return cv;
 }

+void State::disableAllVertexArrays()
+{
+    disableVertexPointer();
+    disableTexCoordPointersAboveAndIncluding(0);
+    disableColorPointer();
+    disableFogCoordPointer();
+    disableIndexPointer();
+    disableNormalPointer();
+    disableSecondaryColorPointer();
+}
+
+void State::dirtyAllVertexArrays()
+{
+    dirtyVertexPointer();
+    dirtyTexCoordPointersAboveAndIncluding(0);
+    dirtyColorPointer();
+    dirtyFogCoordPointer();
+    dirtyIndexPointer();
+    dirtyNormalPointer();
+    dirtySecondaryColorPointer();
+}
+
 typedef void (APIENTRY * ActiveTextureProc) (GLenum texture);

 bool State::setClientActiveTextureUnit( unsigned int unit )
@@ -450,16 +472,17 @@ void State::setFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
    if (s_glFogCoordPointer)
    {

-        if (!_fogArray._enabled)
+        if (!_fogArray._enabled || _fogArray._dirty)
        {
            _fogArray._enabled = true;
            glEnableClientState(GL_FOG_COORDINATE_ARRAY);
        }
-        if (_fogArray._pointer!=ptr)
+        if (_fogArray._pointer!=ptr || _fogArray._dirty)
        {
            _fogArray._pointer=ptr;
            s_glFogCoordPointer( type, stride, ptr );
        }
+        _fogArray._dirty = false;
    }
    
 }
@@ -473,15 +496,16 @@ void State::setSecondaryColorPointer( GLint size, GLenum type,

    if (s_glSecondaryColorPointer)
    {
-        if (!_secondaryColorArray._enabled)
+        if (!_secondaryColorArray._enabled || _secondaryColorArray._dirty)
        {
            _secondaryColorArray._enabled = true;
            glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
        }
-        if (_secondaryColorArray._pointer!=ptr)
+        if (_secondaryColorArray._pointer!=ptr || _secondaryColorArray._dirty)
        {
            _secondaryColorArray._pointer=ptr;
            s_glSecondaryColorPointer( size, type, stride, ptr );
        }
+        _secondaryColorArray._dirty = false;
    }
 }