ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/Plugins/BSPSceneManager/OgreBspLevel.h

@@ -0,0 +1,278 @@
+/*
+-----------------------------------------------------------------------------
+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 _BspLevel_H__
+#define _BspLevel_H__
+
+#include "OgreBspPrerequisites.h"
+#include "OgreResource.h"
+#include "OgreStaticFaceGroup.h"
+#include "OgreSceneManager.h"
+#include "OgreBspNode.h"
+#include "OgreHardwareBufferManager.h"
+#include "OgreDefaultHardwareBufferManager.h"
+#include "OgreQuake3Level.h"
+
+
+namespace Ogre {
+
+    /** Holds all the data associated with a Binary Space Parition
+        (BSP) based indoor level.
+        The data used here is populated by loading level files via
+        the BspLevelManager::load method, although application users
+        are more likely to call SceneManager::setWorldGeometry which will
+        automatically arrange the loading of the level. Note that this assumes
+        that you have asked for an indoor-specialised SceneManager (specify
+        ST_INDOOR when calling Root::getSceneManager).</p>
+        Ogre currently only supports loading from Quake3 Arena level files,
+        although any source that can be converted into this classes structure
+        could also be used. The Quake3 level load process is in a different
+        class called Quake3Level to keep the specifics separate.</p>
+    */
+    class BspLevel : public Resource
+    {
+        friend class BspSceneManager;
+    public:
+        /** Default constructor - used by BspResourceManager (do not call directly) */
+        BspLevel(ResourceManager* creator, const String& name, ResourceHandle handle,
+            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
+        ~BspLevel();
+
+        /** Determines if one leaf node is visible from another. */
+        bool isLeafVisible(const BspNode* from, const BspNode* to) const;
+
+        /** Returns a pointer to the root node (BspNode) of the BSP tree. */
+        const BspNode* getRootNode(void);
+
+        /** Walks the entire BSP tree and returns the leaf
+            which contains the given point.
+        */
+        BspNode* findLeaf(const Vector3& point) const;
+
+        /** Ensures that the MovableObject is attached to the right leaves of the 
+            BSP tree.
+        */
+        void _notifyObjectMoved(const MovableObject* mov, 
+            const Vector3& pos);
+		/** Internal method, makes sure an object is removed from the leaves when detached from a node. */
+		void _notifyObjectDetached(const MovableObject* mov);
+        /** Gets a pointer to the start of the leaf nodes. */
+        BspNode* getLeafStart(void) {return &mRootNode[mLeafStart]; }
+        /** Gets the number of leaf nodes */
+        int getNumLeaves(void) const { return mNumLeaves; }
+
+        /** Calculate the number of loading stages required for a given level */
+        static size_t calculateLoadingStages(const String& levelName);
+        /** Calculate the number of loading stages required for a given level */
+        static size_t calculateLoadingStages(DataStreamPtr& stream);
+
+		/** Load direct from stream */
+		void load(DataStreamPtr& stream);
+
+		/** Is sky enabled? */
+		bool isSkyEnabled(void) const;
+		/** Get Sky material name */
+		const String& getSkyMaterialName(void) const;
+		/** Get sky curvature */
+		Real getSkyCurvature(void) const;
+
+        /** Utility class just to enable queueing of patches */
+    protected:
+        /** @copydoc Resource::loadImpl. */
+        void loadImpl(void);
+        /** @copydoc Resource::unloadImpl. */
+        void unloadImpl(void);
+        /** @copydoc Resource::calculateSize. */
+        size_t calculateSize(void) const;
+        /** Pointer to the root node of the BSP tree;
+            This pointer actually has a dual purpose; to avoid allocating lots of small chunks of
+            memory, the BspLevel actually allocates all nodes required through this pointer. So this
+            pointer is the handle for the allocation of memory for all nodes. It also happens to point
+            to the root node, since the first one in the memory chunk is the root node.
+        */
+        BspNode* mRootNode;
+        int mNumNodes;
+        int mNumLeaves;
+		int mNumBrushes;
+        int mLeafStart; // the index at which leaf nodes begin
+
+        /** Vertex format for fixed geometry.
+            Note that in this case vertex components (position, normal, texture coords etc)
+            are held interleaved in the same buffer. However, the format here is different from 
+            the format used by Quake because older Direct3d drivers like the vertex elements
+            to be in a particular order within the buffer. See VertexDeclaration for full
+            details of this marvellous(not) feature.
+        */
+        struct BspVertex
+        {
+            float position[3];
+            float normal[3];
+            int colour;
+            float texcoords[2];
+            float lightmap[2];
+        };
+        /*
+        /// Array of vertices for whole level.
+        BspVertex* mVertices;
+        int mNumVertices;
+        */
+        /// Vertex data holding all the data for the level, but able to render parts of it
+        VertexData* mVertexData;
+
+        /** Array of indexes into the mFaceGroups array. This buffer is organised
+            by leaf node so leaves can just use contiguous chunks of it and
+            get repointed to the actual entries in mFaceGroups. */
+        int* mLeafFaceGroups;
+        int mNumLeafFaceGroups;
+
+        /** Array of face groups, indexed into by contents of mLeafFaceGroups. */
+        StaticFaceGroup* mFaceGroups;
+        int mNumFaceGroups;
+
+
+        /*
+        /// Array of elements i.e. vertex indexes as used by face groups.
+        int* mElements;
+        int mNumElements;
+        */
+
+        /// indexes for the whole level, will be copied to the real indexdata per frame
+        size_t mNumIndexes;
+        // system-memory buffer
+        HardwareIndexBufferSharedPtr mIndexes;
+
+        /// Brushes as used for collision, main memory is here
+        BspNode::Brush *mBrushes;
+
+        /** Vector of player start points */
+		vector<ViewPoint>::type mPlayerStarts;
+
+        /** Internal utility function for loading data from Quake3. */
+        void loadQuake3Level(const Quake3Level& q3lvl);
+        /** Internal lookup table to determine visibility between leaves.
+            Leaf nodes are assigned to 'clusters' of nodes, which are used to group nodes together for
+            visibility testing. This data holds a lookup table which is used to determine if one cluster of leaves
+            is visible from another cluster. Whilst it would be possible to expand all this out so that
+            each node had a list of pointers to other visible nodes, this would be very expensive in terms
+            of storage (using the cluster method there is a table which is 1-bit squared per cluster, rounded
+            up to the nearest byte obviously, which uses far less space than 4-bytes per linked node per source
+            node). Of course the limitation here is that you have to each leaf in turn to determine if it is visible
+            rather than just following a list, but since this is only done once per frame this is not such a big
+            overhead.</p>
+            Each row in the table is a 'from' cluster, with each bit in the row corresponding to a 'to' cluster,
+            both ordered based on cluster index. A 0 in the bit indicates the 'to' cluster is not visible from the
+            'from' cluster, whilst a 1 indicates it is.</p>
+            As many will notice, this is lifted directly from the Quake implementation of PVS.
+        */
+        struct VisData
+        {
+            unsigned char *tableData;
+            int numClusters;            // Number of clusters, therefore number of rows
+            int rowLength;                // Length in bytes of each row (num clusters / 8 rounded up)
+        };
+
+        VisData mVisData;
+
+
+        /** Internal method for parsing chosen entities. */
+        void loadEntities(const Quake3Level& q3lvl);
+
+		typedef map<const MovableObject*, list<BspNode*>::type >::type MovableToNodeMap;
+        /// Map for locating the nodes a movable is currently a member of
+        MovableToNodeMap mMovableToNodeMap;
+
+        void tagNodesWithMovable(BspNode* node, const MovableObject* mov, const Vector3& pos);
+
+        // Storage of patches 
+		typedef map<int, PatchSurface*>::type PatchMap;
+        PatchMap mPatches;
+        // Total number of vertices required for all patches
+        size_t mPatchVertexCount;
+        // Total number of indexes required for all patches
+        size_t mPatchIndexCount;
+		// Sky enabled?
+		bool mSkyEnabled;
+		// Sky material
+		String mSkyMaterial;
+		// Sky details
+		Real mSkyCurvature;
+
+
+        void initQuake3Patches(const Quake3Level & q3lvl, VertexDeclaration* decl);
+        void buildQuake3Patches(size_t vertOffset, size_t indexOffset);
+
+        void quakeVertexToBspVertex(const bsp_vertex_t* src, BspVertex* dest);
+
+
+    };
+    /** Specialisation of SharedPtr to allow SharedPtr to be assigned to BspLevelPtr 
+    @note Has to be a subclass since we need operator=.
+    We could templatise this instead of repeating per Resource subclass, 
+    except to do so requires a form VC6 does not support i.e.
+    ResourceSubclassPtr<T> : public SharedPtr<T>
+    */
+    class BspLevelPtr : public SharedPtr<BspLevel> 
+    {
+    public:
+        BspLevelPtr() : SharedPtr<BspLevel>() {}
+        explicit BspLevelPtr(BspLevel* rep) : SharedPtr<BspLevel>(rep) {}
+        BspLevelPtr(const BspLevelPtr& r) : SharedPtr<BspLevel>(r) {} 
+        BspLevelPtr(const ResourcePtr& r) : SharedPtr<BspLevel>()
+        {
+			// lock & copy other mutex pointer
+			OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+            pRep = static_cast<BspLevel*>(r.getPointer());
+            pUseCount = r.useCountPointer();
+            if (pUseCount)
+            {
+                ++(*pUseCount);
+            }
+        }
+
+        /// Operator used to convert a ResourcePtr to a BspLevelPtr
+        BspLevelPtr& operator=(const ResourcePtr& r)
+        {
+            if (pRep == static_cast<BspLevel*>(r.getPointer()))
+                return *this;
+            release();
+			// lock & copy other mutex pointer
+			OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+            pRep = static_cast<BspLevel*>(r.getPointer());
+            pUseCount = r.useCountPointer();
+            if (pUseCount)
+            {
+                ++(*pUseCount);
+            }
+            return *this;
+        }
+    };
+
+}
+
+#endif

