From 8f81cf2ac6a7cbd1f49d4ae89dc5edd093baf0af Mon Sep 17 00:00:00 2001
From: Robert Osfield <robert@openscenegraph.com>
Date: Mon, 16 Dec 2002 17:00:05 +0000
Subject: [PATCH] Moved TriangleFunctor from Drawable into its own header file.

---
 include/osg/Drawable                  | 321 ------------------------
 include/osg/TriangleFunctor           | 336 ++++++++++++++++++++++++++
 src/Demos/osggeometry/osggeometry.cpp |   1 +
 src/osgUtil/IntersectVisitor.cpp      |   1 +
 src/osgUtil/SmoothingVisitor.cpp      |   2 +
 src/osgUtil/TriStripVisitor.cpp       |   2 +-
 6 files changed, 341 insertions(+), 322 deletions(-)
 create mode 100644 include/osg/TriangleFunctor

diff --git a/include/osg/Drawable b/include/osg/Drawable
index e17ecd98f..8d7456339 100644
--- a/include/osg/Drawable
+++ b/include/osg/Drawable
@@ -439,327 +439,6 @@ inline void Drawable::draw(State& state)
     }
 };
 
-template<class T>
-class TriangleFunctor : public Drawable::PrimitiveFunctor, public T
-{
-public:
-
-    TriangleFunctor()
-    {
-        _vertexArraySize=0;
-        _vertexArrayPtr=0;
-        _modeCache=0;
-    }
-    
-    virtual ~TriangleFunctor() {}
-
-    virtual void setVertexArray(unsigned int count,const Vec3* vertices)
-    {
-        _vertexArraySize = count;
-        _vertexArrayPtr = vertices;
-    }
-
-    virtual void drawArrays(GLenum mode,GLint first,GLsizei count)
-    {
-        if (_vertexArrayPtr==0 && count==0) return;
-    
-        switch(mode)
-        {
-            case(GL_TRIANGLES):
-            {
-                const Vec3* vlast = &_vertexArrayPtr[first+count];
-                for(const Vec3* vptr=&_vertexArrayPtr[first];vptr<vlast;vptr+=3)
-                    operator()(*(vptr),*(vptr+1),*(vptr+2));
-                break;
-            }
-            case(GL_TRIANGLE_STRIP):
-            {
-                const Vec3* vptr = &_vertexArrayPtr[first];
-                for(GLsizei i=2;i<count;++i,++vptr)
-                {
-		    if ((i%2)) operator()(*(vptr),*(vptr+2),*(vptr+1));
-		    else       operator()(*(vptr),*(vptr+1),*(vptr+2));
-                }
-                break;
-            }
-            case(GL_QUADS):
-            {
-                const Vec3* vptr = &_vertexArrayPtr[first];
-                for(GLsizei i=3;i<count;i+=4,vptr+=4)
-                {
-                    operator()(*(vptr),*(vptr+1),*(vptr+2));
-                    operator()(*(vptr),*(vptr+2),*(vptr+3));
-                }
-                break;
-            }
-            case(GL_QUAD_STRIP):
-            {
-                const Vec3* vptr = &_vertexArrayPtr[first];
-                for(GLsizei i=3;i<count;i+=2,vptr+=2)
-                {
-                    operator()(*(vptr),*(vptr+1),*(vptr+2));
-                    operator()(*(vptr+1),*(vptr+3),*(vptr+2));
-                }
-                break;
-            }
-            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
-            case(GL_TRIANGLE_FAN):
-            {
-                const Vec3* vfirst = &_vertexArrayPtr[first];
-                const Vec3* vptr = vfirst+1;
-                for(GLsizei i=2;i<count;++i,++vptr)
-                {
-                    operator()(*(vfirst),*(vptr),*(vptr+1));
-                }
-                break;
-            }
-            case(GL_POINTS):
-            case(GL_LINES):
-            case(GL_LINE_STRIP):
-            case(GL_LINE_LOOP):
-            default:
-                // can't be converted into to triangles.
-                break;
-        }
-    }
-    
-    virtual void drawElements(GLenum mode,GLsizei count,const GLubyte* indices)
-    {
-        if (indices==0 || count==0) return;
-    
-        typedef const GLubyte* IndexPointer;
-    
-        switch(mode)
-        {
-            case(GL_TRIANGLES):
-            {
-                IndexPointer ilast = &indices[count];
-                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
-                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                break;
-            }
-            case(GL_TRIANGLE_STRIP):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=2;i<count;++i,++iptr)
-                {
-		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
-		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                }
-                break;
-            }
-            case(GL_QUADS):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=3;i<count;i+=4,iptr+=4)
-                {
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
-                }
-                break;
-            }
-            case(GL_QUAD_STRIP):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=3;i<count;i+=2,iptr+=2)
-                {
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
-                }
-                break;
-            }
-            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
-            case(GL_TRIANGLE_FAN):
-            {
-                IndexPointer iptr = indices;
-                const Vec3& vfirst = _vertexArrayPtr[*iptr];
-                ++iptr;
-                for(GLsizei i=2;i<count;++i,++iptr)
-                {
-                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
-                }
-                break;
-            }
-            case(GL_POINTS):
-            case(GL_LINES):
-            case(GL_LINE_STRIP):
-            case(GL_LINE_LOOP):
-            default:
-                // can't be converted into to triangles.
-                break;
-        }
-    }    
-
-    virtual void drawElements(GLenum mode,GLsizei count,const GLushort* indices)
-    {
-        if (indices==0 || count==0) return;
-    
-        typedef const GLushort* IndexPointer;
-    
-        switch(mode)
-        {
-            case(GL_TRIANGLES):
-            {
-                IndexPointer ilast = &indices[count];
-                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
-                {
-                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                }    
-                break;
-            }
-            case(GL_TRIANGLE_STRIP):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=2;i<count;++i,++iptr)
-                {
-		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
-		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                }
-                break;
-            }
-            case(GL_QUADS):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=3;i<count;i+=4,iptr+=4)
-                {
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
-                }
-                break;
-            }
-            case(GL_QUAD_STRIP):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=3;i<count;i+=2,iptr+=2)
-                {
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
-                }
-                break;
-            }
-            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
-            case(GL_TRIANGLE_FAN):
-            {
-                IndexPointer iptr = indices;
-                const Vec3& vfirst = _vertexArrayPtr[*iptr];
-                ++iptr;
-                for(GLsizei i=2;i<count;++i,++iptr)
-                {
-                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
-                }
-                break;
-            }
-            case(GL_POINTS):
-            case(GL_LINES):
-            case(GL_LINE_STRIP):
-            case(GL_LINE_LOOP):
-            default:
-                // can't be converted into to triangles.
-                break;
-        }
-    }    
-
-    virtual void drawElements(GLenum mode,GLsizei count,const GLuint* indices)
-    {
-        if (indices==0 || count==0) return;
-    
-        typedef const GLuint* IndexPointer;
-    
-        switch(mode)
-        {
-            case(GL_TRIANGLES):
-            {
-                IndexPointer ilast = &indices[count];
-                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
-                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                break;
-            }
-            case(GL_TRIANGLE_STRIP):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=2;i<count;++i,++iptr)
-                {
-		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
-		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                }
-                break;
-            }
-            case(GL_QUADS):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=3;i<count;i+=4,iptr+=4)
-                {
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
-                }
-                break;
-            }
-            case(GL_QUAD_STRIP):
-            {
-                IndexPointer iptr = indices;
-                for(GLsizei i=3;i<count;i+=2,iptr+=2)
-                {
-                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
-                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
-                }
-                break;
-            }
-            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
-            case(GL_TRIANGLE_FAN):
-            {
-                IndexPointer iptr = indices;
-                const Vec3& vfirst = _vertexArrayPtr[*iptr];
-                ++iptr;
-                for(GLsizei i=2;i<count;++i,++iptr)
-                {
-                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
-                }
-                break;
-            }
-            case(GL_POINTS):
-            case(GL_LINES):
-            case(GL_LINE_STRIP):
-            case(GL_LINE_LOOP):
-            default:
-                // can't be converted into to triangles.
-                break;
-        }
-    }    
-
-
-
-    /** begin(..),vertex(..) & end() are convinience methods for adapting 
-     *  non vertex array primitives to vertex array based primitives.
-     * this is done to simplify the implementation of primtive functor
-     * subclasses - users only need override drawArray and drawElements.*/
-    inline void begin(GLenum mode)
-    {
-        _modeCache = mode;
-        _vertexCache.clear();
-    }
-
-    inline void vertex(const Vec3& vert) { _vertexCache.push_back(vert); }
-    inline void vertex(float x,float y,float z) { _vertexCache.push_back(osg::Vec3(x,y,z)); }
-    inline void end()
-    {
-        if (!_vertexCache.empty())
-        {
-            setVertexArray(_vertexCache.size(),&_vertexCache.front());
-            drawArrays(_modeCache,0,_vertexCache.size());
-        }
-    }
-
-protected:
-
-
-    unsigned int        _vertexArraySize;
-    const Vec3*         _vertexArrayPtr;
-
-    GLenum              _modeCache;
-    std::vector<Vec3>   _vertexCache;
-
-};
-
 
 }
 
