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

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

@@ -1,212 +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 _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

@@ -1,65 +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 __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

@@ -1,110 +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 _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

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

@@ -1,280 +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 __BspSceneManager_H__
-#define __BspSceneManager_H__
-
-
-#include "OgreBspPrerequisites.h"
-#include "OgreSceneManager.h"
-#include "OgreStaticFaceGroup.h"
-#include "OgreRenderOperation.h"
-#include "OgreBspLevel.h"
-#include <set>
-
-
-namespace Ogre {
-
-
-    /** Specialisation of the SceneManager class to deal with indoor scenes
-        based on a BSP tree.
-        This class refines the behaviour of the default SceneManager to manage
-        a scene whose bulk of geometry is made up of an indoor environment which
-        is organised by a Binary Space Partition (BSP) tree. </p>
-        A BSP tree progressively subdivides the space using planes which are the nodes of the tree.
-        At some point we stop subdividing and everything in the remaining space is part of a 'leaf' which
-        contains a number of polygons. Typically we traverse the tree to locate the leaf in which a
-        point in space is (say the camera origin) and work from there. A second structure, the
-        Potentially Visible Set, tells us which other leaves can been seen from this
-        leaf, and we test their bounding boxes against the camera frustum to see which
-        we need to draw. Leaves are also a good place to start for collision detection since
-        they divide the level into discrete areas for testing.</p>
-        This BSP and PVS technique has been made famous by engines such as Quake and Unreal. Ogre
-        provides support for loading Quake3 level files to populate your world through this class,
-        by calling the BspSceneManager::setWorldGeometry. Note that this interface is made
-        available at the top level of the SceneManager class so you don't have to write your code
-        specifically for this class - just call Root::getSceneManager passing a SceneType of ST_INTERIOR
-        and in the current implementation you will get a BspSceneManager silently disguised as a
-        standard SceneManager.
-    */
-    class BspSceneManager : public SceneManager
-    {
-    protected:
-
-        // World geometry
-        BspLevelPtr mLevel;
-
-        // State variables for rendering WIP
-        // Set of face groups (by index) already included
-		typedef set<int>::type FaceGroupSet;
-        FaceGroupSet mFaceGroupSet;
-        // Material -> face group hashmap
-		typedef map<Material*, vector<StaticFaceGroup*>::type, materialLess >::type MaterialFaceGroupMap;
-        MaterialFaceGroupMap mMatFaceGroupMap;
-
-        RenderOperation mRenderOp;
-
-        // Debugging features
-        bool mShowNodeAABs;
-        RenderOperation mAABGeometry;
-
-        /** Walks the BSP tree looking for the node which the camera
-            is in, and tags any geometry which is in a visible leaf for
-            later processing.
-            @param camera Pointer to the viewpoint.
-            @return The BSP node the camera was found in, for info.
-        */
-        BspNode* walkTree(Camera* camera, VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters);
-        /** Tags geometry in the leaf specified for later rendering. */
-        void processVisibleLeaf(BspNode* leaf, Camera* cam, 
-			VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters);
-
-        /** Caches a face group for imminent rendering. */
-        unsigned int cacheGeometry(unsigned int* pIndexes, const StaticFaceGroup* faceGroup);
-
-        /** Frees up allocated memory for geometry caches. */
-        void freeMemory(void);
-
-        /** Adds a bounding box to draw if turned on. */
-        void addBoundingBox(const AxisAlignedBox& aab, bool visible);
-
-        /** Renders the static level geometry tagged in walkTree. */
-        void renderStaticGeometry(void);
-
-		/** @copydoc SceneManager::clearScene */
-		void clearScene(void);
-
-		// Overridden so we can manually render world geometry
-		bool fireRenderQueueEnded(uint8 id, const String& invocation);
-
-		typedef set<const MovableObject*>::type MovablesForRendering;
-        MovablesForRendering mMovablesForRendering;
-
-    public:
-        BspSceneManager(const String& name);
-        ~BspSceneManager();
-
-
-		/// @copydoc SceneManager::getTypeName
-		const String& getTypeName(void) const;
-
-        /** Specialised from SceneManager to support Quake3 bsp files. */
-        void setWorldGeometry(const String& filename);
-
-        /** Specialised from SceneManager to support Quake3 bsp files. */
-        size_t estimateWorldGeometry(const String& filename);
-        
-        /** Specialised from SceneManager to support Quake3 bsp files. */
-        void setWorldGeometry(DataStreamPtr& stream, 
-			const String& typeName = StringUtil::BLANK);
-
-        /** Specialised from SceneManager to support Quake3 bsp files. */
-        size_t estimateWorldGeometry(DataStreamPtr& stream, 
-			const String& typeName = StringUtil::BLANK);
-
-		/** Tells the manager whether to draw the axis-aligned boxes that surround
-            nodes in the Bsp tree. For debugging purposes.
-        */
-        void showNodeBoxes(bool show);
-
-        /** Specialised to suggest viewpoints. */
-        ViewPoint getSuggestedViewpoint(bool random = false);
-
-        const BspLevelPtr& getLevel(void) {return mLevel; }
-
-        /** Overriden from SceneManager. */
-        void _findVisibleObjects(Camera* cam, VisibleObjectsBoundsInfo* visibleBounds, 
-			bool onlyShadowCasters);
-
-        /** Creates a specialized BspSceneNode */
-        SceneNode * createSceneNodeImpl ( void );
-        /** Creates a specialized BspSceneNode */
-        SceneNode * createSceneNodeImpl ( const String &name );
-
-        /** Internal method for tagging BspNodes with objects which intersect them. */
-        void _notifyObjectMoved(const MovableObject* mov, const Vector3& pos);
-		/** Internal method for notifying the level that an object has been detached from a node */
-		void _notifyObjectDetached(const MovableObject* mov);
-
-        /** Creates an AxisAlignedBoxSceneQuery for this scene manager. 
-        @remarks
-            This method creates a new instance of a query object for this scene manager, 
-            for an axis aligned box region. See SceneQuery and AxisAlignedBoxSceneQuery 
-            for full details.
-        @par
-            The instance returned from this method must be destroyed by calling
-            SceneManager::destroyQuery when it is no longer required.
-        @param box Details of the box which describes the region for this query.
-        @param mask The query mask to apply to this query; can be used to filter out
-            certain objects; see SceneQuery for details.
-        */
-        /*
-        virtual AxisAlignedBoxSceneQuery* 
-            createAABBQuery(const AxisAlignedBox& box, unsigned long mask = 0xFFFFFFFF);
-        */
-        /** Creates a SphereSceneQuery for this scene manager. 
-        @remarks
-            This method creates a new instance of a query object for this scene manager, 
-            for a spherical region. See SceneQuery and SphereSceneQuery 
-            for full details.
-        @par
-            The instance returned from this method must be destroyed by calling
-            SceneManager::destroyQuery when it is no longer required.
-        @param sphere Details of the sphere which describes the region for this query.
-        @param mask The query mask to apply to this query; can be used to filter out
-            certain objects; see SceneQuery for details.
-        */
-        /*
-        virtual SphereSceneQuery* 
-            createSphereQuery(const Sphere& sphere, unsigned long mask = 0xFFFFFFFF);
-        */
-        /** Creates a RaySceneQuery for this scene manager. 
-        @remarks
-            This method creates a new instance of a query object for this scene manager, 
-            looking for objects which fall along a ray. See SceneQuery and RaySceneQuery 
-            for full details.
-        @par
-            The instance returned from this method must be destroyed by calling
-            SceneManager::destroyQuery when it is no longer required.
-        @param ray Details of the ray which describes the region for this query.
-        @param mask The query mask to apply to this query; can be used to filter out
-            certain objects; see SceneQuery for details.
-        */
-        virtual RaySceneQuery* 
-            createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF);
-        /** Creates an IntersectionSceneQuery for this scene manager. 
-        @remarks
-            This method creates a new instance of a query object for locating
-            intersecting objects. See SceneQuery and IntersectionSceneQuery
-            for full details.
-        @par
-            The instance returned from this method must be destroyed by calling
-            SceneManager::destroyQuery when it is no longer required.
-        @param mask The query mask to apply to this query; can be used to filter out
-            certain objects; see SceneQuery for details.
-        */
-        virtual IntersectionSceneQuery* 
-            createIntersectionQuery(unsigned long mask = 0xFFFFFFFF);
-
-    };
-
-    /** BSP specialisation of IntersectionSceneQuery */
-    class BspIntersectionSceneQuery : public DefaultIntersectionSceneQuery
-    {
-    public:
-        BspIntersectionSceneQuery(SceneManager* creator);
-
-        /** See IntersectionSceneQuery. */
-        void execute(IntersectionSceneQueryListener* listener);
-
-    };
-
-    /** BSP specialisation of RaySceneQuery */
-    class BspRaySceneQuery : public DefaultRaySceneQuery
-    {
-    public:
-        BspRaySceneQuery(SceneManager* creator);
-        ~BspRaySceneQuery();
-
-        /** See RaySceneQuery. */
-        void execute(RaySceneQueryListener* listener);
-    protected:
-        /// Set for eliminating duplicates since objects can be in > 1 node
-		set<MovableObject*>::type mObjsThisQuery;
-        /// list of the last single intersection world fragments (derived)
-		vector<SceneQuery::WorldFragment*>::type mSingleIntersections;
-
-        void clearTemporaries(void);
-        /** Internal processing of a single node.
-        @return true if we should continue tracing, false otherwise
-        */
-        bool processNode(const BspNode* node, const Ray& tracingRay, RaySceneQueryListener* listener,
-            Real maxDistance = Math::POS_INFINITY, Real traceDistance = 0.0f);
-        /** Internal processing of a single leaf.
-        @return true if we should continue tracing, false otherwise
-        */
-        bool processLeaf(const BspNode* node, const Ray& tracingRay, RaySceneQueryListener* listener,
-            Real maxDistance = Math::POS_INFINITY, Real traceDistance = 0.0f);
-
-    };
-
-	/// Factory for BspSceneManager
-	class BspSceneManagerFactory : public SceneManagerFactory
-	{
-	protected:
-		void initMetaData(void) const;
-	public:
-		BspSceneManagerFactory() {}
-		~BspSceneManagerFactory() {}
-		/// Factory type name
-		static const String FACTORY_TYPE_NAME;
-		SceneManager* createInstance(const String& instanceName);
-		void destroyInstance(SceneManager* instance);
-	};
-}
-
-#endif