data/deps/include/OGRE/Plugins/BSPSceneManager/OgreBspNode.h

@@ -0,0 +1,212 @@
+/*
+-----------------------------------------------------------------------------
+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 _BspNode_H__
+#define _BspNode_H__
+
+#include "OgreBspPrerequisites.h"
+#include "OgrePlane.h"
+#include "OgreAxisAlignedBox.h"
+#include "OgreSceneQuery.h"
+
+namespace Ogre {
+
+    /** Encapsulates a node in a BSP tree.
+        A BSP tree represents space partitioned by planes . The space which is
+        partitioned is either the world (in the case of the root node) or the space derived
+        from their parent node. Each node can have elements which are in front or behind it, which are
+        it's children and these elements can either be further subdivided by planes,
+        or they can be undivided spaces or 'leaf nodes' - these are the nodes which actually contain
+        objects and world geometry.The leaves of the tree are the stopping point of any tree walking algorithm,
+        both for rendering and collision detection etc.</p>
+        Ogre chooses not to represent splitting nodes and leaves as separate structures, but to merge the two for simplicity
+        of the walking algorithm. If a node is a leaf, the isLeaf() method returns true and both getFront() and
+        getBack() return null pointers. If the node is a partitioning plane isLeaf() returns false and getFront()
+        and getBack() will return the corresponding BspNode objects.
+    */
+	class BspNode : public NodeAlloc
+    {
+        friend class BspLevel;
+
+    public:
+        /** Constructor, only to be used by BspLevel. */
+        BspNode(BspLevel* owner, bool isLeaf);
+
+        BspNode();
+        ~BspNode();
+
+        /** Returns true if this node is a leaf (i.e. contains geometry) or false if it is a splitting plane.
+            A BspNode can either be a splitting plane (the typical representation of a BSP node) or an undivided
+            region contining geometry (a leaf node). Ogre represents both using the same class for simplicity
+            of tree walking. However it is important that you use this method to determine which type you are dealing
+            with, since certain methods are only supported with one of the subtypes. Details are given in the individual methods.
+            Note that I could have represented splitting / leaf nodes as a class hierarchy but the
+            virtual methods / run-time type identification would have a performance hit, and it would not make the
+            code much (any?) simpler anyway. I think this is a fair trade-off in this case.
+        */
+        bool isLeaf(void) const;
+
+        /** Returns a pointer to a BspNode containing the subspace on the positive side of the splitting plane.
+            This method should only be called on a splitting node, i.e. where isLeaf() returns false. Calling this
+            method on a leaf node will throw an exception.
+        */
+        BspNode* getFront(void) const;
+
+        /** Returns a pointer to a BspNode containing the subspace on the negative side of the splitting plane.
+            This method should only be called on a splitting node, i.e. where isLeaf() returns false. Calling this
+            method on a leaf node will throw an exception.
+        */
+        BspNode* getBack(void) const;
+
+        /** Determines which side of the splitting plane a worldspace point is.
+            This method should only be called on a splitting node, i.e. where isLeaf() returns false. Calling this
+            method on a leaf node will throw an exception.
+        */
+        Plane::Side getSide (const Vector3& point) const;
+
+        /** Gets the next node down in the tree, with the intention of
+            locating the leaf containing the given point.
+            This method should only be called on a splitting node, i.e. where isLeaf() returns false. Calling this
+            method on a leaf node will throw an exception.
+        */
+        BspNode* getNextNode(const Vector3& point) const;
+
+
+        /** Returns details of the plane which is used to subdivide the space of his node's children.
+            This method should only be called on a splitting node, i.e. where isLeaf() returns false. Calling this
+            method on a leaf node will throw an exception.
+        */
+        const Plane& getSplitPlane(void) const;
+
+        /** Returns the axis-aligned box which contains this node if it is a leaf.
+            This method should only be called on a leaf node. It returns a box which can be used in calls like
+            Camera::isVisible to determine if the leaf node is visible in the view.
+        */
+        const AxisAlignedBox& getBoundingBox(void) const;
+
+        /** Returns the number of faces contained in this leaf node.
+            Should only be called on a leaf node.
+        */
+        int getNumFaceGroups(void) const;
+        /** Returns the index to the face group index list for this leaf node.
+            The contents of this buffer is a list of indexes which point to the
+            actual face groups held in a central buffer in the BspLevel class (in
+            actual fact for efficiency the indexes themselves are also held in a single
+            buffer in BspLevel too). The reason for this indirection is that the buffer
+            of indexes to face groups is organised in chunks relative to nodes, whilst the
+            main buffer of face groups may not be.
+            Should only be called on a leaf node.
+        */
+        int getFaceGroupStart(void) const;
+
+        /** Determines if the passed in node (must also be a leaf) is visible from this leaf.
+            Must only be called on a leaf node, and the parameter must also be a leaf node. If
+            this method returns true, then the leaf passed in is visible from this leaf.
+            Note that internally this uses the Potentially Visible Set (PVS) which is precalculated
+            and stored with the BSP level.
+        */
+        bool isLeafVisible(const BspNode* leaf) const;
+
+        friend std::ostream& operator<< (std::ostream& o, BspNode& n);
+
+        /// Internal method for telling the node that a movable intersects it
+        void _addMovable(const MovableObject* mov);
+
+        /// Internal method for telling the node that a movable no longer intersects it
+        void _removeMovable(const MovableObject* mov);
+
+        /// Gets the signed distance to the dividing plane
+        Real getDistance(const Vector3& pos) const;
+
+		typedef set<const MovableObject*>::type IntersectingObjectSet;
+
+        struct Brush
+        {
+			list<Plane>::type planes;
+            SceneQuery::WorldFragment fragment; // For query reporting
+        };
+		typedef vector<Brush*>::type NodeBrushList; // Main brush memory held on level
+
+        /** Get the list of solid Brushes for this node.
+        @remarks Only applicable for leaf nodes. 
+        */
+        const NodeBrushList& getSolidBrushes(void) const;
+    protected:
+        BspLevel* mOwner; // Back-reference to containing level
+        bool mIsLeaf;
+
+        // Node-only members
+        /** The plane which splits space in a non-leaf node.
+            Note that nodes do not allocate the memory for other nodes - for simplicity and bulk-allocation
+            of memory the BspLevel is responsible for assigning enough memory for all nodes in one go.
+        */
+        Plane mSplitPlane;
+        /** Pointer to the node in front of this non-leaf node. */
+        BspNode* mFront;
+        /** Pointer to the node behind this non-leaf node. */
+        BspNode* mBack;
+
+        // Leaf-only members
+        /** The cluster number of this leaf.
+            Leaf nodes are assigned to 'clusters' of nodes, which are used to group nodes together for
+            visibility testing. There is a lookup table which is used to determine if one cluster of leaves
+            is visible from another cluster. Whilst it would be possible to expand all this out so that
+            each node had a list of pointers to other visible nodes, this would be very expensive in terms
+            of storage (using the cluster method there is a table which is 1-bit squared per cluster, rounded
+            up to the nearest byte obviously, which uses far less space than 4-bytes per linked node per source
+            node). Of course the limitation here is that you have to each leaf in turn to determine if it is visible
+            rather than just following a list, but since this is only done once per frame this is not such a big
+            overhead.
+        */
+        int mVisCluster;
+
+        /** The axis-aligned box which bounds node if it is a leaf. */
+        AxisAlignedBox mBounds;
+        /** Number of face groups in this node if it is a leaf. */
+        int mNumFaceGroups;
+        /** Index to the part of the main leaf facegroup index buffer(held in BspLevel) for this leaf.
+            This leaf uses mNumFaceGroups from this pointer onwards. From here you use the index
+            in this buffer to look up the actual face.
+            Note that again for simplicity and bulk memory allocation the face
+            group list itself is allocated by the BspLevel for all nodes, and each leaf node is given a section of it to
+            work on. This saves lots of small memory allocations / deallocations which limits memory fragmentation.
+        */
+        int mFaceGroupStart;
+
+        IntersectingObjectSet mMovables;
+
+        NodeBrushList mSolidBrushes;
+    public:
+        const IntersectingObjectSet& getObjects(void) const { return mMovables; }
+
+
+    };
+
+
+}
+
+#endif