diff --git a/include/osg/TriangleFunctor b/include/osg/TriangleFunctor
new file mode 100644
index 000000000..9405096cd
--- /dev/null
+++ b/include/osg/TriangleFunctor
@@ -0,0 +1,336 @@
+//C++ header - Open Scene Graph - Copyright (C) 1998-2002 Robert Osfield
+//Distributed under the terms of the GNU Library General Public License (LGPL)
+//as published by the Free Software Foundation.
+
+#ifndef OSG_TRIANGLEFUNCTOR
+#define OSG_TRIANGLEFUNCTOR 1
+
+#include <osg/Drawable>
+
+namespace osg {
+
+template<class T>
+class TriangleFunctor : public Drawable::PrimitiveFunctor, public T
+{
+public:
+
+    TriangleFunctor()
+    {
+        _vertexArraySize=0;
+        _vertexArrayPtr=0;
+        _modeCache=0;
+    }
+    
+    virtual ~TriangleFunctor() {}
+
+    virtual void setVertexArray(unsigned int count,const Vec3* vertices)
+    {
+        _vertexArraySize = count;
+        _vertexArrayPtr = vertices;
+    }
+
+    virtual void drawArrays(GLenum mode,GLint first,GLsizei count)
+    {
+        if (_vertexArrayPtr==0 && count==0) return;
+    
+        switch(mode)
+        {
+            case(GL_TRIANGLES):
+            {
+                const Vec3* vlast = &_vertexArrayPtr[first+count];
+                for(const Vec3* vptr=&_vertexArrayPtr[first];vptr<vlast;vptr+=3)
+                    operator()(*(vptr),*(vptr+1),*(vptr+2));
+                break;
+            }
+            case(GL_TRIANGLE_STRIP):
+            {
+                const Vec3* vptr = &_vertexArrayPtr[first];
+                for(GLsizei i=2;i<count;++i,++vptr)
+                {
+		    if ((i%2)) operator()(*(vptr),*(vptr+2),*(vptr+1));
+		    else       operator()(*(vptr),*(vptr+1),*(vptr+2));
+                }
+                break;
+            }
+            case(GL_QUADS):
+            {
+                const Vec3* vptr = &_vertexArrayPtr[first];
+                for(GLsizei i=3;i<count;i+=4,vptr+=4)
+                {
+                    operator()(*(vptr),*(vptr+1),*(vptr+2));
+                    operator()(*(vptr),*(vptr+2),*(vptr+3));
+                }
+                break;
+            }
+            case(GL_QUAD_STRIP):
+            {
+                const Vec3* vptr = &_vertexArrayPtr[first];
+                for(GLsizei i=3;i<count;i+=2,vptr+=2)
+                {
+                    operator()(*(vptr),*(vptr+1),*(vptr+2));
+                    operator()(*(vptr+1),*(vptr+3),*(vptr+2));
+                }
+                break;
+            }
+            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
+            case(GL_TRIANGLE_FAN):
+            {
+                const Vec3* vfirst = &_vertexArrayPtr[first];
+                const Vec3* vptr = vfirst+1;
+                for(GLsizei i=2;i<count;++i,++vptr)
+                {
+                    operator()(*(vfirst),*(vptr),*(vptr+1));
+                }
+                break;
+            }
+            case(GL_POINTS):
+            case(GL_LINES):
+            case(GL_LINE_STRIP):
+            case(GL_LINE_LOOP):
+            default:
+                // can't be converted into to triangles.
+                break;
+        }
+    }
+    
+    virtual void drawElements(GLenum mode,GLsizei count,const GLubyte* indices)
+    {
+        if (indices==0 || count==0) return;
+    
+        typedef const GLubyte* IndexPointer;
+    
+        switch(mode)
+        {
+            case(GL_TRIANGLES):
+            {
+                IndexPointer ilast = &indices[count];
+                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
+                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                break;
+            }
+            case(GL_TRIANGLE_STRIP):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=2;i<count;++i,++iptr)
+                {
+		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
+		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                }
+                break;
+            }
+            case(GL_QUADS):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=3;i<count;i+=4,iptr+=4)
+                {
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
+                }
+                break;
+            }
+            case(GL_QUAD_STRIP):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=3;i<count;i+=2,iptr+=2)
+                {
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
+                }
+                break;
+            }
+            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
+            case(GL_TRIANGLE_FAN):
+            {
+                IndexPointer iptr = indices;
+                const Vec3& vfirst = _vertexArrayPtr[*iptr];
+                ++iptr;
+                for(GLsizei i=2;i<count;++i,++iptr)
+                {
+                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
+                }
+                break;
+            }
+            case(GL_POINTS):
+            case(GL_LINES):
+            case(GL_LINE_STRIP):
+            case(GL_LINE_LOOP):
+            default:
+                // can't be converted into to triangles.
+                break;
+        }
+    }    
+
+    virtual void drawElements(GLenum mode,GLsizei count,const GLushort* indices)
+    {
+        if (indices==0 || count==0) return;
+    
+        typedef const GLushort* IndexPointer;
+    
+        switch(mode)
+        {
+            case(GL_TRIANGLES):
+            {
+                IndexPointer ilast = &indices[count];
+                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
+                {
+                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                }    
+                break;
+            }
+            case(GL_TRIANGLE_STRIP):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=2;i<count;++i,++iptr)
+                {
+		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
+		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                }
+                break;
+            }
+            case(GL_QUADS):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=3;i<count;i+=4,iptr+=4)
+                {
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
+                }
+                break;
+            }
+            case(GL_QUAD_STRIP):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=3;i<count;i+=2,iptr+=2)
+                {
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
+                }
+                break;
+            }
+            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
+            case(GL_TRIANGLE_FAN):
+            {
+                IndexPointer iptr = indices;
+                const Vec3& vfirst = _vertexArrayPtr[*iptr];
+                ++iptr;
+                for(GLsizei i=2;i<count;++i,++iptr)
+                {
+                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
+                }
+                break;
+            }
+            case(GL_POINTS):
+            case(GL_LINES):
+            case(GL_LINE_STRIP):
+            case(GL_LINE_LOOP):
+            default:
+                // can't be converted into to triangles.
+                break;
+        }
+    }    
+
+    virtual void drawElements(GLenum mode,GLsizei count,const GLuint* indices)
+    {
+        if (indices==0 || count==0) return;
+    
+        typedef const GLuint* IndexPointer;
+    
+        switch(mode)
+        {
+            case(GL_TRIANGLES):
+            {
+                IndexPointer ilast = &indices[count];
+                for(IndexPointer  iptr=indices;iptr<ilast;iptr+=3)
+                    operator()(_vertexArrayPtr[*iptr],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                break;
+            }
+            case(GL_TRIANGLE_STRIP):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=2;i<count;++i,++iptr)
+                {
+		    if ((i%2)) operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+1)]);
+		    else       operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                }
+                break;
+            }
+            case(GL_QUADS):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=3;i<count;i+=4,iptr+=4)
+                {
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+2)],_vertexArrayPtr[*(iptr+3)]);
+                }
+                break;
+            }
+            case(GL_QUAD_STRIP):
+            {
+                IndexPointer iptr = indices;
+                for(GLsizei i=3;i<count;i+=2,iptr+=2)
+                {
+                    operator()(_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+2)]);
+                    operator()(_vertexArrayPtr[*(iptr+1)],_vertexArrayPtr[*(iptr+3)],_vertexArrayPtr[*(iptr+2)]);
+                }
+                break;
+            }
+            case(GL_POLYGON): // treat polygons as GL_TRIANGLE_FAN
+            case(GL_TRIANGLE_FAN):
+            {
+                IndexPointer iptr = indices;
+                const Vec3& vfirst = _vertexArrayPtr[*iptr];
+                ++iptr;
+                for(GLsizei i=2;i<count;++i,++iptr)
+                {
+                    operator()(vfirst,_vertexArrayPtr[*(iptr)],_vertexArrayPtr[*(iptr+1)]);
+                }
+                break;
+            }
+            case(GL_POINTS):
+            case(GL_LINES):
+            case(GL_LINE_STRIP):
+            case(GL_LINE_LOOP):
+            default:
+                // can't be converted into to triangles.
+                break;
+        }
+    }    
+
+
+
+    /** begin(..),vertex(..) & end() are convinience methods for adapting 
+     *  non vertex array primitives to vertex array based primitives.
+     * this is done to simplify the implementation of primtive functor
+     * subclasses - users only need override drawArray and drawElements.*/
+    inline void begin(GLenum mode)
+    {
+        _modeCache = mode;
+        _vertexCache.clear();
+    }
+
+    inline void vertex(const Vec3& vert) { _vertexCache.push_back(vert); }
+    inline void vertex(float x,float y,float z) { _vertexCache.push_back(osg::Vec3(x,y,z)); }
+    inline void end()
+    {
+        if (!_vertexCache.empty())
+        {
+            setVertexArray(_vertexCache.size(),&_vertexCache.front());
+            drawArrays(_modeCache,0,_vertexCache.size());
+        }
+    }
+
+protected:
+
+
+    unsigned int        _vertexArraySize;
+    const Vec3*         _vertexArrayPtr;
+
+    GLenum              _modeCache;
+    std::vector<Vec3>   _vertexCache;
+
+};
+
+
+}
+
+#endif
diff --git a/src/Demos/osggeometry/osggeometry.cpp b/src/Demos/osggeometry/osggeometry.cpp
index 3e526c5b6..b37083d18 100644
--- a/src/Demos/osggeometry/osggeometry.cpp
+++ b/src/Demos/osggeometry/osggeometry.cpp
@@ -5,6 +5,7 @@
 #include <osg/MatrixTransform>
 #include <osg/Texture2D>
 #include <osg/PolygonStipple>
