Stars45 can now be built under MSYS2/Mingw32

1 files changed, 0 insertions, 177 deletions

diff --git a/Opcode/OpcodeLib/Ice/IceOBB.h b/Opcode/OpcodeLib/Ice/IceOBB.h
deleted file mode 100644
index 249e76a..0000000
--- a/Opcode/OpcodeLib/Ice/IceOBB.h
+++ /dev/null
@@ -1,177 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-/**

- *	Contains OBB-related code. (oriented bounding box)

- *	\file		IceOBB.h

- *	\author		Pierre Terdiman

- *	\date		January, 13, 2000

- */

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-// Include Guard

-#ifndef __ICEOBB_H__

-#define __ICEOBB_H__

-

-	// Forward declarations

-	class LSS;

-

-	class ICEMATHS_API OBB

-	{

-		public:

-		//! Constructor

-		inline_						OBB()		{}

-		//! Constructor

-		inline_						OBB(const IcePoint& center, const IcePoint& extents, const Matrix3x3& rot) : mCenter(center), mExtents(extents), mRot(rot)	{}

-		//! Destructor

-		inline_						~OBB()		{}

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Setups an empty OBB.

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				void				SetEmpty()

-									{

-										mCenter.Zero();

-										mExtents.Set(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);

-										mRot.Identity();

-									}

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Tests if a point is contained within the OBB.

-		 *	\param		p	[in] the world point to test

-		 *	\return		true if inside the OBB

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				bool				ContainsPoint(const IcePoint& p)	const;

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Builds an OBB from an AABB and a world transform.

-		 *	\param		aabb	[in] the aabb

-		 *	\param		mat		[in] the world transform

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				void				Create(const AABB& aabb, const Matrix4x4& mat);

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Recomputes the OBB after an arbitrary transform by a 4x4 matrix.

-		 *	\param		mtx		[in] the transform matrix

-		 *	\param		obb		[out] the transformed OBB

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		inline_	void				Rotate(const Matrix4x4& mtx, OBB& obb)	const

-									{

-										// The extents remain constant

-										obb.mExtents = mExtents;

-										// The center gets x-formed

-										obb.mCenter = mCenter * mtx;

-										// Combine rotations

-										obb.mRot = mRot * Matrix3x3(mtx);

-									}

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Checks the OBB is valid.

-		 *	\return		true if the box is valid

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		inline_	BOOL				IsValid()	const

-									{

-										// Consistency condition for (Center, Extents) boxes: Extents >= 0.0f

-										if(mExtents.x < 0.0f)	return FALSE;

-										if(mExtents.y < 0.0f)	return FALSE;

-										if(mExtents.z < 0.0f)	return FALSE;

-										return TRUE;

-									}

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Computes the obb planes.

-		 *	\param		planes	[out] 6 box planes

-		 *	\return		true if success

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				bool				ComputePlanes(IcePlane* planes)	const;

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Computes the obb points.

-		 *	\param		pts	[out] 8 box points

-		 *	\return		true if success

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				bool				ComputePoints(IcePoint* pts)	const;

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Computes vertex normals.

-		 *	\param		pts	[out] 8 box points

-		 *	\return		true if success

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				bool				ComputeVertexNormals(IcePoint* pts)	const;

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Returns edges.

-		 *	\return		24 indices (12 edges) indexing the list returned by ComputePoints()

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				const udword*		GetEdges()	const;

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Returns local edge normals.

-		 *	\return		edge normals in local space

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				const IcePoint*		GetLocalEdgeNormals()	const;

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Returns world edge normal

-		 *	\param		edge_index		[in] 0 <= edge index < 12

-		 *	\param		world_normal	[out] edge normal in world space

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				void				ComputeWorldEdgeNormal(udword edge_index, IcePoint& world_normal)	const;

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Computes an LSS surrounding the OBB.

-		 *	\param		lss		[out] the LSS

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				void				ComputeLSS(LSS& lss)	const;

-

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-		/**

-		 *	Checks the OBB is inside another OBB.

-		 *	\param		box		[in] the other OBB

-		 *	\return		TRUE if we're inside the other box

-		 */

-		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

-				BOOL				IsInside(const OBB& box)	const;

-

-		inline_	const IcePoint&		GetCenter()		const	{ return mCenter;	}

-		inline_	const IcePoint&		GetExtents()	const	{ return mExtents;	}

-		inline_	const Matrix3x3&	GetRot()		const	{ return mRot;		}

-

-		inline_	void				GetRotatedExtents(Matrix3x3& extents)	const

-									{

-										extents = mRot;

-										extents.Scale(mExtents);

-									}

-

-				IcePoint				mCenter;		//!< B for Box

-				IcePoint				mExtents;		//!< B for Bounding

-				Matrix3x3			mRot;			//!< O for Oriented

-

-				// Orientation is stored in row-major format,

-				// i.e. rows = eigen vectors of the covariance matrix

-	};

-

-#endif	// __ICEOBB_H__