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

data/deps/include/OGRE/OgreAutoParamDataSource.h

@@ -1,265 +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 __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;
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Materials
-	*  @{
-	*/
-
-
-    /** 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 : public SceneMgtAlloc
-    {
-    protected:
-		const Light& getLight(size_t index) const;
-        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 mCameraPosition;
-        mutable Vector4 mCameraPositionObjectSpace;
-        mutable Matrix4 mTextureViewProjMatrix[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable Matrix4 mTextureWorldViewProjMatrix[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable Matrix4 mSpotlightViewProjMatrix[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable Matrix4 mSpotlightWorldViewProjMatrix[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable Vector4 mShadowCamDepthRanges[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-        mutable Matrix4 mViewMatrix;
-        mutable Matrix4 mProjectionMatrix;
-		mutable Real mDirLightExtrusionDistance;
-		mutable Vector4 mLodCameraPosition;
-		mutable Vector4 mLodCameraPositionObjectSpace;
-
-        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 mCameraPositionDirty;
-        mutable bool mCameraPositionObjectSpaceDirty;
-        mutable bool mTextureViewProjMatrixDirty[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable bool mTextureWorldViewProjMatrixDirty[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable bool mSpotlightViewProjMatrixDirty[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable bool mSpotlightWorldViewProjMatrixDirty[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable bool mShadowCamDepthRangesDirty[OGRE_MAX_SIMULTANEOUS_LIGHTS];
-		mutable ColourValue mAmbientLight;
-        mutable ColourValue mFogColour;
-        mutable Vector4 mFogParams;
-        mutable int mPassNumber;
-		mutable Vector4 mSceneDepthRange;
-		mutable bool mSceneDepthRangeDirty;
-		mutable bool mLodCameraPositionDirty;
-		mutable bool mLodCameraPositionObjectSpaceDirty;
-
-        const Renderable* mCurrentRenderable;
-        const Camera* mCurrentCamera;
-		bool mCameraRelativeRendering;
-		Vector3 mCameraRelativePosition;
-        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();
-        virtual ~AutoParamDataSource();
-        /** Updates the current renderable */
-        virtual void setCurrentRenderable(const Renderable* rend);
-        /** Sets the world matrices, avoid query from renderable again */
-        virtual void setWorldMatrices(const Matrix4* m, size_t count);
-        /** Updates the current camera */
-        virtual void setCurrentCamera(const Camera* cam, bool useCameraRelative);
-        /** Sets the light list that should be used, and it's base index from the global list */
-        virtual void setCurrentLightList(const LightList* ll);
-        /** Sets the current texture projector for a index */
-        virtual void setTextureProjector(const Frustum* frust, size_t index);
-        /** Sets the current render target */
-        virtual void setCurrentRenderTarget(const RenderTarget* target);
-        /** Sets the current viewport */
-        virtual void setCurrentViewport(const Viewport* viewport);
-		/** Sets the shadow extrusion distance to be used for point lights. */
-		virtual void setShadowDirLightExtrusionDistance(Real dist);
-		/** Sets the main camera's scene bounding information */
-		virtual void setMainCamBoundsInfo(VisibleObjectsBoundsInfo* info);
-		/** Set the current scene manager for enquiring on demand */
-		virtual void setCurrentSceneManager(const SceneManager* sm);
-        /** Sets the current pass */
-        virtual void setCurrentPass(const Pass* pass);
-
-
-
-        virtual const Matrix4& getWorldMatrix(void) const;
-        virtual const Matrix4* getWorldMatrixArray(void) const;
-        virtual size_t getWorldMatrixCount(void) const;
-        virtual const Matrix4& getViewMatrix(void) const;
-        virtual const Matrix4& getViewProjectionMatrix(void) const;
-        virtual const Matrix4& getProjectionMatrix(void) const;
-        virtual const Matrix4& getWorldViewProjMatrix(void) const;
-        virtual const Matrix4& getWorldViewMatrix(void) const;
-        virtual const Matrix4& getInverseWorldMatrix(void) const;
-        virtual const Matrix4& getInverseWorldViewMatrix(void) const;
-        virtual const Matrix4& getInverseViewMatrix(void) const;
-        virtual const Matrix4& getInverseTransposeWorldMatrix(void) const;
-        virtual const Matrix4& getInverseTransposeWorldViewMatrix(void) const;
-        virtual const Vector4& getCameraPosition(void) const;
-        virtual const Vector4& getCameraPositionObjectSpace(void) const;
-		virtual const Vector4& getLodCameraPosition(void) const;
-		virtual const Vector4& getLodCameraPositionObjectSpace(void) const;
-		virtual bool hasLightList() const { return mCurrentLightList != 0; }
-        /** Get the light which is 'index'th closest to the current object */        
-		virtual float getLightNumber(size_t index) const;
-		virtual float getLightCount() const;
-		virtual float getLightCastsShadows(size_t index) const;
-		virtual const ColourValue& getLightDiffuseColour(size_t index) const;
-		virtual const ColourValue& getLightSpecularColour(size_t index) const;
-		virtual const ColourValue getLightDiffuseColourWithPower(size_t index) const;
-		virtual const ColourValue getLightSpecularColourWithPower(size_t index) const;
-		virtual const Vector3& getLightPosition(size_t index) const;
-		virtual Vector4 getLightAs4DVector(size_t index) const;
-		virtual const Vector3& getLightDirection(size_t index) const;
-		virtual Real getLightPowerScale(size_t index) const;
-		virtual Vector4 getLightAttenuation(size_t index) const;
-		virtual Vector4 getSpotlightParams(size_t index) const;
-		virtual void setAmbientLightColour(const ColourValue& ambient);
-		virtual const ColourValue& getAmbientLightColour(void) const;
-        virtual const ColourValue& getSurfaceAmbientColour(void) const;
-        virtual const ColourValue& getSurfaceDiffuseColour(void) const;
-        virtual const ColourValue& getSurfaceSpecularColour(void) const;
-        virtual const ColourValue& getSurfaceEmissiveColour(void) const;
-        virtual Real getSurfaceShininess(void) const;
-        virtual ColourValue getDerivedAmbientLightColour(void) const;
-        virtual ColourValue getDerivedSceneColour(void) const;
-        virtual void setFog(FogMode mode, const ColourValue& colour, Real expDensity, Real linearStart, Real linearEnd);
-        virtual const ColourValue& getFogColour(void) const;
-        virtual const Vector4& getFogParams(void) const;
-        virtual const Matrix4& getTextureViewProjMatrix(size_t index) const;
-		virtual const Matrix4& getTextureWorldViewProjMatrix(size_t index) const;
-		virtual const Matrix4& getSpotlightViewProjMatrix(size_t index) const;
-		virtual const Matrix4& getSpotlightWorldViewProjMatrix(size_t index) const;
-        virtual const Matrix4& getTextureTransformMatrix(size_t index) const;
-        virtual const RenderTarget* getCurrentRenderTarget(void) const;
-        virtual const Renderable* getCurrentRenderable(void) const;
-        virtual const Pass* getCurrentPass(void) const;
-        virtual Vector4 getTextureSize(size_t index) const;
-        virtual Vector4 getInverseTextureSize(size_t index) const;
-        virtual Vector4 getPackedTextureSize(size_t index) const;
-		virtual Real getShadowExtrusionDistance(void) const;
-		virtual const Vector4& getSceneDepthRange() const;
-		virtual const Vector4& getShadowSceneDepthRange(size_t index) const;
-		virtual const ColourValue& getShadowColour() const;
-		virtual Matrix4 getInverseViewProjMatrix(void) const;
-		virtual Matrix4 getInverseTransposeViewProjMatrix() const;
-		virtual Matrix4 getTransposeViewProjMatrix() const;
-		virtual Matrix4 getTransposeViewMatrix() const;
-        virtual Matrix4 getInverseTransposeViewMatrix() const;
-		virtual Matrix4 getTransposeProjectionMatrix() const;
-		virtual Matrix4 getInverseProjectionMatrix() const;
-		virtual Matrix4 getInverseTransposeProjectionMatrix() const;
-		virtual Matrix4 getTransposeWorldViewProjMatrix() const;
-		virtual Matrix4 getInverseWorldViewProjMatrix() const;
-		virtual Matrix4 getInverseTransposeWorldViewProjMatrix() const;
-		virtual Matrix4 getTransposeWorldViewMatrix() const;
-		virtual Matrix4 getTransposeWorldMatrix() const;
-        virtual Real getTime(void) const;
-		virtual Real getTime_0_X(Real x) const;
-		virtual Real getCosTime_0_X(Real x) const;
-		virtual Real getSinTime_0_X(Real x) const;
-		virtual Real getTanTime_0_X(Real x) const;
-		virtual Vector4 getTime_0_X_packed(Real x) const;
-		virtual Real getTime_0_1(Real x) const;
-		virtual Real getCosTime_0_1(Real x) const;
-		virtual Real getSinTime_0_1(Real x) const;
-		virtual Real getTanTime_0_1(Real x) const;
-		virtual Vector4 getTime_0_1_packed(Real x) const;
-		virtual Real getTime_0_2Pi(Real x) const;
-		virtual Real getCosTime_0_2Pi(Real x) const;
-		virtual Real getSinTime_0_2Pi(Real x) const;
-		virtual Real getTanTime_0_2Pi(Real x) const;
-		virtual Vector4 getTime_0_2Pi_packed(Real x) const;
-        virtual Real getFrameTime(void) const;
-		virtual Real getFPS() const;
-		virtual Real getViewportWidth() const;
-		virtual Real getViewportHeight() const;
-		virtual Real getInverseViewportWidth() const;
-		virtual Real getInverseViewportHeight() const;
-		virtual Vector3 getViewDirection() const;
-		virtual Vector3 getViewSideVector() const;
-		virtual Vector3 getViewUpVector() const;
-		virtual Real getFOV() const;
-		virtual Real getNearClipDistance() const;
-		virtual Real getFarClipDistance() const;
-        virtual int getPassNumber(void) const;
-        virtual void setPassNumber(const int passNumber);
-        virtual void incPassNumber(void);
-		virtual void updateLightCustomGpuParameter(const GpuProgramParameters::AutoConstantEntry& constantEntry, GpuProgramParameters *params) const;
-    };
-	/** @} */
-	/** @} */
-}
-
-#endif

