Refactored and renamed Box, Int2, Rect and FRect #3 (SVN being silly)

CamelotUtility/Include/CmAABox.cpp

@@ -1,498 +0,0 @@
-#include "CmAABox.h"
-#include "CmRay.h"
-#include "CmPlane.h"
-#include "CmSphere.h"
-
-namespace CamelotFramework
-{
-	const AABox AABox::BOX_EMPTY;
-
-	AABox::AABox() 
-		:mMinimum(Vector3::ZERO), mMaximum(Vector3::ONE)
-	{
-		// Default to a null box 
-		setMin(Vector3(-0.5f, -0.5f, -0.5f));
-		setMax(Vector3(0.5f, 0.5f, 0.5f));
-	}
-
-	AABox::AABox(const AABox& copy)
-		:mMinimum(Vector3::ZERO), mMaximum(Vector3::ONE)
-	{
-		setExtents(copy.mMinimum, copy.mMaximum);
-	}
-
-	AABox::AABox(const Vector3& min, const Vector3& max)
-		:mMinimum(Vector3::ZERO), mMaximum(Vector3::ONE)
-	{
-		setExtents(min, max);
-	}
-
-	AABox& AABox::operator=(const AABox& rhs)
-	{
-		setExtents(rhs.mMinimum, rhs.mMaximum);
-
-		return *this;
-	}
-
-	void AABox::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" );
-
-		mMinimum = min;
-		mMaximum = max;
-	}
-
-	void AABox::scale(const Vector3& s)
-	{
-		Vector3 center = getCenter();
-		Vector3 min = center + (mMinimum - center) * s;
-		Vector3 max = center + (mMaximum - center) * s;
-
-		setExtents(min, max);
-	}
-
-	Vector3 AABox::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();
-		}
-	}
-
-	void AABox::merge(const AABox& rhs)
-	{
-		Vector3 min = mMinimum;
-		Vector3 max = mMaximum;
-		max.ceil(rhs.mMaximum);
-		min.floor(rhs.mMinimum);
-
-		setExtents(min, max);
-	}
-
-	void AABox::merge(const Vector3& point)
-	{
-		mMaximum.ceil(point);
-		mMinimum.floor(point);
-	}
-
-	void AABox::transform(const Matrix4& matrix)
-	{
-		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.transform3x4(currentCorner));
-
-		// min,min,max
-		currentCorner.z = oldMax.z;
-		merge(matrix.transform3x4(currentCorner));
-
-		// min max max
-		currentCorner.y = oldMax.y;
-		merge(matrix.transform3x4(currentCorner));
-
-		// min max min
-		currentCorner.z = oldMin.z;
-		merge(matrix.transform3x4(currentCorner));
-
-		// max max min
-		currentCorner.x = oldMax.x;
-		merge(matrix.transform3x4(currentCorner));
-
-		// max max max
-		currentCorner.z = oldMax.z;
-		merge(matrix.transform3x4(currentCorner));
-
-		// max min max
-		currentCorner.y = oldMin.y;
-		merge(matrix.transform3x4(currentCorner));
-
-		// max min min
-		currentCorner.z = oldMin.z;
-		merge(matrix.transform3x4(currentCorner)); 
-	}
-
-	void AABox::transformAffine(const Matrix4& m)
-	{
-		assert(m.isAffine());
-
-		Vector3 centre = getCenter();
-		Vector3 halfSize = getHalfSize();
-
-		Vector3 newCentre = m.transform3x4(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);
-	}
-
-	AABox AABox::intersection(const AABox& b2) const
-	{
-		Vector3 intMin = mMinimum;
-        Vector3 intMax = mMaximum;
-
-        intMin.ceil(b2.getMin());
-        intMax.floor(b2.getMax());
-
-        // Check intersection isn't null
-        if (intMin.x < intMax.x &&
-            intMin.y < intMax.y &&
-            intMin.z < intMax.z)
-        {
-            return AABox(intMin, intMax);
-        }
-
-        return AABox();
-	}
-
-	bool AABox::intersects(const AABox& b2) const
-	{
-		// 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;
-	}
-
-	bool AABox::intersects(const Sphere& sphere) const
-	{
-		// Use splitting planes
-		const Vector3& center = sphere.getCenter();
-		float radius = sphere.getRadius();
-		const Vector3& min = getMin();
-		const Vector3& max = getMax();
-
-		// Arvo's algorithm
-		float s, d = 0;
-		for (int i = 0; i < 3; ++i)
-		{
-			if (center.ptr()[i] < min.ptr()[i])
-			{
-				s = center.ptr()[i] - min.ptr()[i];
-				d += s * s; 
-			}
-			else if(center.ptr()[i] > max.ptr()[i])
-			{
-				s = center.ptr()[i] - max.ptr()[i];
-				d += s * s; 
-			}
-		}
-		return d <= radius * radius;
-	}
-
-	bool AABox::intersects(const Plane& p) const
-	{
-		return (p.getSide(*this) == Plane::BOTH_SIDE);
-	}
-
-	bool AABox::intersects(const Vector3& v) const
-	{
-		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);
-	}
-
-	std::pair<bool, float> AABox::intersects(const Ray& ray) const
-	{
-		float lowt = 0.0f;
-		float t;
-		bool hit = false;
-		Vector3 hitpoint;
-		const Vector3& min = getMin();
-		const Vector3& max = getMax();
-		const Vector3& rayorig = ray.getOrigin();
-		const Vector3& raydir = ray.getDirection();
-
-		// Check origin inside first
-		if ((rayorig.x > min.x && rayorig.y > min.y && rayorig.z > min.z) && (rayorig.x < max.x && rayorig.y < max.y && rayorig.z < max.z))
-		{
-			return std::pair<bool, float>(true, 0.0f);
-		}
-
-		// Check each face in turn, only check closest 3
-		// Min x
-		if (rayorig.x <= min.x && raydir.x > 0)
-		{
-			t = (min.x - rayorig.x) / raydir.x;
-			if (t >= 0)
-			{
-				// Substitute t back into ray and check bounds and dist
-				hitpoint = rayorig + raydir * t;
-				if (hitpoint.y >= min.y && hitpoint.y <= max.y &&
-					hitpoint.z >= min.z && hitpoint.z <= max.z &&
-					(!hit || t < lowt))
-				{
-					hit = true;
-					lowt = t;
-				}
-			}
-		}
-		// Max x
-		if (rayorig.x >= max.x && raydir.x < 0)
-		{
-			t = (max.x - rayorig.x) / raydir.x;
-			if (t >= 0)
-			{
-				// Substitute t back into ray and check bounds and dist
-				hitpoint = rayorig + raydir * t;
-				if (hitpoint.y >= min.y && hitpoint.y <= max.y &&
-					hitpoint.z >= min.z && hitpoint.z <= max.z &&
-					(!hit || t < lowt))
-				{
-					hit = true;
-					lowt = t;
-				}
-			}
-		}
-		// Min y
-		if (rayorig.y <= min.y && raydir.y > 0)
-		{
-			t = (min.y - rayorig.y) / raydir.y;
-			if (t >= 0)
-			{
-				// Substitute t back into ray and check bounds and dist
-				hitpoint = rayorig + raydir * t;
-				if (hitpoint.x >= min.x && hitpoint.x <= max.x &&
-					hitpoint.z >= min.z && hitpoint.z <= max.z &&
-					(!hit || t < lowt))
-				{
-					hit = true;
-					lowt = t;
-				}
-			}
-		}
-		// Max y
-		if (rayorig.y >= max.y && raydir.y < 0)
-		{
-			t = (max.y - rayorig.y) / raydir.y;
-			if (t >= 0)
-			{
-				// Substitute t back into ray and check bounds and dist
-				hitpoint = rayorig + raydir * t;
-				if (hitpoint.x >= min.x && hitpoint.x <= max.x &&
-					hitpoint.z >= min.z && hitpoint.z <= max.z &&
-					(!hit || t < lowt))
-				{
-					hit = true;
-					lowt = t;
-				}
-			}
-		}
-		// Min z
-		if (rayorig.z <= min.z && raydir.z > 0)
-		{
-			t = (min.z - rayorig.z) / raydir.z;
-			if (t >= 0)
-			{
-				// Substitute t back into ray and check bounds and dist
-				hitpoint = rayorig + raydir * t;
-				if (hitpoint.x >= min.x && hitpoint.x <= max.x &&
-					hitpoint.y >= min.y && hitpoint.y <= max.y &&
-					(!hit || t < lowt))
-				{
-					hit = true;
-					lowt = t;
-				}
-			}
-		}
-		// Max z
-		if (rayorig.z >= max.z && raydir.z < 0)
-		{
-			t = (max.z - rayorig.z) / raydir.z;
-			if (t >= 0)
-			{
-				// Substitute t back into ray and check bounds and dist
-				hitpoint = rayorig + raydir * t;
-				if (hitpoint.x >= min.x && hitpoint.x <= max.x &&
-					hitpoint.y >= min.y && hitpoint.y <= max.y &&
-					(!hit || t < lowt))
-				{
-					hit = true;
-					lowt = t;
-				}
-			}
-		}
-
-		return std::pair<bool, float>(hit, lowt);
-
-	} 
-
-	bool AABox::intersects(const Ray& ray, float& d1, float& d2) const
-	{
-		const Vector3& min = getMin();
-		const Vector3& max = getMax();
-		const Vector3& rayorig = ray.getOrigin();
-		const Vector3& raydir = ray.getDirection();
-
-		Vector3 absDir;
-		absDir[0] = Math::abs(raydir[0]);
-		absDir[1] = Math::abs(raydir[1]);
-		absDir[2] = Math::abs(raydir[2]);
-
-		// Sort the axis, ensure check minimise floating error axis first
-		int imax = 0, imid = 1, imin = 2;
-		if (absDir[0] < absDir[2])
-		{
-			imax = 2;
-			imin = 0;
-		}
-		if (absDir[1] < absDir[imin])
-		{
-			imid = imin;
-			imin = 1;
-		}
-		else if (absDir[1] > absDir[imax])
-		{
-			imid = imax;
-			imax = 1;
-		}
-
-		float start = 0, end = Math::POS_INFINITY;
-
-#define _CALC_AXIS(i)                                       \
-	do {                                                    \
-	float denom = 1 / raydir[i];                         \
-	float newstart = (min[i] - rayorig[i]) * denom;      \
-	float newend = (max[i] - rayorig[i]) * denom;        \
-	if (newstart > newend) std::swap(newstart, newend); \
-	if (newstart > end || newend < start) return false; \
-	if (newstart > start) start = newstart;             \
-	if (newend < end) end = newend;                     \
-	} while(0)
-
-		// Check each axis in turn
-
-		_CALC_AXIS(imax);
-
-		if (absDir[imid] < std::numeric_limits<float>::epsilon())
-		{
-			// Parallel with middle and minimise axis, check bounds only
-			if (rayorig[imid] < min[imid] || rayorig[imid] > max[imid] ||
-				rayorig[imin] < min[imin] || rayorig[imin] > max[imin])
-				return false;
-		}
-		else
-		{
-			_CALC_AXIS(imid);
-
-			if (absDir[imin] < std::numeric_limits<float>::epsilon())
-			{
-				// Parallel with minimise axis, check bounds only
-				if (rayorig[imin] < min[imin] || rayorig[imin] > max[imin])
-					return false;
-			}
-			else
-			{
-				_CALC_AXIS(imin);
-			}
-		}
-#undef _CALC_AXIS
-
-		d1 = start;
-		d2 = end;
-
-		return true;
-	}
-
-	Vector3 AABox::getCenter() const
-	{
-		return Vector3(
-			(mMaximum.x + mMinimum.x) * 0.5f,
-			(mMaximum.y + mMinimum.y) * 0.5f,
-			(mMaximum.z + mMinimum.z) * 0.5f);
-	}
-
-	Vector3 AABox::getSize() const
-	{
-		return mMaximum - mMinimum;
-	}
-
-	Vector3 AABox::getHalfSize() const
-	{
-		return (mMaximum - mMinimum) * 0.5;
-	}
-
-	float AABox::getRadius() const
-	{
-		return (mMaximum - mMinimum).length();
-	}
-
-	float AABox::getVolume() const
-	{
-		Vector3 diff = mMaximum - mMinimum;
-		return diff.x * diff.y * diff.z;
-	}
-
-    bool AABox::contains(const Vector3& v) const
-    {
-        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;
-    }
-
-    bool AABox::contains(const AABox& other) const
-    {
-        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;
-    }
-
-    bool AABox::operator== (const AABox& rhs) const
-    {
-        return this->mMinimum == rhs.mMinimum &&
-                this->mMaximum == rhs.mMaximum;
-    }
-
-    bool AABox::operator!= (const AABox& rhs) const
-    {
-        return !(*this == rhs);
-    }
-}
-

