1HEADmaster

1 files changed, 275 insertions, 0 deletions

diff --git a/hammer/boundbox.cpp b/hammer/boundbox.cpp
new file mode 100644
index 0000000..e60f880
--- /dev/null
+++ b/hammer/boundbox.cpp
@@ -0,0 +1,275 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "stdafx.h"
+#include "BoundBox.h"
+#include "hammer_mathlib.h"
+#include "MapDefs.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+BoundBox::BoundBox(void)
+{
+	ResetBounds();
+}
+
+BoundBox::BoundBox(const Vector &mins, const Vector &maxs)
+{
+	bmins = mins;
+	bmaxs = maxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the box to an uninitialized state, so that calls to UpdateBounds
+//			will properly set the mins and maxs.
+//-----------------------------------------------------------------------------
+void BoundBox::ResetBounds(void)
+{
+	bmins[0] = bmins[1] = bmins[2] = COORD_NOTINIT;
+	bmaxs[0] = bmaxs[1] = bmaxs[2] = -COORD_NOTINIT;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pt - 
+//-----------------------------------------------------------------------------
+void BoundBox::UpdateBounds(const Vector& pt)
+{
+	if(pt[0] < bmins[0])
+		bmins[0] = pt[0];
+	if(pt[1] < bmins[1])
+		bmins[1] = pt[1];
+	if(pt[2] < bmins[2])
+		bmins[2] = pt[2];
+
+	if(pt[0] > bmaxs[0])
+		bmaxs[0] = pt[0];
+	if(pt[1] > bmaxs[1])
+		bmaxs[1] = pt[1];
+	if(pt[2] > bmaxs[2])
+		bmaxs[2] = pt[2];
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bmins - 
+//			bmaxs - 
+//-----------------------------------------------------------------------------
+void BoundBox::UpdateBounds(const Vector& mins, const Vector& maxs)
+{
+	if(mins[0] < bmins[0])
+		bmins[0] = mins[0];
+	if(mins[1] < bmins[1])
+		bmins[1] = mins[1];
+	if(mins[2] < bmins[2])
+		bmins[2] = mins[2];
+
+	if(maxs[0] > bmaxs[0])
+		bmaxs[0] = maxs[0];
+	if(maxs[1] > bmaxs[1])
+		bmaxs[1] = maxs[1];
+	if(maxs[2] > bmaxs[2])
+		bmaxs[2] = maxs[2];
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pBox - 
+//-----------------------------------------------------------------------------
+void BoundBox::UpdateBounds(const BoundBox *pBox)
+{
+	UpdateBounds(pBox->bmins, pBox->bmaxs);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : ptdest - 
+//-----------------------------------------------------------------------------
+void BoundBox::GetBoundsCenter(Vector& ptdest)
+{
+	ptdest = (bmins + bmaxs)/2.0f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pt - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool BoundBox::ContainsPoint(const Vector& pt) const
+{
+	for (int i = 0; i < 3; i++)
+	{
+		if (pt[i] < bmins[i] || pt[i] > bmaxs[i])
+		{
+			return(false);
+		}
+	}
+	return(true);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pfMins - 
+//			pfMaxs - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool BoundBox::IsIntersectingBox(const Vector& pfMins, const Vector& pfMaxs) const
+{
+	if ((bmins[0] >= pfMaxs[0]) || (bmaxs[0] <= pfMins[0]))
+	{
+		return(false);
+
+	}
+	if ((bmins[1] >= pfMaxs[1]) || (bmaxs[1] <= pfMins[1]))
+	{
+		return(false);
+	}
+
+	if ((bmins[2] >= pfMaxs[2]) || (bmaxs[2] <= pfMins[2]))
+	{
+		return(false);
+	}
+
+	return(true);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pfMins - 
+//			pfMaxs - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool BoundBox::IsInsideBox(const Vector& pfMins, const Vector& pfMaxs) const
+{
+	if ((bmins[0] < pfMins[0]) || (bmaxs[0] > pfMaxs[0]))
+	{
+		return(false);
+	}
+
+	if ((bmins[1] < pfMins[1]) || (bmaxs[1] > pfMaxs[1]))
+	{
+		return(false);
+	}
+
+	if ((bmins[2] < pfMins[2]) || (bmaxs[2] > pfMaxs[2]))
+	{
+		return(false);
+	}
+
+	return(true);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether this bounding box is valid, ie maxs >= mins.
+//-----------------------------------------------------------------------------
+bool BoundBox::IsValidBox(void) const
+{
+	for (int i = 0; i < 3; i++)
+	{
+		if (bmins[i] > bmaxs[i])
+		{
+			return(false);
+		}
+	}
+
+	return(true);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : size - 
+//-----------------------------------------------------------------------------
+void BoundBox::GetBoundsSize(Vector& size)
+{
+	size[0] = bmaxs[0] - bmins[0];
+	size[1] = bmaxs[1] - bmins[1];
+	size[2] = bmaxs[2] - bmins[2];
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : iValue - 
+//			iGridSize - 
+// Output : 
+//-----------------------------------------------------------------------------
+static int Snap(/*int*/ float iValue, int iGridSize)
+{
+	return (int)(V_rint(iValue/iGridSize) * iGridSize);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : iGridSize - 
+//-----------------------------------------------------------------------------
+void BoundBox::SnapToGrid(int iGridSize)
+{
+	// does not alter the size of the box .. snaps its minimal coordinates
+	//  to the grid size specified in iGridSize
+	Vector size;
+	GetBoundsSize(size);
+
+	for(int i = 0; i < 3; i++)
+	{
+		bmins[i] = (float)Snap(/* YWB (int)*/bmins[i], iGridSize);
+		bmaxs[i] = bmins[i] + size[i];
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : axis - 
+//-----------------------------------------------------------------------------
+void BoundBox::Rotate90(int axis)
+{
+	int e1 = AXIS_X, e2 = AXIS_Y;
+
+	// get bounds center first
+	Vector center;
+	GetBoundsCenter(center);
+
+	switch(axis)
+	{
+	case AXIS_Z:
+		e1 = AXIS_X;
+		e2 = AXIS_Y;
+		break;
+	case AXIS_X:
+		e1 = AXIS_Y;
+		e2 = AXIS_Z;
+		break;
+	case AXIS_Y:
+		e1 = AXIS_X;
+		e2 = AXIS_Z;
+		break;
+	}
+
+	float tmp1, tmp2;
+	tmp1 = bmins[e1] - center[e1] + center[e2];
+	tmp2 = bmaxs[e1] - center[e1] + center[e2];
+	bmins[e1] = bmins[e2] - center[e2] + center[e1];
+	bmaxs[e1] = bmaxs[e2] - center[e2] + center[e1];
+	bmins[e2] = tmp1;
+	bmaxs[e2] = tmp2;
+}
+