Refactored ShapeDrawable so that it is subclassed from osg::Geometry rather than osg::Drawable.

Created a BuildShapeGeometryVisitor visitor that can create osg::Geometry for osg::Shape objects

include/osg/Shape

@@ -650,6 +650,157 @@ class OSG_EXPORT CompositeShape : public Shape
 
 };
 
+
+/** Describe several hints that can be passed to a Tessellator (like the one used
+ *  by \c ShapeDrawable) as a mean to try to influence the way it works.
+ */
+class TessellationHints : public Object
+{
+    public:
+
+        TessellationHints():
+            _TessellationMode(USE_SHAPE_DEFAULTS),
+            _detailRatio(1.0f),
+            _targetNumFaces(100),
+            _createFrontFace(true),
+            _createBackFace(false),
+            _createNormals(true),
+            _createTextureCoords(false),
+            _createTop(true),
+            _createBody(true),
+            _createBottom(true) {}
+
+
+        TessellationHints(const TessellationHints& tess, const CopyOp& copyop=CopyOp::SHALLOW_COPY):
+            Object(tess,copyop),
+            _TessellationMode(tess._TessellationMode),
+            _detailRatio(tess._detailRatio),
+            _targetNumFaces(tess._targetNumFaces),
+            _createFrontFace(tess._createFrontFace),
+            _createBackFace(tess._createBackFace),
+            _createNormals(tess._createNormals),
+            _createTextureCoords(tess._createTextureCoords),
+            _createTop(tess._createTop),
+            _createBody(tess._createBody),
+            _createBottom(tess._createBottom) {}
+
+        META_Object(osg,TessellationHints);
+
+
+        enum TessellationMode
+        {
+            USE_SHAPE_DEFAULTS,
+            USE_TARGET_NUM_FACES
+        };
+
+        inline void setTessellationMode(TessellationMode mode) { _TessellationMode=mode; }
+        inline TessellationMode getTessellationMode() const { return _TessellationMode; }
+
+        inline void setDetailRatio(float ratio) { _detailRatio = ratio; }
+        inline float getDetailRatio() const { return _detailRatio; }
+
+        inline void setTargetNumFaces(unsigned int target) { _targetNumFaces=target; }
+        inline unsigned int getTargetNumFaces() const { return _targetNumFaces; }
+
+        inline void setCreateFrontFace(bool on) { _createFrontFace=on; }
+        inline bool getCreateFrontFace() const { return _createFrontFace; }
+
+        inline void setCreateBackFace(bool on) { _createBackFace=on; }
+        inline bool getCreateBackFace() const { return _createBackFace; }
+
+        inline void setCreateNormals(bool on) { _createNormals=on; }
+        inline bool getCreateNormals() const { return _createNormals; }
+
+        inline void setCreateTextureCoords(bool on) { _createTextureCoords=on; }
+        inline bool getCreateTextureCoords() const { return _createTextureCoords; }
+
+        inline void setCreateTop(bool on) { _createTop=on; }
+        inline bool getCreateTop() const { return _createTop; }
+
+        inline void setCreateBody(bool on) { _createBody=on; }
+        inline bool getCreateBody() const { return _createBody; }
+
+        inline void setCreateBottom(bool on) { _createBottom=on; }
+        inline bool getCreateBottom() const { return _createBottom; }
+
+    protected:
+
+        ~TessellationHints() {}
+
+
+        TessellationMode _TessellationMode;
+
+        float           _detailRatio;
+        unsigned int     _targetNumFaces;
+
+        bool             _createFrontFace;
+        bool             _createBackFace;
+        bool             _createNormals;
+        bool             _createTextureCoords;
+
+        bool             _createTop;
+        bool             _createBody;
+        bool             _createBottom;
+
+};
+
+// forward declare;
+class Geometry;
+
+/** Convinience class for populating an osg::Geomtry with vertex, normals, texture coords and primitives that can render a Shape. */
+class OSG_EXPORT BuildShapeGeometryVisitor : public ConstShapeVisitor
+{
+    public:
+
+        BuildShapeGeometryVisitor(Geometry* geometry, TessellationHints* hints);
+
+        virtual void apply(const Sphere&);
+        virtual void apply(const Box&);
+        virtual void apply(const Cone&);
+        virtual void apply(const Cylinder&);
+        virtual void apply(const Capsule&);
+        virtual void apply(const InfinitePlane&);
+
+        virtual void apply(const TriangleMesh&);
+        virtual void apply(const ConvexHull&);
+        virtual void apply(const HeightField&);
+
+        virtual void apply(const CompositeShape&);
+
+        void Normal(const Vec3f& v) { _normals->push_back(v); }
+        void Normal3f(float x, float y, float z) { _normals->push_back(Vec3(x,y,z)); }
+        void TexCoord2f(float x, float y) { _texcoords->push_back(Vec2(x,y)); }
+        void Vertex(const Vec3f& v) { _vertices->push_back(v); }
+        void Vertex3f(float x, float y, float z) { _vertices->push_back(Vec3(x,y,z)); }
+
+        void setMatrix(const osg::Matrixd& m);
+
+        void Begin(GLenum mode);
+        void End();
+
+protected:
+
+        BuildShapeGeometryVisitor& operator = (const BuildShapeGeometryVisitor&) { return *this; }
+
+        enum SphereHalf { SphereTopHalf, SphereBottomHalf };
+
+        // helpers for apply( Cylinder | Sphere | Capsule )
+        void drawCylinderBody(unsigned int numSegments, float radius, float height);
+        void drawHalfSphere(unsigned int numSegments, unsigned int numRows, float radius, SphereHalf which, float zOffset = 0.0f);
+
+        Geometry*                   _geometry;
+        const TessellationHints*    _hints;
+
+        ref_ptr<Vec3Array>          _vertices;
+        ref_ptr<Vec3Array>          _normals;
+        ref_ptr<Vec2Array>          _texcoords;
+
+        GLenum          _mode;
+        unsigned int    _start_index;
+        Matrixd         _matrix;
+        Matrixd         _inverse;
+};
+
 }
 
 #endif