ruby-ogre 0.0.1-x86-linux

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

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

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

@@ -0,0 +1,67 @@
+/*
+-----------------------------------------------------------------------------
+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 __BspSceneManagerPlugin_H__
+#define __BspSceneManagerPlugin_H__
+
+#include "OgrePlugin.h"
+#include "OgreBspSceneManager.h"
+#include "OgreBspResourceManager.h"
+
+namespace Ogre
+{
+
+	/** Plugin instance for BSPSceneManager */
+	class BspSceneManagerPlugin : public Plugin
+	{
+	public:
+		BspSceneManagerPlugin();
+
+
+		/// @copydoc Plugin::getName
+		const String& getName() const;
+
+		/// @copydoc Plugin::install
+		void install();
+
+		/// @copydoc Plugin::initialise
+		void initialise();
+
+		/// @copydoc Plugin::shutdown
+		void shutdown();
+
+		/// @copydoc Plugin::uninstall
+		void uninstall();
+	protected:
+		BspSceneManagerFactory* mBspFactory;
+		BspResourceManager* mBspResourceManager;
+
+
+	};
+}
+
+#endif

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

@@ -0,0 +1,79 @@
+/*
+-----------------------------------------------------------------------------
+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 __BSPSCENENODE_H__
+#define __BSPSCENENODE_H__
+
+#include "OgreBspPrerequisites.h"
+#include "OgreSceneNode.h"
+
+namespace Ogre {
+
+    /** Specialisation of SceneNode for the BspSceneManager.
+    @remarks
+        This specialisation of SceneNode is to enable information about the
+        leaf node in which any attached objects are held is stored for
+        use in the visibility determination. 
+    @par
+        Do not confuse this class with BspNode, which reflects nodes in the
+        BSP tree itself. This class is just like a regular SceneNode, except that
+        it should be locating BspNode leaf elements which objects should be included
+        in. Note that because objects are movable, and thus may very well be overlapping
+        the boundaries of more than one leaf, that it is possible that an object attached
+        to one BspSceneNode may actually be associated with more than one BspNode.
+    */
+    class BspSceneNode : public SceneNode
+    {
+	protected:
+		/// Overridden from SceneNode
+		void setInSceneGraph(bool inGraph);		
+    public:
+        BspSceneNode(SceneManager* creator) : SceneNode(creator) {}
+        BspSceneNode(SceneManager* creator, const String& name) 
+            : SceneNode(creator, name) {}
+        /// Overridden from Node
+        void _update(bool updateChildren, bool parentHasChanged);
+        /** Detaches the indexed object from this scene node.
+        @remarks
+            Detaches by index, see the alternate version to detach by name. Object indexes
+            may change as other objects are added / removed.
+        */
+        MovableObject* detachObject(unsigned short index);
+
+        /** Detaches the named object from this node and returns a pointer to it. */
+        MovableObject* detachObject(const String& name);
+
+        /** Detaches all objects attached to this node.
+        */
+        void detachAllObjects(void);
+
+
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,167 @@
+/*
+-----------------------------------------------------------------------------
+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 __Quake3Level_H__
+#define __Quake3Level_H__
+
+#include "OgreBspPrerequisites.h"
+#include "OgreQuake3Types.h"
+#include "OgreDataStream.h"
+
+
+namespace Ogre {
+
+    /** Support for loading and extracting data from a Quake3 level file.
+    This class implements the required methods for opening Quake3 level files
+    and extracting the pertinent data within. Ogre supports BSP based levels
+    through it's own BspLevel class, which is not specific to any file format,
+    so this class is here to source that data from the Quake3 format.</p>
+    Quake3 levels include far more than just data for rendering - typically the
+    <strong>leaves</strong> of the tree are used for rendering, and <strong>brushes,</strong>
+    are used to    define convex hulls made of planes for collision detection. There are also
+    <strong>entities</strong> which define non-visual elements like player start
+    points, triggers etc and <strong>models</strong> which are used for movable
+    scenery like doors and platforms. <strong>Shaders</strong> meanwhile are textures
+    with extra effects and 'content flags' indicating special properties like
+    water or lava.</p>
+    I will try to support as much of this as I can in Ogre, but I won't duplicate
+    the structure or necessarily use the same terminology. Quake3 is designed for a very specific
+    purpose and code structure, whereas Ogre is designed to be more flexible,
+    so for example I'm likely to separate game-related properties like surface flags
+    from the generics of materials in my implementation.</p>
+    This is a utility class only - a single call to loadFromChunk should be
+    enough. You should not expect the state of this object to be consistent
+    between calls, since it uses pointers to memory which may no longer
+    be valid after the original call. This is why it has no accessor methods
+    for reading it's internal state.
+    */
+	class Quake3Level : public ResourceAlloc
+    {
+    public:
+        Quake3Level();
+
+        /** Load just the header information from a Quake3 file. 
+        @remarks
+            This method loads just the header information from the 
+            Quake3 file, in order to estimate the loading time.
+        */
+        void loadHeaderFromStream(DataStreamPtr& inStream);
+
+        /** Reads Quake3 bsp data from a stream as read from the file.
+            Since ResourceManagers generally locate data in a variety of
+            places they typically manipulate them as a chunk of data, rather than
+            a file pointer since this is unsupported through compressed archives.</p>
+            Quake3 files are made up of a header (which contains version info and
+            a table of the contents) and 17 'lumps' i.e. sections of data,
+            the offsets to which are kept in the table of contents. The 17 types
+            are predefined (You can find them in OgreQuake3Types.h)
+
+            @param inStream Stream containing Quake3 data
+        */
+        void loadFromStream(DataStreamPtr& inStream);
+
+        /* Extracts the embedded lightmap texture data and loads them as textures.
+           Calling this method makes the lightmap texture data embedded in
+           the .bsp file available to the renderer. Lightmaps are extracted
+           and loaded as Texture objects (subclass specific to RenderSystem
+           subclass) and are named "@lightmap1", "@lightmap2" etc.
+        */
+        void extractLightmaps(void) const;
+
+        /** Utility function read the header and set up pointers. */
+        void initialise(bool headerOnly = false);
+        /** Utility function read the header and set up counters. */
+        void initialiseCounts(void);
+        /** Utility function read the header and set up pointers. */
+        void initialisePointers(void);
+
+        /** Utility function to return a pointer to a lump. */
+        void* getLump(int lumpType);
+        int getLumpSize(int lumpType);
+
+        /** Debug method. */
+        void dumpContents(void);
+
+        // Internal storage
+        // This is ALL temporary. Don't rely on it being static
+        MemoryDataStreamPtr mChunk;
+
+        // NB no brushes, fog or local lightvolumes yet
+        bsp_header_t* mHeader;
+        unsigned char* mLumpStart;
+
+        int* mElements; // vertex indexes for faces
+        int mNumElements;
+
+        void* mEntities;
+        int mNumEntities;
+
+        bsp_model_t* mModels;
+        int mNumModels;
+
+        bsp_node_t* mNodes;
+        int mNumNodes;
+
+        bsp_leaf_t* mLeaves;
+        int mNumLeaves;
+
+        int* mLeafFaces;     // Indexes to face groups by leaf
+        int mNumLeafFaces;
+
+        bsp_plane_t* mPlanes;
+        int mNumPlanes;
+
+        bsp_face_t* mFaces;      // Groups of faces
+        int mNumFaces;
+
+        bsp_vertex_t* mVertices;
+        int mNumVertices;
+
+        bsp_shader_t* mShaders;
+        int mNumShaders;
+
+        unsigned char* mLightmaps;
+        int mNumLightmaps;
+
+        bsp_vis_t* mVis;
+
+        bsp_brush_t* mBrushes;
+        int mNumBrushes;
+
+        bsp_brushside_t* mBrushSides;
+        int mNumBrushSides;
+
+        int* mLeafBrushes;      // Groups of indexes to brushes by leaf
+        int mNumLeafBrushes;
+
+
+
+    };
+}
+
+
+#endif