data/deps/include/OGRE/Plugins/BSPSceneManager/OgreBspPrerequisites.h

@@ -0,0 +1,65 @@
+/*
+-----------------------------------------------------------------------------
+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 __BspPrerequisites_H__
+#define __BspPrerequisites_H__
+
+#include "OgrePrerequisites.h"
+
+namespace Ogre {
+
+    // Predeclare classes
+
+    class BspLevel;
+    class BspNode;
+    class BspResourceManager;
+    class BspSceneManager;
+    class Quake3Level;
+    class Quake3ShaderManager;
+    class Quake3Shader;
+
+#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32) && !defined(OGRE_STATIC_LIB)
+#	ifdef OGRE_BSPPLUGIN_EXPORTS
+#		define _OgreBspPluginExport __declspec(dllexport)
+#	else
+#       if defined( __MINGW32__ )
+#           define _OgreBspPluginExport
+#       else
+#    		define _OgreBspPluginExport __declspec(dllimport)
+#       endif
+#   endif
+#elif defined ( OGRE_GCC_VISIBILITY )
+#    define _OgreBspPluginExport  __attribute__ ((visibility("default")))
+#else
+#	define _OgreBspPluginExport
+#endif	// OGRE_WIN32
+
+
+}
+
+
+#endif

data/deps/include/OGRE/Plugins/BSPSceneManager/OgreBspResourceManager.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-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 _BspLevelManager_H__
+#define _BspLevelManager_H__
+
+#include "OgreBspPrerequisites.h"
+#include "OgreResourceManager.h"
+#include "OgreSingleton.h"
+
+namespace Ogre {
+
+    /** Manages the locating and loading of BSP-based indoor levels.
+    Like other ResourceManager specialisations it manages the location and loading
+    of a specific type of resource, in this case files containing Binary
+    Space Partition (BSP) based level files e.g. Quake3 levels.</p>
+    However, note that unlike other ResourceManager implementations,
+    only 1 BspLevel resource is allowed to be loaded at one time. Loading
+    another automatically unloads the currently loaded level if any.
+    */
+    class BspResourceManager : public ResourceManager, public Singleton<BspResourceManager>
+    {
+    public:
+        BspResourceManager();
+        ~BspResourceManager();
+
+        /** Loads a BSP-based level from the named file.
+            Currently only supports loading of Quake3 .bsp files.
+        */
+        ResourcePtr load(const String& name, 
+            const String& group, bool isManual = false, 
+            ManualResourceLoader* loader = 0, const NameValuePairList* loadParams = 0);
+
+        /** Loads a BSP-based level from a stream.
+            Currently only supports loading of Quake3 .bsp files.
+        */
+        ResourcePtr load(DataStreamPtr& stream, const String& group);
+
+        /** 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 BspResourceManager& 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 BspResourceManager* getSingletonPtr(void);
+
+
+    protected:
+        /** @copydoc ResourceManager::createImpl. */
+        Resource* createImpl(const String& name, ResourceHandle handle, 
+            const String& group, bool isManual, ManualResourceLoader* loader, 
+            const NameValuePairList* createParams);
+
+        // Singleton managed by this class
+        Quake3ShaderManager *mShaderMgr;
+
+    };
+
+}
+
+#endif