ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreDualQuaternion.h

@@ -1,184 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#ifndef __DualQuaternion_H__
-#define __DualQuaternion_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreMath.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-	/** Implementation of a dual quaternion, i.e. a rotation around an axis and a translation.
-	    This implementation may note be appropriate as a general implementation, but is intended for use with
-	    dual quaternion skinning.
-	*/
-	class _OgreExport DualQuaternion
-	{
-	public:
-		/// Default constructor, initializes to identity rotation (aka 0�), and zero translation (0,0,0)
-		inline DualQuaternion ()
-			: w(1), x(0), y(0), z(0), dw(1), dx(0), dy(0), dz(0)
-		{
-		}
-		
-		/// Construct from an explicit list of values
-		inline DualQuaternion (Real fW, Real fX, Real fY, Real fZ, 
-				Real fdW, Real fdX, Real fdY, Real fdZ)
-			: w(fW), x(fX), y(fY), z(fZ), dw(fdW), dx(fdX), dy(fdY), dz(fdZ)
-		{
-		}
-        
-		/// Construct a dual quaternion from a transformation matrix
-		inline DualQuaternion(const Matrix4& rot)
-		{
-			this->fromTransformationMatrix(rot);
-		}
-		
-		/// Construct a dual quaternion from a unit quaternion and a translation vector
-		inline DualQuaternion(const Quaternion& q, const Vector3& trans)
-		{
-			this->fromRotationTranslation(q, trans);
-		}
-		
-		/// Construct a dual quaternion from 8 manual w/x/y/z/dw/dx/dy/dz values
-		inline DualQuaternion(Real* valptr)
-		{
-			memcpy(&w, valptr, sizeof(Real)*8);
-		}
-
-		/// Array accessor operator
-		inline Real operator [] ( const size_t i ) const
-		{
-			assert( i < 8 );
-
-			return *(&w+i);
-		}
-
-		/// Array accessor operator
-		inline Real& operator [] ( const size_t i )
-		{
-			assert( i < 8 );
-
-			return *(&w+i);
-		}
-		
-		inline DualQuaternion& operator= (const DualQuaternion& rkQ)
-		{
-			w = rkQ.w;
-			x = rkQ.x;
-			y = rkQ.y;
-			z = rkQ.z;
-			dw = rkQ.dw;
-			dx = rkQ.dx;
-			dy = rkQ.dy;
-			dz = rkQ.dz;
-			
-			return *this;
-		}
-
-		inline bool operator== (const DualQuaternion& rhs) const
-		{
-			return (rhs.w == w) && (rhs.x == x) && (rhs.y == y) && (rhs.z == z) && 
-				(rhs.dw == dw) && (rhs.dx == dx) && (rhs.dy == dy) && (rhs.dz == dz);
-		}
-
-		inline bool operator!= (const DualQuaternion& rhs) const
-		{
-			return !operator==(rhs);
-		}
-
-		/// Pointer accessor for direct copying
-		inline Real* ptr()
-		{
-			return &w;
-		}
-
-		/// Pointer accessor for direct copying
-		inline const Real* ptr() const
-		{
-			return &w;
-		}
-		
-		/// Exchange the contents of this dual quaternion with another. 
-		inline void swap(DualQuaternion& other)
-		{
-			std::swap(w, other.w);
-			std::swap(x, other.x);
-			std::swap(y, other.y);
-			std::swap(z, other.z);
-			std::swap(dw, other.dw);
-			std::swap(dx, other.dx);
-			std::swap(dy, other.dy);
-			std::swap(dz, other.dz);
-		}
-		
-		/// Check whether this dual quaternion contains valid values
-		inline bool isNaN() const
-		{
-			return Math::isNaN(w) || Math::isNaN(x) || Math::isNaN(y) || Math::isNaN(z) ||  
-				Math::isNaN(dw) || Math::isNaN(dx) || Math::isNaN(dy) || Math::isNaN(dz);
-		}
-
-		/// Construct a dual quaternion from a rotation described by a Quaternion and a translation described by a Vector3
-		void fromRotationTranslation (const Quaternion& q, const Vector3& trans);
-		
-		/// Convert a dual quaternion into its two components, a Quaternion representing the rotation and a Vector3 representing the translation
-		void toRotationTranslation (Quaternion& q, Vector3& translation) const;
-
-		/// Construct a dual quaternion from a 4x4 transformation matrix
-		void fromTransformationMatrix (const Matrix4& kTrans);
-		
-		/// Convert a dual quaternion to a 4x4 transformation matrix
-		void toTransformationMatrix (Matrix4& kTrans) const;
-
-		Real w, x, y, z, dw, dx, dy, dz;
-
-		/** 
-		Function for writing to a stream. Outputs "DualQuaternion(w, x, y, z, dw, dx, dy, dz)" with w, x, y, z, dw, dx, dy, dz
-		being the member values of the dual quaternion.
-		*/
-		inline _OgreExport friend std::ostream& operator <<
-		( std::ostream& o, const DualQuaternion& q )
-		{
-			o << "DualQuaternion(" << q.w << ", " << q.x << ", " << q.y << ", " << q.z << ", " << q.dw << ", " << q.dx << ", " << q.dy << ", " << q.dz << ")";
-			return o;
-		}
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif 

data/deps/include/OGRE/OgreDynLib.h

@@ -1,124 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef _DynLib_H__
-#define _DynLib_H__
-
-#include "OgrePrerequisites.h"
-
-#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
-#    define DYNLIB_HANDLE hInstance
-#    define DYNLIB_LOAD( a ) LoadLibraryEx( a, NULL, LOAD_WITH_ALTERED_SEARCH_PATH )
-#    define DYNLIB_GETSYM( a, b ) GetProcAddress( a, b )
-#    define DYNLIB_UNLOAD( a ) !FreeLibrary( a )
-
-struct HINSTANCE__;
-typedef struct HINSTANCE__* hInstance;
-
-#elif OGRE_PLATFORM == OGRE_PLATFORM_LINUX || OGRE_PLATFORM == OGRE_PLATFORM_ANDROID || OGRE_PLATFORM == OGRE_PLATFORM_NACL
-#    define DYNLIB_HANDLE void*
-#    define DYNLIB_LOAD( a ) dlopen( a, RTLD_LAZY | RTLD_GLOBAL)
-#    define DYNLIB_GETSYM( a, b ) dlsym( a, b )
-#    define DYNLIB_UNLOAD( a ) dlclose( a )
-
-#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-#    define DYNLIB_HANDLE void*
-#    define DYNLIB_LOAD( a ) mac_loadDylib( a )
-#    define DYNLIB_GETSYM( a, b ) dlsym( a, b )
-#    define DYNLIB_UNLOAD( a ) dlclose( a )
-
-#endif
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup General
-	*  @{
-	*/
-
-    /** Resource holding data about a dynamic library.
-        @remarks
-            This class holds the data required to get symbols from
-            libraries loaded at run-time (i.e. from DLL's for so's)
-        @author
-            Adrian Cearn„u (cearny@cearny.ro)
-        @since
-            27 January 2002
-        @see
-            Resource
-    */
-	class _OgreExport DynLib : public DynLibAlloc
-    {
-	protected:
-		String mName;
-        /// Gets the last loading error
-        String dynlibError(void);
-    public:
-        /** Default constructor - used by DynLibManager.
-            @warning
-                Do not call directly
-        */
-        DynLib( const String& name );
-
-        /** Default destructor.
-        */
-        ~DynLib();
-
-        /** Load the library
-        */
-        void load();
-        /** Unload the library
-        */
-        void unload();
-		/// Get the name of the library
-		const String& getName(void) const { return mName; }
-
-        /**
-            Returns the address of the given symbol from the loaded library.
-            @param
-                strName The name of the symbol to search for
-            @return
-                If the function succeeds, the returned value is a handle to
-                the symbol.
-            @par
-                If the function fails, the returned value is <b>NULL</b>.
-
-        */
-        void* getSymbol( const String& strName ) const throw();
-
-    protected:
-
-        /// Handle to the loaded library.
-        DYNLIB_HANDLE mInst;
-    };
-	/** @} */
-	/** @} */
-
-}
-
-#endif

data/deps/include/OGRE/OgreDynLibManager.h

@@ -1,117 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __DynLibManager_H__
-#define __DynLibManager_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreSingleton.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup General
-	*  @{
-	*/
-	/** Manager for Dynamic-loading Libraries.
-        @remarks
-            This manager keeps a track of all the open dynamic-loading
-            libraries, opens them and returns references to already-open
-            libraries.
-    */
-    class _OgreExport DynLibManager: public Singleton<DynLibManager>, public DynLibAlloc
-    {
-	protected:
-		typedef map<String, DynLib*>::type DynLibList;
-		DynLibList mLibList;
-    public:
-        /** Default constructor.
-            @note
-                <br>Should never be called as the singleton is automatically
-                created during the creation of the Root object.
-            @see
-                Root::Root
-        */
-        DynLibManager();
-
-        /** Default destructor.
-            @see
-                Root::~Root
-        */
-        virtual ~DynLibManager();
-
-        /** Loads the passed library.
-            @param
-                filename The name of the library. The extension can be omitted
-        */
-        DynLib* load(const String& filename);
-
-		/** Unloads the passed library.
-		@param
-		filename The name of the library. The extension can be omitted
-		*/
-		void unload(DynLib* lib);
-
-		/** Override standard Singleton retrieval.
-        @remarks
-        Why do we do this? Well, it's because the Singleton
-        implementation is in a .h file, which means it gets compiled
-        into anybody who includes it. This is needed for the
-        Singleton template to work, but we actually only want it
-        compiled into the implementation of the class based on the
-        Singleton, not all of them. If we don't change this, we get
-        link errors when trying to use the Singleton-based class from
-        an outside dll.
-        @par
-        This method just delegates to the template version anyway,
-        but the implementation stays in this single compilation unit,
-        preventing link errors.
-        */
-        static DynLibManager& getSingleton(void);
-        /** Override standard Singleton retrieval.
-        @remarks
-        Why do we do this? Well, it's because the Singleton
-        implementation is in a .h file, which means it gets compiled
-        into anybody who includes it. This is needed for the
-        Singleton template to work, but we actually only want it
-        compiled into the implementation of the class based on the
-        Singleton, not all of them. If we don't change this, we get
-        link errors when trying to use the Singleton-based class from
-        an outside dll.
-        @par
-        This method just delegates to the template version anyway,
-        but the implementation stays in this single compilation unit,
-        preventing link errors.
-        */
-        static DynLibManager* getSingletonPtr(void);
-    };
-	/** @} */
-	/** @} */
-}
-
-#endif

data/deps/include/OGRE/OgreEdgeListBuilder.h

@@ -1,269 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __EdgeListBuilder_H__
-#define __EdgeListBuilder_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreVector4.h"
-#include "OgreHardwareVertexBuffer.h"
-#include "OgreRenderOperation.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-
-
-    /** This class contains the information required to describe the edge connectivity of a
-        given set of vertices and indexes. 
-    @remarks 
-        This information is built using the EdgeListBuilder class. Note that for a given mesh,
-        which can be made up of multiple submeshes, there are separate edge lists for when 
-    */
-	class _OgreExport EdgeData : public EdgeDataAlloc
-    {
-    public:
-        /** Basic triangle structure. */
-        struct Triangle {
-            /** The set of indexes this triangle came from (NB it is possible that the triangles on 
-               one side of an edge are using a different vertex buffer from those on the other side.) */
-            size_t indexSet; 
-            /** The vertex set these vertices came from. */
-            size_t vertexSet;
-            size_t vertIndex[3];/// Vertex indexes, relative to the original buffer
-            size_t sharedVertIndex[3]; /// Vertex indexes, relative to a shared vertex buffer with 
-                                        // duplicates eliminated (this buffer is not exposed)
-
-			Triangle() :indexSet(0), vertexSet(0) {}
-        };
-        /** Edge data. */
-        struct Edge {
-            /** The indexes of the 2 tris attached, note that tri 0 is the one where the 
-                indexes run _anti_ clockwise along the edge. Indexes must be
-                reversed for tri 1. */
-            size_t triIndex[2];
-            /** The vertex indices for this edge. Note that both vertices will be in the vertex
-                set as specified in 'vertexSet', which will also be the same as tri 0 */
-            size_t vertIndex[2];
-            /** Vertex indices as used in the shared vertex list, not exposed. */
-            size_t sharedVertIndex[2];
-            /** Indicates if this is a degenerate edge, ie it does not have 2 triangles */
-            bool degenerate;
-        };
-
-        // Array of 4D vector of triangle face normal, which is unit vector orthogonal
-        // to the triangles, plus distance from origin.
-        // Use aligned policy here because we are intended to use in SIMD optimised routines .
-        typedef std::vector<Vector4, STLAllocator<Vector4, CategorisedAlignAllocPolicy<MEMCATEGORY_GEOMETRY> > > TriangleFaceNormalList;
-
-        // Working vector used when calculating the silhouette.
-        // Use std::vector<char> instead of std::vector<bool> which might implemented
-        // similar bit-fields causing loss performance.
-        typedef vector<char>::type TriangleLightFacingList;
-
-        typedef vector<Triangle>::type TriangleList;
-        typedef vector<Edge>::type EdgeList;
-
-        /** A group of edges sharing the same vertex data. */
-        struct EdgeGroup
-        {
-            /** The vertex set index that contains the vertices for this edge group. */
-            size_t vertexSet;
-            /** Pointer to vertex data used by this edge group. */
-            const VertexData* vertexData;
-            /** Index to main triangles array, indicate the first triangle of this edge
-                group, and all triangles of this edge group are stored continuous in
-                main triangles array.
-            */
-            size_t triStart;
-            /** Number triangles of this edge group. */
-            size_t triCount;
-            /** The edges themselves. */
-            EdgeList edges;
-
-        };
-
-        typedef vector<EdgeGroup>::type EdgeGroupList;
-
-        /** Main triangles array, stores all triangles of this edge list. Note that
-            triangles are grouping against edge group.
-        */
-        TriangleList triangles;
-        /** All triangle face normals. It should be 1:1 with triangles. */
-        TriangleFaceNormalList triangleFaceNormals;
-        /** Triangle light facing states. It should be 1:1 with triangles. */
-        TriangleLightFacingList triangleLightFacings;
-        /** All edge groups of this edge list. */
-        EdgeGroupList edgeGroups;
-        /** Flag indicate the mesh is manifold. */
-        bool isClosed;
-
-
-        /** Calculate the light facing state of the triangles in this edge list
-        @remarks
-            This is normally the first stage of calculating a silhouette, i.e.
-            establishing which tris are facing the light and which are facing
-            away. This state is stored in the 'triangleLightFacings'.
-        @param lightPos 4D position of the light in object space, note that 
-            for directional lights (which have no position), the w component
-            is 0 and the x/y/z position are the direction.
-        */
-        void updateTriangleLightFacing(const Vector4& lightPos);
-        /** Updates the face normals for this edge list based on (changed)
-            position information, useful for animated objects. 
-        @param vertexSet The vertex set we are updating
-        @param positionBuffer The updated position buffer, must contain ONLY xyz
-        */
-        void updateFaceNormals(size_t vertexSet, const HardwareVertexBufferSharedPtr& positionBuffer);
-
-
-
-        // Debugging method
-        void log(Log* log);
-        
-    };
-
-    /** General utility class for building edge lists for geometry.
-    @remarks
-        You can add multiple sets of vertex and index data to build and edge list. 
-        Edges will be built between the various sets as well as within sets; this allows 
-        you to use a model which is built from multiple SubMeshes each using 
-        separate index and (optionally) vertex data and still get the same connectivity 
-        information. It's important to note that the indexes for the edge will be constrained
-        to a single vertex buffer though (this is required in order to render the edge).
-    */
-    class _OgreExport EdgeListBuilder 
-    {
-    public:
-
-        EdgeListBuilder();
-        virtual ~EdgeListBuilder();
-        /** Add a set of vertex geometry data to the edge builder. 
-        @remarks
-            You must add at least one set of vertex data to the builder before invoking the
-            build method.
-        */
-        void addVertexData(const VertexData* vertexData);
-        /** Add a set of index geometry data to the edge builder. 
-        @remarks
-            You must add at least one set of index data to the builder before invoking the
-            build method.
-        @param indexData The index information which describes the triangles.
-        @param vertexSet The vertex data set this index data refers to; you only need to alter this
-            if you have added multiple sets of vertices
-        @param opType The operation type used to render these indexes. Only triangle types
-            are supported (no point or line types)
-        */
-        void addIndexData(const IndexData* indexData, size_t vertexSet = 0, 
-            RenderOperation::OperationType opType = RenderOperation::OT_TRIANGLE_LIST);
-
-        /** Builds the edge information based on the information built up so far.
-        @remarks
-            The caller takes responsibility for deleting the returned structure.
-        */
-        EdgeData* build(void);
-
-        /// Debugging method
-        void log(Log* l);
-    protected:
-
-        /** A vertex can actually represent several vertices in the final model, because
-		vertices along texture seams etc will have been duplicated. In order to properly
-		evaluate the surface properties, a single common vertex is used for these duplicates,
-		and the faces hold the detail of the duplicated vertices.
-		*/
-        struct CommonVertex {
-            Vector3  position;  // location of point in euclidean space
-	        size_t index;       // place of vertex in common vertex list
-            size_t vertexSet;   // The vertex set this came from
-            size_t indexSet;    // The index set this was referenced (first) from
-            size_t originalIndex; // place of vertex in original vertex set
-        };
-        /** A set of indexed geometry data */
-        struct Geometry {
-            size_t vertexSet;           // The vertex data set this geometry data refers to
-            size_t indexSet;            // The index data set this geometry data refers to
-            const IndexData* indexData; // The index information which describes the triangles.
-            RenderOperation::OperationType opType;  // The operation type used to render this geometry
-        };
-        /** Comparator for sorting geometries by vertex set */
-        struct geometryLess {
-            bool operator()(const Geometry& a, const Geometry& b) const
-            {
-                if (a.vertexSet < b.vertexSet) return true;
-                if (a.vertexSet > b.vertexSet) return false;
-                return a.indexSet < b.indexSet;
-            }
-        };
-        /** Comparator for unique vertex list */
-        struct vectorLess {
-            bool operator()(const Vector3& a, const Vector3& b) const
-            {
-                if (a.x < b.x) return true;
-                if (a.x > b.x) return false;
-                if (a.y < b.y) return true;
-                if (a.y > b.y) return false;
-                return a.z < b.z;
-            }
-        };
-
-        typedef vector<const VertexData*>::type VertexDataList;
-        typedef vector<Geometry>::type GeometryList;
-        typedef vector<CommonVertex>::type CommonVertexList;
-
-        GeometryList mGeometryList;
-        VertexDataList mVertexDataList;
-        CommonVertexList mVertices;
-        EdgeData* mEdgeData;
-		/// Map for identifying common vertices
-		typedef map<Vector3, size_t, vectorLess>::type CommonVertexMap;
-		CommonVertexMap mCommonVertexMap;
-        /** Edge map, used to connect edges. Note we allow many triangles on an edge,
-        after connected an existing edge, we will remove it and never used again.
-        */
-        typedef multimap< std::pair<size_t, size_t>, std::pair<size_t, size_t> >::type EdgeMap;
-        EdgeMap mEdgeMap;
-
-        void buildTrianglesEdges(const Geometry &geometry);
-
-        /// Finds an existing common vertex, or inserts a new one
-        size_t findOrCreateCommonVertex(const Vector3& vec, size_t vertexSet, 
-            size_t indexSet, size_t originalIndex);
-        /// Connect existing edge or create a new edge - utility method during building
-        void connectOrCreateEdge(size_t vertexSet, size_t triangleIndex, size_t vertIndex0, size_t vertIndex1, 
-            size_t sharedVertIndex0, size_t sharedVertIndex1);
-    };
-	/** @} */
-	/** @} */
-
-}
-#endif
-