shattered_ogrerb 0.5.0.1

data/vendor/ogrerb/src_headers/OGRE/OgreDefaultHardwareBufferManager.h

@@ -0,0 +1,116 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+
+#ifndef __DefaultHardwareBufferManager_H__
+#define __DefaultHardwareBufferManager_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreHardwareBufferManager.h"
+#include "OgreHardwareVertexBuffer.h"
+#include "OgreHardwareIndexBuffer.h"
+
+namespace Ogre {
+
+    /// Specialisation of HardwareVertexBuffer for emulation
+    class _OgreExport DefaultHardwareVertexBuffer : public HardwareVertexBuffer 
+    {
+	protected:
+		unsigned char* mpData;
+        /** See HardwareBuffer. */
+        void* lockImpl(size_t offset, size_t length, LockOptions options);
+        /** See HardwareBuffer. */
+		void unlockImpl(void);
+    public:
+		DefaultHardwareVertexBuffer(size_t vertexSize, size_t numVertices, 
+            HardwareBuffer::Usage usage);
+        ~DefaultHardwareVertexBuffer();
+        /** See HardwareBuffer. */
+        void readData(size_t offset, size_t length, void* pDest);
+        /** See HardwareBuffer. */
+        void writeData(size_t offset, size_t length, const void* pSource,
+				bool discardWholeBuffer = false);
+        /** Override HardwareBuffer to turn off all shadowing. */
+        void* lock(size_t offset, size_t length, LockOptions options);
+        /** Override HardwareBuffer to turn off all shadowing. */
+		void unlock(void);
+
+
+    };
+
+	/// Specialisation of HardwareIndexBuffer for emulation
+    class _OgreExport DefaultHardwareIndexBuffer : public HardwareIndexBuffer
+    {
+	protected:
+		unsigned char* mpData;
+        /** See HardwareBuffer. */
+        void* lockImpl(size_t offset, size_t length, LockOptions options);
+        /** See HardwareBuffer. */
+		void unlockImpl(void);
+    public:
+		DefaultHardwareIndexBuffer(IndexType idxType, size_t numIndexes, HardwareBuffer::Usage usage);
+        ~DefaultHardwareIndexBuffer();
+        /** See HardwareBuffer. */
+        void readData(size_t offset, size_t length, void* pDest);
+        /** See HardwareBuffer. */
+        void writeData(size_t offset, size_t length, const void* pSource,
+				bool discardWholeBuffer = false);
+        /** Override HardwareBuffer to turn off all shadowing. */
+        void* lock(size_t offset, size_t length, LockOptions options);
+        /** Override HardwareBuffer to turn off all shadowing. */
+		void unlock(void);
+
+    };
+
+	/** Specialisation of HardwareBufferManager to emulate hardware buffers.
+	@remarks
+		You might want to instantiate this class if you want to utilise
+		classes like MeshSerializer without having initialised the 
+		rendering system (which is required to create a 'real' hardware
+		buffer manager.
+	*/
+	class _OgreExport DefaultHardwareBufferManager : public HardwareBufferManager
+	{
+    public:
+        DefaultHardwareBufferManager();
+        ~DefaultHardwareBufferManager();
+        /// Creates a vertex buffer
+		HardwareVertexBufferSharedPtr 
+            createVertexBuffer(size_t vertexSize, size_t numVerts, 
+				HardwareBuffer::Usage usage, bool useShadowBuffer = false);
+		/// Create a hardware vertex buffer
+		HardwareIndexBufferSharedPtr 
+            createIndexBuffer(HardwareIndexBuffer::IndexType itype, size_t numIndexes, 
+				HardwareBuffer::Usage usage, bool useShadowBuffer = false);
+
+    };
+
+
+}
+
+#endif

data/vendor/ogrerb/src_headers/OGRE/OgreDynLib.h

@@ -0,0 +1,116 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef _DynLib_H__
+#define _DynLib_H__
+
+#include "OgrePrerequisites.h"
+
+#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
+#    define DYNLIB_HANDLE hInstance
+#    define DYNLIB_LOAD( a ) LoadLibrary( a )
+#    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
+#    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
+#    define DYNLIB_HANDLE CFBundleRef
+#    define DYNLIB_LOAD( a ) mac_loadExeBundle( a )
+#    define DYNLIB_GETSYM( a, b ) mac_getBundleSym( a, b )
+#    define DYNLIB_UNLOAD( a ) mac_unloadExeBundle( a )
+#endif
+
+namespace Ogre {
+
+    /** 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
+    {
+	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
+            @returns
+                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 m_hInst;
+    };
+
+}
+
+#endif

data/vendor/ogrerb/src_headers/OGRE/OgreDynLibManager.h

@@ -0,0 +1,110 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __DynLibManager_H__
+#define __DynLibManager_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreSingleton.h"
+
+namespace Ogre {
+    /** 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>
+    {
+	protected:
+		typedef std::map<String, DynLib*> 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 ommitted
+        */
+        DynLib* load(const String& filename);
+
+		/** Unloads the passed library.
+		@param
+		filename The name of the library. The extension can be ommitted
+		*/
+		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/vendor/ogrerb/src_headers/OGRE/OgreEdgeListBuilder.h

@@ -0,0 +1,261 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __EdgeListBuilder_H__
+#define __EdgeListBuilder_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreVector4.h"
+#include "OgreHardwareVertexBuffer.h"
+#include "OgreRenderOperation.h"
+#include "OgreAlignedAllocator.h"
+
+namespace Ogre {
+
+
+    /** 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:
+        /** 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)
+        };
+        /** 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 othogonal
+        // to the triangles, plus distance from origin.
+        // Use aligned allocator here because we are intented to use in SIMD optimised routines .
+        typedef std::vector<Vector4, AlignedAllocator<Vector4> > 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 std::vector<char> TriangleLightFacingList;
+
+        typedef std::vector<Triangle> TriangleList;
+        typedef std::vector<Edge> 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 std::vector<EdgeGroup> 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, ie
+            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 std::vector<const VertexData*> VertexDataList;
+        typedef std::vector<Geometry> GeometryList;
+        typedef std::vector<CommonVertex> CommonVertexList;
+
+        GeometryList mGeometryList;
+        VertexDataList mVertexDataList;
+        CommonVertexList mVertices;
+        EdgeData* mEdgeData;
+		/// Map for identifying common vertices
+		typedef std::map<Vector3, size_t, vectorLess> 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 std::multimap< std::pair<size_t, size_t>, std::pair<size_t, size_t> > 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
+