+#include <osg/TriangleFunctor>
 
 #include <osgDB/ReadFile>
 #include <osgDB/WriteFile>
diff --git a/src/osgUtil/IntersectVisitor.cpp b/src/osgUtil/IntersectVisitor.cpp
index ddc89c18d..98909c859 100644
--- a/src/osgUtil/IntersectVisitor.cpp
+++ b/src/osgUtil/IntersectVisitor.cpp
@@ -4,6 +4,7 @@
 #include <osg/LOD>
 #include <osg/Billboard>
 #include <osg/Notify>
+#include <osg/TriangleFunctor>
 
 #include <float.h>
 #include <algorithm>
diff --git a/src/osgUtil/SmoothingVisitor.cpp b/src/osgUtil/SmoothingVisitor.cpp
index 26c3ec64c..969c799bf 100644
--- a/src/osgUtil/SmoothingVisitor.cpp
+++ b/src/osgUtil/SmoothingVisitor.cpp
@@ -1,3 +1,5 @@
+#include <osg/TriangleFunctor>
+
 #include <osgUtil/SmoothingVisitor>
 
 #include <stdio.h>
diff --git a/src/osgUtil/TriStripVisitor.cpp b/src/osgUtil/TriStripVisitor.cpp
index 2b399d6cb..898ee2e3e 100644
--- a/src/osgUtil/TriStripVisitor.cpp
+++ b/src/osgUtil/TriStripVisitor.cpp
@@ -1,6 +1,6 @@
-
 #include <osg/Types>
 #include <osg/Notify>
+#include <osg/TriangleFunctor>
 
 #include <osgUtil/TriStripVisitor>