ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreDualQuaternion.h

@@ -0,0 +1,184 @@
+/*
+-----------------------------------------------------------------------------
+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

@@ -0,0 +1,130 @@
+/*
+-----------------------------------------------------------------------------
+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
+#    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 )
+
+#elif OGRE_PLATFORM == OGRE_PLATFORM_SYMBIAN || OGRE_PLATFORM == OGRE_PLATFORM_NACL
+#    define DYNLIB_HANDLE void*
+#    define DYNLIB_LOAD( a ) 0
+#    define DYNLIB_GETSYM( a, b ) 0
+#    define DYNLIB_UNLOAD( a ) 0
+
+#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

@@ -0,0 +1,117 @@
+/*
+-----------------------------------------------------------------------------
+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

@@ -0,0 +1,269 @@
+/*
+-----------------------------------------------------------------------------
+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
+