shattered_ogrerb 0.5.0.1

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

@@ -0,0 +1,62 @@
+/*
+-----------------------------------------------------------------------------
+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 _ArchiveFactory_H__
+#define _ArchiveFactory_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreFactoryObj.h"
+
+namespace Ogre {
+
+    /** Abstract factory class, archive codec plugins can register concrete
+        subclasses of this.
+        @remarks
+            All access to 'archives' (collections of files, compressed or
+            just folders, maybe even remote) is managed via the abstract
+            Archive class. Plugins are expected to provide the
+            implementation for the actual codec itself, but because a
+            subclass of Archive has to be created for every archive, a
+            factory class is required to create the appropriate subclass.
+        @par
+            So archive plugins create a subclass of Archive AND a subclass
+            of ArchiveFactory which creates instances of the Archive
+            subclass. See the 'Zip' and 'FileSystem' plugins for examples.
+            Each Archive and ArchiveFactory subclass pair deal with a
+            single archive type (identified by a string).
+    */
+    class _OgreExport ArchiveFactory : public FactoryObj< Archive >
+    {
+    public:
+        // No methods, must just override all methods inherited from FactoryObj
+    };
+
+} // namespace
+
+#endif

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

@@ -0,0 +1,130 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-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 _ArchiveManager_H__
+#define _ArchiveManager_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreResourceManager.h"
+#include "OgreSingleton.h"
+
+namespace Ogre {
+
+    /** This class manages the available ArchiveFactory plugins. 
+    */
+    class _OgreExport ArchiveManager : public Singleton<ArchiveManager>
+    {
+    protected:
+        typedef std::map<String, ArchiveFactory*> ArchiveFactoryMap;
+        /// Factories available to create archives, indexed by archive type (String identifier e.g. 'Zip')
+        ArchiveFactoryMap mArchFactories;
+        /// Currently loaded archives
+        typedef std::map<String, Archive*> ArchiveMap;
+        ArchiveMap mArchives;
+
+    public:
+        /** Default constructor - should never get called by a client app.
+        */
+        ArchiveManager() {}
+        /** Default destructor.
+        */
+        virtual ~ArchiveManager();
+
+        /** Opens an archive for file reading.
+            @remarks
+                The archives are created using class factories within
+                extension libraries.
+            @param filename
+                The filename that will be opened
+            @param refLibrary
+                The library that contains the data-handling code
+            @returns
+                If the function succeeds, a valid pointer to an Archive
+                object is returened.
+            @par
+                If the function fails, an exception is thrown.
+        */
+        Archive* load( const String& filename, const String& archiveType);
+
+		/** Unloads an archive.
+		@remarks
+			You must ensure that this archive is not being used before removing it.
+		*/
+		void unload(Archive* arch);
+		/** Unloads an archive by name.
+		@remarks
+			You must ensure that this archive is not being used before removing it.
+		*/
+		void unload(const String& filename);
+
+
+        /** Adds a new ArchiveFactory to the list of available factories.
+            @remarks
+                Plugin developers who add new archive codecs need to call
+                this after defining their ArchiveFactory subclass and
+                Archive subclasses for their archive type.
+        */
+        void addArchiveFactory(ArchiveFactory* factory);
+        /** 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 ArchiveManager& 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 ArchiveManager* getSingletonPtr(void);
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,225 @@
+/*
+-----------------------------------------------------------------------------
+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 __AutoParamDataSource_H_
+#define __AutoParamDataSource_H_
+
+#include "OgrePrerequisites.h"
+#include "OgreCommon.h"
+#include "OgreMatrix4.h"
+#include "OgreVector4.h"
+#include "OgreLight.h"
+#include "OgreColourValue.h"
+
+namespace Ogre {
+
+	// forward decls
+	struct VisibleObjectsBoundsInfo;
+
+
+    /** This utility class is used to hold the information used to generate the matrices
+    and other information required to automatically populate GpuProgramParameters.
+    @remarks
+        This class exercises a lazy-update scheme in order to avoid having to update all
+        the information a GpuProgramParameters class could possibly want all the time. 
+        It relies on the SceneManager to update it when the base data has changed, and
+        will calculate concatenated matrices etc only when required, passing back precalculated
+        matrices when they are requested more than once when the underlying information has
+        not altered.
+    */
+    class _OgreExport AutoParamDataSource
+    {
+    protected:
+        mutable Matrix4 mWorldMatrix[256];
+        mutable size_t mWorldMatrixCount;
+        mutable const Matrix4* mWorldMatrixArray;
+        mutable Matrix4 mWorldViewMatrix;
+        mutable Matrix4 mViewProjMatrix;
+        mutable Matrix4 mWorldViewProjMatrix;
+        mutable Matrix4 mInverseWorldMatrix;
+        mutable Matrix4 mInverseWorldViewMatrix;
+        mutable Matrix4 mInverseViewMatrix;
+        mutable Matrix4 mInverseTransposeWorldMatrix;
+        mutable Matrix4 mInverseTransposeWorldViewMatrix;
+        mutable Vector4 mCameraPositionObjectSpace;
+        mutable Matrix4 mTextureViewProjMatrix[OGRE_MAX_SIMULTANEOUS_LIGHTS];
+        mutable Matrix4 mViewMatrix;
+        mutable Matrix4 mProjectionMatrix;
+		mutable Real mDirLightExtrusionDistance;
+        mutable Vector4 mCameraPosition;
+
+        mutable bool mWorldMatrixDirty;
+        mutable bool mViewMatrixDirty;
+        mutable bool mProjMatrixDirty;
+        mutable bool mWorldViewMatrixDirty;
+        mutable bool mViewProjMatrixDirty;
+        mutable bool mWorldViewProjMatrixDirty;
+        mutable bool mInverseWorldMatrixDirty;
+        mutable bool mInverseWorldViewMatrixDirty;
+        mutable bool mInverseViewMatrixDirty;
+        mutable bool mInverseTransposeWorldMatrixDirty;
+        mutable bool mInverseTransposeWorldViewMatrixDirty;
+        mutable bool mCameraPositionObjectSpaceDirty;
+        mutable bool mCameraPositionDirty;
+        mutable bool mTextureViewProjMatrixDirty[OGRE_MAX_SIMULTANEOUS_LIGHTS];
+		mutable ColourValue mAmbientLight;
+        mutable ColourValue mFogColour;
+        mutable Vector4 mFogParams;
+        mutable int mPassNumber;
+		mutable Vector4 mSceneDepthRange;
+		mutable bool mSceneDepthRangeDirty;
+		// Ordered by light, populated on demand, dirtied when lights change
+		mutable std::vector<Vector4> mShadowCamDepthRanges;
+		mutable bool mShadowCamDepthRangesDirty;
+
+        const Renderable* mCurrentRenderable;
+        const Camera* mCurrentCamera;
+        const LightList* mCurrentLightList;
+        const Frustum* mCurrentTextureProjector[OGRE_MAX_SIMULTANEOUS_LIGHTS];
+        const RenderTarget* mCurrentRenderTarget;
+        const Viewport* mCurrentViewport;
+		const SceneManager* mCurrentSceneManager;
+		const VisibleObjectsBoundsInfo* mMainCamBoundsInfo;
+        const Pass* mCurrentPass;
+
+        Light mBlankLight;
+    public:
+        AutoParamDataSource();
+        ~AutoParamDataSource();
+        /** Updates the current renderable */
+        void setCurrentRenderable(const Renderable* rend);
+        /** Sets the world matrices, avoid query from renderable again */
+        void setWorldMatrices(const Matrix4* m, size_t count);
+        /** Updates the current camera */
+        void setCurrentCamera(const Camera* cam);
+        /** Sets the light list that should be used */
+        void setCurrentLightList(const LightList* ll);
+        /** Sets the current texture projector for a index */
+        void setTextureProjector(const Frustum* frust, size_t index);
+        /** Sets the current render target */
+        void setCurrentRenderTarget(const RenderTarget* target);
+        /** Sets the current viewport */
+        void setCurrentViewport(const Viewport* viewport);
+		/** Sets the shadow extrusion distance to be used for point lights. */
+		void setShadowDirLightExtrusionDistance(Real dist);
+		/** Sets the main camera's scene bounding information */
+		void setMainCamBoundsInfo(VisibleObjectsBoundsInfo* info);
+		/** Set the current scene manager for enquiring on demand */
+		void setCurrentSceneManager(const SceneManager* sm);
+        /** Sets the current pass */
+        void setCurrentPass(const Pass* pass);
+
+
+
+        const Matrix4& getWorldMatrix(void) const;
+        const Matrix4* getWorldMatrixArray(void) const;
+        size_t getWorldMatrixCount(void) const;
+        const Matrix4& getViewMatrix(void) const;
+        const Matrix4& getViewProjectionMatrix(void) const;
+        const Matrix4& getProjectionMatrix(void) const;
+        const Matrix4& getWorldViewProjMatrix(void) const;
+        const Matrix4& getWorldViewMatrix(void) const;
+        const Matrix4& getInverseWorldMatrix(void) const;
+        const Matrix4& getInverseWorldViewMatrix(void) const;
+        const Matrix4& getInverseViewMatrix(void) const;
+        const Matrix4& getInverseTransposeWorldMatrix(void) const;
+        const Matrix4& getInverseTransposeWorldViewMatrix(void) const;
+        const Vector4& getCameraPosition(void) const;
+        const Vector4& getCameraPositionObjectSpace(void) const;
+        /** Get the light which is 'index'th closest to the current object */
+        const Light& getLight(size_t index) const;
+		void setAmbientLightColour(const ColourValue& ambient);
+		const ColourValue& getAmbientLightColour(void) const;
+        const ColourValue& getSurfaceAmbientColour(void) const;
+        const ColourValue& getSurfaceDiffuseColour(void) const;
+        const ColourValue& getSurfaceSpecularColour(void) const;
+        const ColourValue& getSurfaceEmissiveColour(void) const;
+        Real getSurfaceShininess(void) const;
+        ColourValue getDerivedAmbientLightColour(void) const;
+        ColourValue getDerivedSceneColour(void) const;
+        void setFog(FogMode mode, const ColourValue& colour, Real expDensity, Real linearStart, Real linearEnd);
+        const ColourValue& getFogColour(void) const;
+        const Vector4& getFogParams(void) const;
+        const Matrix4& getTextureViewProjMatrix(size_t index) const;
+        const RenderTarget* getCurrentRenderTarget(void) const;
+        const Renderable* getCurrentRenderable(void) const;
+        const Pass* getCurrentPass(void) const;
+        Vector4 getTextureSize(size_t index) const;
+        Vector4 getInverseTextureSize(size_t index) const;
+        Vector4 getPackedTextureSize(size_t index) const;
+		Real getShadowExtrusionDistance(void) const;
+		const Vector4& getSceneDepthRange() const;
+		const Vector4& getShadowSceneDepthRange(size_t lightIndex) const;
+		Matrix4 getInverseViewProjMatrix(void) const;
+		Matrix4 getInverseTransposeViewProjMatrix() const;
+		Matrix4 getTransposeViewProjMatrix() const;
+		Matrix4 getTransposeViewMatrix() const;
+        Matrix4 getInverseTransposeViewMatrix() const;
+		Matrix4 getTransposeProjectionMatrix() const;
+		Matrix4 getInverseProjectionMatrix() const;
+		Matrix4 getInverseTransposeProjectionMatrix() const;
+		Matrix4 getTransposeWorldViewProjMatrix() const;
+		Matrix4 getInverseWorldViewProjMatrix() const;
+		Matrix4 getInverseTransposeWorldViewProjMatrix() const;
+		Matrix4 getTransposeWorldViewMatrix() const;
+		Matrix4 getTransposeWorldMatrix() const;
+        Real getTime(void) const;
+		Real getTime_0_X(Real x) const;
+		Real getCosTime_0_X(Real x) const;
+		Real getSinTime_0_X(Real x) const;
+		Real getTanTime_0_X(Real x) const;
+		Vector4 getTime_0_X_packed(Real x) const;
+		Real getTime_0_1(Real x) const;
+		Real getCosTime_0_1(Real x) const;
+		Real getSinTime_0_1(Real x) const;
+		Real getTanTime_0_1(Real x) const;
+		Vector4 getTime_0_1_packed(Real x) const;
+		Real getTime_0_2Pi(Real x) const;
+		Real getCosTime_0_2Pi(Real x) const;
+		Real getSinTime_0_2Pi(Real x) const;
+		Real getTanTime_0_2Pi(Real x) const;
+		Vector4 getTime_0_2Pi_packed(Real x) const;
+        Real getFrameTime(void) const;
+		Real getFPS() const;
+		Real getViewportWidth() const;
+		Real getViewportHeight() const;
+		Real getInverseViewportWidth() const;
+		Real getInverseViewportHeight() const;
+		Vector3 getViewDirection() const;
+		Vector3 getViewSideVector() const;
+		Vector3 getViewUpVector() const;
+		Real getFOV() const;
+		Real getNearClipDistance() const;
+		Real getFarClipDistance() const;
+        int getPassNumber(void) const;
+        void setPassNumber(const int passNumber);
+        void incPassNumber(void);
+    };
+}
+
+#endif

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

@@ -0,0 +1,790 @@
+/*
+-----------------------------------------------------------------------------
+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 __AxisAlignedBox_H_
+#define __AxisAlignedBox_H_
+
+// Precompiler options
+#include "OgrePrerequisites.h"
+
+#include "OgreVector3.h"
+#include "OgreMatrix4.h"
+
+namespace Ogre {
+
+	/** A 3D box aligned with the x/y/z axes.
+	@remarks
+	This class represents a simple box which is aligned with the
+	axes. Internally it only stores 2 points as the extremeties of
+	the box, one which is the minima of all 3 axes, and the other
+	which is the maxima of all 3 axes. This class is typically used
+	for an axis-aligned bounding box (AABB) for collision and
+	visibility determination.
+	*/
+	class _OgreExport AxisAlignedBox
+	{
+	protected:
+		enum Extent
+		{
+			EXTENT_NULL,
+			EXTENT_FINITE,
+			EXTENT_INFINITE
+		};
+
+		Vector3 mMinimum;
+		Vector3 mMaximum;
+		Extent mExtent;
+		mutable Vector3* mpCorners;
+
+	public:
+		/*
+		1-----2
+		/|    /|
+		/ |   / |
+		5-----4  |
+		|  0--|--3
+		| /   | /
+		|/    |/
+		6-----7
+		*/
+		typedef enum {
+			FAR_LEFT_BOTTOM = 0,
+			FAR_LEFT_TOP = 1,
+			FAR_RIGHT_TOP = 2,
+			FAR_RIGHT_BOTTOM = 3,
+			NEAR_RIGHT_BOTTOM = 7,
+			NEAR_LEFT_BOTTOM = 6,
+			NEAR_LEFT_TOP = 5,
+			NEAR_RIGHT_TOP = 4
+		} CornerEnum;
+		inline AxisAlignedBox() : mpCorners(0)
+		{
+			// Default to a null box 
+			setMinimum( -0.5, -0.5, -0.5 );
+			setMaximum( 0.5, 0.5, 0.5 );
+			mExtent = EXTENT_NULL;
+		}
+
+		inline AxisAlignedBox(const AxisAlignedBox & rkBox) : mpCorners(0)
+		{
+			if (rkBox.isNull())
+				setNull();
+			else if (rkBox.isInfinite())
+				setInfinite();
+			else
+				setExtents( rkBox.mMinimum, rkBox.mMaximum );
+		}
+
+		inline AxisAlignedBox( const Vector3& min, const Vector3& max ) : mpCorners(0)
+		{
+			setExtents( min, max );
+		}
+
+		inline AxisAlignedBox(
+			Real mx, Real my, Real mz,
+			Real Mx, Real My, Real Mz ) : mpCorners(0)
+		{
+			setExtents( mx, my, mz, Mx, My, Mz );
+		}
+
+		AxisAlignedBox& operator=(const AxisAlignedBox& rhs)
+		{
+			// Specifically override to avoid copying mpCorners
+			if (rhs.isNull())
+				setNull();
+			else if (rhs.isInfinite())
+				setInfinite();
+			else
+				setExtents(rhs.mMinimum, rhs.mMaximum);
+
+			return *this;
+		}
+
+		~AxisAlignedBox()
+		{
+			if (mpCorners)
+				delete [] mpCorners;
+		}
+
+
+		/** Gets the minimum corner of the box.
+		*/
+		inline const Vector3& getMinimum(void) const
+		{ 
+			return mMinimum; 
+		}
+
+		/** Gets a modifiable version of the minimum
+		corner of the box.
+		*/
+		inline Vector3& getMinimum(void)
+		{ 
+			return mMinimum; 
+		}
+
+		/** Gets the maximum corner of the box.
+		*/
+		inline const Vector3& getMaximum(void) const
+		{ 
+			return mMaximum;
+		}
+
+		/** Gets a modifiable version of the maximum
+		corner of the box.
+		*/
+		inline Vector3& getMaximum(void)
+		{ 
+			return mMaximum;
+		}
+
+
+		/** Sets the minimum corner of the box.
+		*/
+		inline void setMinimum( const Vector3& vec )
+		{
+			mExtent = EXTENT_FINITE;
+			mMinimum = vec;
+		}
+
+		inline void setMinimum( Real x, Real y, Real z )
+		{
+			mExtent = EXTENT_FINITE;
+			mMinimum.x = x;
+			mMinimum.y = y;
+			mMinimum.z = z;
+		}
+
+		/** Changes one of the components of the minimum corner of the box
+		used to resize only one dimension of the box
+		*/
+		inline void setMinimumX(Real x)
+		{
+			mMinimum.x = x;
+		}
+
+		inline void setMinimumY(Real y)
+		{
+			mMinimum.y = y;
+		}
+
+		inline void setMinimumZ(Real z)
+		{
+			mMinimum.z = z;
+		}
+
+		/** Sets the maximum corner of the box.
+		*/
+		inline void setMaximum( const Vector3& vec )
+		{
+			mExtent = EXTENT_FINITE;
+			mMaximum = vec;
+		}
+
+		inline void setMaximum( Real x, Real y, Real z )
+		{
+			mExtent = EXTENT_FINITE;
+			mMaximum.x = x;
+			mMaximum.y = y;
+			mMaximum.z = z;
+		}
+
+		/** Changes one of the components of the maximum corner of the box
+		used to resize only one dimension of the box
+		*/
+		inline void setMaximumX( Real x )
+		{
+			mMaximum.x = x;
+		}
+
+		inline void setMaximumY( Real y )
+		{
+			mMaximum.y = y;
+		}
+
+		inline void setMaximumZ( Real z )
+		{
+			mMaximum.z = z;
+		}
+
+		/** Sets both minimum and maximum extents at once.
+		*/
+		inline void setExtents( const Vector3& min, const Vector3& max )
+		{
+            assert( (min.x <= max.x && min.y <= max.y && min.z <= max.z) &&
+                "The minimum corner of the box must be less than or equal to maximum corner" );
+
+			mExtent = EXTENT_FINITE;
+			mMinimum = min;
+			mMaximum = max;
+		}
+
+		inline void setExtents(
+			Real mx, Real my, Real mz,
+			Real Mx, Real My, Real Mz )
+		{
+            assert( (mx <= Mx && my <= My && mz <= Mz) &&
+                "The minimum corner of the box must be less than or equal to maximum corner" );
+
+			mExtent = EXTENT_FINITE;
+
+			mMinimum.x = mx;
+			mMinimum.y = my;
+			mMinimum.z = mz;
+
+			mMaximum.x = Mx;
+			mMaximum.y = My;
+			mMaximum.z = Mz;
+
+		}
+
+		/** Returns a pointer to an array of 8 corner points, useful for
+		collision vs. non-aligned objects.
+		@remarks
+		If the order of these corners is important, they are as
+		follows: The 4 points of the minimum Z face (note that
+		because Ogre uses right-handed coordinates, the minimum Z is
+		at the 'back' of the box) starting with the minimum point of
+		all, then anticlockwise around this face (if you are looking
+		onto the face from outside the box). Then the 4 points of the
+		maximum Z face, starting with maximum point of all, then
+		anticlockwise around this face (looking onto the face from
+		outside the box). Like this:
+		<pre>
+		1-----2
+		/|    /|
+		/ |   / |
+		5-----4  |
+		|  0--|--3
+		| /   | /
+		|/    |/
+		6-----7
+		</pre>
+		@remarks as this implementation uses a static member, make sure to use your own copy !
+		*/
+		inline const Vector3* getAllCorners(void) const
+		{
+			assert( (mExtent == EXTENT_FINITE) && "Can't get corners of a null or infinite AAB" );
+
+			// The order of these items is, using right-handed co-ordinates:
+			// Minimum Z face, starting with Min(all), then anticlockwise
+			//   around face (looking onto the face)
+			// Maximum Z face, starting with Max(all), then anticlockwise
+			//   around face (looking onto the face)
+			// Only for optimization/compatibility.
+			if (!mpCorners)
+				mpCorners = new Vector3[8];
+
+			mpCorners[0] = mMinimum;
+			mpCorners[1].x = mMinimum.x; mpCorners[1].y = mMaximum.y; mpCorners[1].z = mMinimum.z;
+			mpCorners[2].x = mMaximum.x; mpCorners[2].y = mMaximum.y; mpCorners[2].z = mMinimum.z;
+			mpCorners[3].x = mMaximum.x; mpCorners[3].y = mMinimum.y; mpCorners[3].z = mMinimum.z;            
+
+			mpCorners[4] = mMaximum;
+			mpCorners[5].x = mMinimum.x; mpCorners[5].y = mMaximum.y; mpCorners[5].z = mMaximum.z;
+			mpCorners[6].x = mMinimum.x; mpCorners[6].y = mMinimum.y; mpCorners[6].z = mMaximum.z;
+			mpCorners[7].x = mMaximum.x; mpCorners[7].y = mMinimum.y; mpCorners[7].z = mMaximum.z;
+
+			return mpCorners;
+		}
+
+		/** gets the position of one of the corners
+		*/
+		Vector3 getCorner(CornerEnum cornerToGet)
+		{
+			switch(cornerToGet)
+			{
+			case FAR_LEFT_BOTTOM:
+				return mMinimum;
+			case FAR_LEFT_TOP:
+				return Vector3(mMinimum.x, mMaximum.y, mMinimum.z);
+			case FAR_RIGHT_TOP:
+				return Vector3(mMaximum.x, mMaximum.y, mMinimum.z);
+			case FAR_RIGHT_BOTTOM:
+				return Vector3(mMaximum.x, mMinimum.y, mMinimum.z);
+			case NEAR_RIGHT_BOTTOM:
+				return Vector3(mMaximum.x, mMinimum.y, mMaximum.z);
+			case NEAR_LEFT_BOTTOM:
+				return Vector3(mMinimum.x, mMinimum.y, mMaximum.z);
+			case NEAR_LEFT_TOP:
+				return Vector3(mMinimum.x, mMaximum.y, mMaximum.z);
+			case NEAR_RIGHT_TOP:
+				return mMaximum;
+			default:
+				return Vector3();
+			}
+		}
+
+		_OgreExport friend std::ostream& operator<<( std::ostream& o, const AxisAlignedBox aab )
+		{
+			switch (aab.mExtent)
+			{
+			case EXTENT_NULL:
+				o << "AxisAlignedBox(null)";
+				return o;
+
+			case EXTENT_FINITE:
+				o << "AxisAlignedBox(min=" << aab.mMinimum << ", max=" << aab.mMaximum << ")";
+				return o;
+
+			case EXTENT_INFINITE:
+				o << "AxisAlignedBox(infinite)";
+				return o;
+
+			default: // shut up compiler
+				assert( false && "Never reached" );
+				return o;
+			}
+		}
+
+		/** Merges the passed in box into the current box. The result is the
+		box which encompasses both.
+		*/
+		void merge( const AxisAlignedBox& rhs )
+		{
+			// Do nothing if rhs null, or this is infinite
+			if ((rhs.mExtent == EXTENT_NULL) || (mExtent == EXTENT_INFINITE))
+			{
+				return;
+			}
+			// Otherwise if rhs is infinite, make this infinite, too
+			else if (rhs.mExtent == EXTENT_INFINITE)
+			{
+				mExtent = EXTENT_INFINITE;
+			}
+			// Otherwise if current null, just take rhs
+			else if (mExtent == EXTENT_NULL)
+			{
+				setExtents(rhs.mMinimum, rhs.mMaximum);
+			}
+			// Otherwise merge
+			else
+			{
+				Vector3 min = mMinimum;
+				Vector3 max = mMaximum;
+				max.makeCeil(rhs.mMaximum);
+				min.makeFloor(rhs.mMinimum);
+
+				setExtents(min, max);
+			}
+
+		}
+
+		/** Extends the box to encompass the specified point (if needed).
+		*/
+		inline void merge( const Vector3& point )
+		{
+			switch (mExtent)
+			{
+			case EXTENT_NULL: // if null, use this point
+				setExtents(point, point);
+				return;
+
+			case EXTENT_FINITE:
+				mMaximum.makeCeil(point);
+				mMinimum.makeFloor(point);
+				return;
+
+			case EXTENT_INFINITE: // if infinite, makes no difference
+				return;
+			}
+
+			assert( false && "Never reached" );
+		}
+
+		/** Transforms the box according to the matrix supplied.
+		@remarks
+		By calling this method you get the axis-aligned box which
+		surrounds the transformed version of this box. Therefore each
+		corner of the box is transformed by the matrix, then the
+		extents are mapped back onto the axes to produce another
+		AABB. Useful when you have a local AABB for an object which
+		is then transformed.
+		*/
+		inline void transform( const Matrix4& matrix )
+		{
+			// Do nothing if current null or infinite
+			if( mExtent != EXTENT_FINITE )
+				return;
+
+			Vector3 oldMin, oldMax, currentCorner;
+
+			// Getting the old values so that we can use the existing merge method.
+			oldMin = mMinimum;
+			oldMax = mMaximum;
+
+			// We sequentially compute the corners in the following order :
+			// 0, 6, 5, 1, 2, 4 ,7 , 3
+			// This sequence allows us to only change one member at a time to get at all corners.
+
+			// For each one, we transform it using the matrix
+			// Which gives the resulting point and merge the resulting point.
+
+			// First corner 
+			// min min min
+			currentCorner = oldMin;
+			merge( matrix * currentCorner );
+
+			// min,min,max
+			currentCorner.z = oldMax.z;
+			merge( matrix * currentCorner );
+
+			// min max max
+			currentCorner.y = oldMax.y;
+			merge( matrix * currentCorner );
+
+			// min max min
+			currentCorner.z = oldMin.z;
+			merge( matrix * currentCorner );
+
+			// max max min
+			currentCorner.x = oldMax.x;
+			merge( matrix * currentCorner );
+
+			// max max max
+			currentCorner.z = oldMax.z;
+			merge( matrix * currentCorner );
+
+			// max min max
+			currentCorner.y = oldMin.y;
+			merge( matrix * currentCorner );
+
+			// max min min
+			currentCorner.z = oldMin.z;
+			merge( matrix * currentCorner ); 
+		}
+
+		/** Transforms the box according to the affine matrix supplied.
+		@remarks
+		By calling this method you get the axis-aligned box which
+		surrounds the transformed version of this box. Therefore each
+		corner of the box is transformed by the matrix, then the
+		extents are mapped back onto the axes to produce another
+		AABB. Useful when you have a local AABB for an object which
+		is then transformed.
+		@note
+		The matrix must be an affine matrix. @see Matrix4::isAffine.
+		*/
+		void transformAffine(const Matrix4& m)
+		{
+			assert(m.isAffine());
+
+			// Do nothing if current null or infinite
+			if ( mExtent != EXTENT_FINITE )
+				return;
+
+			Vector3 centre = getCenter();
+			Vector3 halfSize = getHalfSize();
+
+			Vector3 newCentre = m.transformAffine(centre);
+			Vector3 newHalfSize(
+				Math::Abs(m[0][0]) * halfSize.x + Math::Abs(m[0][1]) * halfSize.y + Math::Abs(m[0][2]) * halfSize.z, 
+				Math::Abs(m[1][0]) * halfSize.x + Math::Abs(m[1][1]) * halfSize.y + Math::Abs(m[1][2]) * halfSize.z,
+				Math::Abs(m[2][0]) * halfSize.x + Math::Abs(m[2][1]) * halfSize.y + Math::Abs(m[2][2]) * halfSize.z);
+
+			setExtents(newCentre - newHalfSize, newCentre + newHalfSize);
+		}
+
+		/** Sets the box to a 'null' value i.e. not a box.
+		*/
+		inline void setNull()
+		{
+			mExtent = EXTENT_NULL;
+		}
+
+		/** Returns true if the box is null i.e. empty.
+		*/
+		inline bool isNull(void) const
+		{
+			return (mExtent == EXTENT_NULL);
+		}
+
+		/** Returns true if the box is finite.
+		*/
+		bool isFinite(void) const
+		{
+			return (mExtent == EXTENT_FINITE);
+		}
+
+		/** Sets the box to 'infinite'
+		*/
+		inline void setInfinite()
+		{
+			mExtent = EXTENT_INFINITE;
+		}
+
+		/** Returns true if the box is infinite.
+		*/
+		bool isInfinite(void) const
+		{
+			return (mExtent == EXTENT_INFINITE);
+		}
+
+		/** Returns whether or not this box intersects another. */
+		inline bool intersects(const AxisAlignedBox& b2) const
+		{
+			// Early-fail for nulls
+			if (this->isNull() || b2.isNull())
+				return false;
+
+			// Early-success for infinites
+			if (this->isInfinite() || b2.isInfinite())
+				return true;
+
+			// Use up to 6 separating planes
+			if (mMaximum.x < b2.mMinimum.x)
+				return false;
+			if (mMaximum.y < b2.mMinimum.y)
+				return false;
+			if (mMaximum.z < b2.mMinimum.z)
+				return false;
+
+			if (mMinimum.x > b2.mMaximum.x)
+				return false;
+			if (mMinimum.y > b2.mMaximum.y)
+				return false;
+			if (mMinimum.z > b2.mMaximum.z)
+				return false;
+
+			// otherwise, must be intersecting
+			return true;
+
+		}
+
+		/// Calculate the area of intersection of this box and another
+		inline AxisAlignedBox intersection(const AxisAlignedBox& b2) const
+		{
+            if (this->isNull() || b2.isNull())
+			{
+				return AxisAlignedBox();
+			}
+			else if (this->isInfinite())
+			{
+				return b2;
+			}
+			else if (b2.isInfinite())
+			{
+				return *this;
+			}
+
+			Vector3 intMin = mMinimum;
+            Vector3 intMax = mMaximum;
+
+            intMin.makeCeil(b2.getMinimum());
+            intMax.makeFloor(b2.getMaximum());
+
+            // Check intersection isn't null
+            if (intMin.x < intMax.x &&
+                intMin.y < intMax.y &&
+                intMin.z < intMax.z)
+            {
+                return AxisAlignedBox(intMin, intMax);
+            }
+
+            return AxisAlignedBox();
+		}
+
+		/// Calculate the volume of this box
+		Real volume(void) const
+		{
+			switch (mExtent)
+			{
+			case EXTENT_NULL:
+				return 0.0f;
+
+			case EXTENT_FINITE:
+				{
+					Vector3 diff = mMaximum - mMinimum;
+					return diff.x * diff.y * diff.z;
+				}
+
+			case EXTENT_INFINITE:
+				return Math::POS_INFINITY;
+
+			default: // shut up compiler
+				assert( false && "Never reached" );
+				return 0.0f;
+			}
+		}
+
+		/** Scales the AABB by the vector given. */
+		inline void scale(const Vector3& s)
+		{
+			// Do nothing if current null or infinite
+			if (mExtent != EXTENT_FINITE)
+				return;
+
+			// NB assumes centered on origin
+			Vector3 min = mMinimum * s;
+			Vector3 max = mMaximum * s;
+			setExtents(min, max);
+		}
+
+		/** Tests whether this box intersects a sphere. */
+		bool intersects(const Sphere& s) const
+		{
+			return Math::intersects(s, *this); 
+		}
+		/** Tests whether this box intersects a plane. */
+		bool intersects(const Plane& p) const
+		{
+			return Math::intersects(p, *this);
+		}
+		/** Tests whether the vector point is within this box. */
+		bool intersects(const Vector3& v) const
+		{
+			switch (mExtent)
+			{
+			case EXTENT_NULL:
+				return false;
+
+			case EXTENT_FINITE:
+				return(v.x >= mMinimum.x  &&  v.x <= mMaximum.x  && 
+					v.y >= mMinimum.y  &&  v.y <= mMaximum.y  && 
+					v.z >= mMinimum.z  &&  v.z <= mMaximum.z);
+
+			case EXTENT_INFINITE:
+				return true;
+
+			default: // shut up compiler
+				assert( false && "Never reached" );
+				return false;
+			}
+		}
+		/// Gets the centre of the box
+		Vector3 getCenter(void) const
+		{
+			assert( (mExtent == EXTENT_FINITE) && "Can't get center of a null or infinite AAB" );
+
+			return Vector3(
+				(mMaximum.x + mMinimum.x) * 0.5,
+				(mMaximum.y + mMinimum.y) * 0.5,
+				(mMaximum.z + mMinimum.z) * 0.5);
+		}
+		/// Gets the size of the box
+		Vector3 getSize(void) const
+		{
+			switch (mExtent)
+			{
+			case EXTENT_NULL:
+				return Vector3::ZERO;
+
+			case EXTENT_FINITE:
+				return mMaximum - mMinimum;
+
+			case EXTENT_INFINITE:
+				return Vector3(
+					Math::POS_INFINITY,
+					Math::POS_INFINITY,
+					Math::POS_INFINITY);
+
+			default: // shut up compiler
+				assert( false && "Never reached" );
+				return Vector3::ZERO;
+			}
+		}
+		/// Gets the half-size of the box
+		Vector3 getHalfSize(void) const
+		{
+			switch (mExtent)
+			{
+			case EXTENT_NULL:
+				return Vector3::ZERO;
+
+			case EXTENT_FINITE:
+				return (mMaximum - mMinimum) * 0.5;
+
+			case EXTENT_INFINITE:
+				return Vector3(
+					Math::POS_INFINITY,
+					Math::POS_INFINITY,
+					Math::POS_INFINITY);
+
+			default: // shut up compiler
+				assert( false && "Never reached" );
+				return Vector3::ZERO;
+			}
+		}
+
+        /** Tests whether the given point contained by this box.
+        */
+        bool contains(const Vector3& v) const
+        {
+            if (isNull())
+                return false;
+            if (isInfinite())
+                return true;
+
+            return mMinimum.x <= v.x && v.x <= mMaximum.x &&
+                   mMinimum.y <= v.y && v.y <= mMaximum.y &&
+                   mMinimum.z <= v.z && v.z <= mMaximum.z;
+        }
+
+        /** Tests whether another box contained by this box.
+        */
+        bool contains(const AxisAlignedBox& other) const
+        {
+            if (other.isNull() || this->isInfinite())
+                return true;
+
+            if (this->isNull() || other.isInfinite())
+                return false;
+
+            return this->mMinimum.x <= other.mMinimum.x &&
+                   this->mMinimum.y <= other.mMinimum.y &&
+                   this->mMinimum.z <= other.mMinimum.z &&
+                   other.mMaximum.x <= this->mMaximum.x &&
+                   other.mMaximum.y <= this->mMaximum.y &&
+                   other.mMaximum.z <= this->mMaximum.z;
+        }
+
+        /** Tests 2 boxes for equality.
+        */
+        bool operator== (const AxisAlignedBox& rhs) const
+        {
+            if (this->mExtent != rhs.mExtent)
+                return false;
+
+            if (!this->isFinite())
+                return true;
+
+            return this->mMinimum == rhs.mMinimum &&
+                   this->mMaximum == rhs.mMaximum;
+        }
+
+        /** Tests 2 boxes for inequality.
+        */
+        bool operator!= (const AxisAlignedBox& rhs) const
+        {
+            return !(*this == rhs);
+        }
+
+	};
+
+} // namespace Ogre
+
+#endif