data/deps/include/OGRE/OgreAxisAlignedBox.h

@@ -1,841 +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 __AxisAlignedBox_H_
-#define __AxisAlignedBox_H_
-
-// Precompiler options
-#include "OgrePrerequisites.h"
-
-#include "OgreVector3.h"
-#include "OgreMatrix4.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-
-	/** 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
-	{
-	public:
-		enum Extent
-		{
-			EXTENT_NULL,
-			EXTENT_FINITE,
-			EXTENT_INFINITE
-		};
-	protected:
-
-		Vector3 mMinimum;
-		Vector3 mMaximum;
-		Extent mExtent;
-		mutable Vector3* mCorners;
-
-	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() : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(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(Extent e) : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
-		{
-			setMinimum( -0.5, -0.5, -0.5 );
-			setMaximum( 0.5, 0.5, 0.5 );
-			mExtent = e;
-		}
-
-		inline AxisAlignedBox(const AxisAlignedBox & rkBox) : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
-
-		{
-			if (rkBox.isNull())
-				setNull();
-			else if (rkBox.isInfinite())
-				setInfinite();
-			else
-				setExtents( rkBox.mMinimum, rkBox.mMaximum );
-		}
-
-		inline AxisAlignedBox( const Vector3& min, const Vector3& max ) : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
-		{
-			setExtents( min, max );
-		}
-
-		inline AxisAlignedBox(
-			Real mx, Real my, Real mz,
-			Real Mx, Real My, Real Mz ) : mMinimum(Vector3::ZERO), mMaximum(Vector3::UNIT_SCALE), mCorners(0)
-		{
-			setExtents( mx, my, mz, Mx, My, Mz );
-		}
-
-		AxisAlignedBox& operator=(const AxisAlignedBox& rhs)
-		{
-			// Specifically override to avoid copying mCorners
-			if (rhs.isNull())
-				setNull();
-			else if (rhs.isInfinite())
-				setInfinite();
-			else
-				setExtents(rhs.mMinimum, rhs.mMaximum);
-
-			return *this;
-		}
-
-		~AxisAlignedBox()
-		{
-			if (mCorners)
-				OGRE_FREE(mCorners, MEMCATEGORY_SCENE_CONTROL);
-		}
-
-
-		/** 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 (!mCorners)
-				mCorners = OGRE_ALLOC_T(Vector3, 8, MEMCATEGORY_SCENE_CONTROL);
-
-			mCorners[0] = mMinimum;
-			mCorners[1].x = mMinimum.x; mCorners[1].y = mMaximum.y; mCorners[1].z = mMinimum.z;
-			mCorners[2].x = mMaximum.x; mCorners[2].y = mMaximum.y; mCorners[2].z = mMinimum.z;
-			mCorners[3].x = mMaximum.x; mCorners[3].y = mMinimum.y; mCorners[3].z = mMinimum.z;            
-
-			mCorners[4] = mMaximum;
-			mCorners[5].x = mMinimum.x; mCorners[5].y = mMaximum.y; mCorners[5].z = mMaximum.z;
-			mCorners[6].x = mMinimum.x; mCorners[6].y = mMinimum.y; mCorners[6].z = mMaximum.z;
-			mCorners[7].x = mMaximum.x; mCorners[7].y = mMinimum.y; mCorners[7].z = mMaximum.z;
-
-			return mCorners;
-		}
-
-		/** gets the position of one of the corners
-		*/
-		Vector3 getCorner(CornerEnum cornerToGet) const
-		{
-			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;
-
-			// reset
-			setNull();
-
-			// 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.5f,
-				(mMaximum.y + mMinimum.y) * 0.5f,
-				(mMaximum.z + mMinimum.z) * 0.5f);
-		}
-		/// 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;
-        }
-		
-		/** Returns the minimum distance between a given point and any part of the box. */
-		Real distance(const Vector3& v) const
-		{
-			
-			if (this->contains(v))
-				return 0;
-			else
-			{
-				Real maxDist = std::numeric_limits<Real>::min();
-
-				if (v.x < mMinimum.x)
-					maxDist = std::max(maxDist, mMinimum.x - v.x);
-				if (v.y < mMinimum.y)
-					maxDist = std::max(maxDist, mMinimum.y - v.y);
-				if (v.z < mMinimum.z)
-					maxDist = std::max(maxDist, mMinimum.z - v.z);
-				
-				if (v.x > mMaximum.x)
-					maxDist = std::max(maxDist, v.x - mMaximum.x);
-				if (v.y > mMaximum.y)
-					maxDist = std::max(maxDist, v.y - mMaximum.y);
-				if (v.z > mMaximum.z)
-					maxDist = std::max(maxDist, v.z - mMaximum.z);
-				
-				return maxDist;
-			}
-		}
-
-        /** 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);
-        }
-
-		// special values
-		static const AxisAlignedBox BOX_NULL;
-		static const AxisAlignedBox BOX_INFINITE;
-
-
-	};
-
-	/** @} */
-	/** @} */
-} // namespace Ogre
-
-#endif