276 lines
6.6 KiB
C++
276 lines
6.6 KiB
C++
//========= 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;
|
|
}
|
|
|