CamelotUtility/Include/CmBox.h

@@ -1,74 +0,0 @@
-#pragma once
-
-#include "CmPrerequisitesUtil.h"
-
-namespace CamelotFramework
-{
-/** Structure used to define a box in a 3-D integer space.
-    Note that the left, top, and front edges are included but the right, 
-    bottom and back ones are not.
-    */
-	struct CM_UTILITY_EXPORT Box
-	{
-		UINT32 left, top, right, bottom, front, back;
-		/// Parameterless constructor for setting the members manually
-		Box()
-			: left(0), top(0), right(1), bottom(1), front(0), back(1)
-		{
-		}
-		/** Define a box from left, top, right and bottom coordinates
-			This box will have depth one (front=0 and back=1).
-			@param	l	x value of left edge
-			@param	t	y value of top edge
-			@param	r	x value of right edge
-			@param	b	y value of bottom edge
-			@note Note that the left, top, and front edges are included 
- 				but the right, bottom and back ones are not.
-		*/
-		Box( UINT32 l, UINT32 t, UINT32 r, UINT32 b ):
-			left(l),
-			top(t),   
-			right(r),
-			bottom(b),
-			front(0),
-			back(1)
-		{
-			assert(right >= left && bottom >= top && back >= front);
-		}
-		/** Define a box from left, top, front, right, bottom and back
-			coordinates.
-			@param	l	x value of left edge
-			@param	t	y value of top edge
-			@param  ff  z value of front edge
-			@param	r	x value of right edge
-			@param	b	y value of bottom edge
-			@param  bb  z value of back edge
-			@note Note that the left, top, and front edges are included 
- 				but the right, bottom and back ones are not.
-		*/
-		Box( UINT32 l, UINT32 t, UINT32 ff, UINT32 r, UINT32 b, UINT32 bb ):
-			left(l),
-			top(t),   
-			right(r),
-			bottom(b),
-			front(ff),
-			back(bb)
-		{
-			assert(right >= left && bottom >= top && back >= front);
-		}
-            
-		/// Return true if the other box is a part of this one
-		bool contains(const Box &def) const
-		{
-			return (def.left >= left && def.top >= top && def.front >= front &&
-				def.right <= right && def.bottom <= bottom && def.back <= back);
-		}
-            
-		/// Get the width of this box
-		UINT32 getWidth() const { return right-left; }
-		/// Get the height of this box
-		UINT32 getHeight() const { return bottom-top; }
-		/// Get the depth of this box
-		UINT32 getDepth() const { return back-front; }
-	};
-}

CamelotUtility/Source/CmBox.cpp

@@ -1 +0,0 @@
-#include "CmBox.h"