Renegade/Code/WWMath/aabox.h

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : WWMath                                                       *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/wwmath/aabox.h                               $*
 *                                                                                             *
 *                       Author:: Greg_h                                                       *
 *                                                                                             *
 *                     $Modtime:: 5/08/01 6:35p                                               $*
 *                                                                                             *
 *                    $Revision:: 30                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   AABoxClass::Transform -- transform an aabox                                               *
 *   AABoxClass::Translate -- transform an aabox                                               *
 *   AABoxClass::Init -- create a box which bounds the given points									  *
 *   AABoxClass::Init -- initialize from a min-max form of a box                               *
 *   AABoxClass::Init_Min_Max -- init the box from a min and max vector                        *
 *   AABoxClass::Add_Point -- expand the box to contain the given point                        *
 *   AABoxClass::Project_To_Axis -- compute projection onto the given axis                     *
 *   AABoxClass::Intersects -- test for intersection with another static aabox                 *
 *   AABoxClass::Add_Box -- expand this box to enclose the passed box                          *
 *   AABoxClass::Add_Box -- Expand this box to enclose the passed box                          *
 *   MinMaxAABoxClass::Init -- init the box from an array of points                            *
 *   MinMaxAABoxClass::Init -- initializes this box from a center-extent box                   *
 *   MinMaxAABoxClass::Add_Point -- updates this box so it encloses the given point            *
 *   MinMaxAABoxClass::Add_Box -- update this box to enclose the given box                     *
 *   MinMaxAABoxClass::Add_Box -- Updates this box to enclose the specified box                *
 *   MinMaxAABoxClass::Transform -- Updates this box to enclose its transformed version        *
 *   MinMaxAABoxClass::Translate -- translates the box                                         *
 *   AABoxClass::Init -- Init from a line segment                                              *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#if defined(_MSC_VER)
#pragma once
#endif

#ifndef AABOX_H
#define AABOX_H

#include "always.h"
#include "matrix3d.h"
#include "lineseg.h"
#include "colmath.h"

class AABoxClass;
class MinMaxAABoxClass;
class OBBoxClass;
class TriClass;
class PlaneClass;
struct CastResultStruct;


/*
** AABoxClass
**
** Axis-Aligned Boxes.  I've coded these similar to the OrientedBoxClass only 
** without a rotation matrix.  A similar algorithm is used to test the box
** for intersection.
*/
class AABoxClass
{

public:

	WWINLINE AABoxClass(void) { }

	WWINLINE AABoxClass(const Vector3 & center,const Vector3 & extent) : 
		Center(center),
		Extent(extent)
	{ }

	AABoxClass(const MinMaxAABoxClass & minmaxbox) { Init(minmaxbox); }

	AABoxClass(Vector3 * points,int num) { Init(points,num); }

	bool operator== (const AABoxClass &src);
	bool operator!= (const AABoxClass &src);

	WWINLINE void		Init(const Vector3& center,const Vector3 & extent) { Center = center; Extent = extent; }
	WWINLINE void		Init(Vector3 * points,int num);
	WWINLINE void		Init(const MinMaxAABoxClass & minmaxbox);
	void		Init(const LineSegClass & line);
	void		Init_Min_Max(const Vector3 & min,const Vector3 & max);
	void		Init_Random(float min_center = -1.0f,float max_center = 1.0f,float min_extent = 0.5f,float max_extent = 1.0f);

	void		Add_Point(const Vector3 & point);
	void		Add_Box(const AABoxClass & b);
	void		Add_Box(const MinMaxAABoxClass & b);
	float		Project_To_Axis(const Vector3 & axis) const;

	void		Transform(const Matrix3D & tm);
	void		Translate(const Vector3 & pos);

	WWINLINE float Volume(void) const { return 2.0*Extent.X * 2.0*Extent.Y * 2.0*Extent.Z; }
	WWINLINE bool		Contains(const Vector3 & point) const;
	WWINLINE bool		Contains(const AABoxClass & other_box) const;
	WWINLINE bool		Contains(const MinMaxAABoxClass & other_box) const;

	static void	Transform(const Matrix3D & tm,const AABoxClass & in,AABoxClass * out);

	Vector3	Center;			// world space center
	Vector3	Extent;			// size of the box in the three directions

};

/*
** MinMaxAABoxClass
** This is another form of an AABox.  It can be faster to build one of these
** and then convert it into a center-extent AABox in some cases.  Its purpose
** is basically that.
*/
class MinMaxAABoxClass
{
public:

	WWINLINE MinMaxAABoxClass(void) { }

	WWINLINE MinMaxAABoxClass(const Vector3 & min_corner,const Vector3 & max_corner) :
		MinCorner(min_corner),
		MaxCorner(max_corner)
	{
	}
	
	WWINLINE MinMaxAABoxClass(Vector3 * points,int num) { Init(points,num); }

	WWINLINE MinMaxAABoxClass(const AABoxClass & that) { Init(that); }

	WWINLINE void		Init(Vector3 * points,int num);
	WWINLINE void		Init(const AABoxClass & box);
	void		Init_Empty(void);
	
	void		Add_Point(const Vector3 & point);
	void		Add_Box(const MinMaxAABoxClass & box);
	void		Add_Box(const AABoxClass & box);
	void		Add_Box(const Vector3 & min_corner,const Vector3 & max_corner);

	void		Transform(const Matrix3D & tm);
	void		Translate(const Vector3 & pos);

	WWINLINE float		Volume(void) const { Vector3 size = MaxCorner - MinCorner; return size.X*size.Y*size.Z; }

	Vector3	MinCorner;
	Vector3	MaxCorner;
};




/***********************************************************************************************
 * AABoxClass::Transform -- transform an aabox                                                 *
 *                                                                                             *
 * Note that this function expands the box to enclose its transformed form.                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/24/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void	AABoxClass::Transform(const Matrix3D & tm)
{
	Vector3 oldcenter = Center;
	Vector3 oldextent = Extent;
	tm.Transform_Center_Extent_AABox(oldcenter,oldextent,&Center,&Extent);
}


/***********************************************************************************************
 * AABoxClass::Translate -- translate an aabox                                                 *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/24/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void	AABoxClass::Translate(const Vector3 & trans)
{
	Center += trans;
}


/***********************************************************************************************
 * AABoxClass::operator== -- Comparison operator                                               *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   6/21/00    PDS : Created.                                                                 *
 *=============================================================================================*/
WWINLINE  bool AABoxClass::operator== (const AABoxClass &src)
{
	return (Center == src.Center) && (Extent == src.Extent);
}


/***********************************************************************************************
 * AABoxClass::operator!= -- Comparison operator                                               *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   6/21/00    PDS : Created.                                                                 *
 *=============================================================================================*/
WWINLINE bool AABoxClass::operator!= (const AABoxClass &src)
{
	return (Center != src.Center) || (Extent != src.Extent);
}


/***********************************************************************************************
 * AABoxClass::Init -- create a box which bounds the given points		                          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/24/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void AABoxClass::Init(Vector3 * points,int num)
{
	Vector3 Min = points[0];
	Vector3 Max = points[0];
	
	for (int i=1; i<num; i++) {
		if (Min.X > points[i].X) Min.X = points[i].X;
		if (Min.Y > points[i].Y) Min.Y = points[i].Y;
		if (Min.Z > points[i].Z) Min.Z = points[i].Z;

		if (Max.X < points[i].X) Max.X = points[i].X;
		if (Max.Y < points[i].Y) Max.Y = points[i].Y;
		if (Max.Z < points[i].Z) Max.Z = points[i].Z;
	}
	
	Center = (Max + Min) * 0.5f;
	Extent = (Max - Min) * 0.5f;
}


/***********************************************************************************************
 * AABoxClass::Init -- initialize from a min-max form of a box                                 *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void AABoxClass::Init(const MinMaxAABoxClass & mmbox)
{
	Center = (mmbox.MaxCorner + mmbox.MinCorner) * 0.5f;
	Extent = (mmbox.MaxCorner - mmbox.MinCorner) * 0.5f;
}


/***********************************************************************************************
 * AABoxClass::Init -- Init from a line segment                                                *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   4/27/2000  gth : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void AABoxClass::Init(const LineSegClass & line)
{
	Vector3 min_corner = line.Get_P0();
	Vector3 max_corner = line.Get_P0();
	
	if (min_corner.X > line.Get_P1().X) min_corner.X = line.Get_P1().X;
	if (min_corner.Y > line.Get_P1().Y) min_corner.Y = line.Get_P1().Y;
	if (min_corner.Z > line.Get_P1().Z) min_corner.Z = line.Get_P1().Z;

	if (max_corner.X < line.Get_P1().X) max_corner.X = line.Get_P1().X;
	if (max_corner.Y < line.Get_P1().Y) max_corner.Y = line.Get_P1().Y;
	if (max_corner.Z < line.Get_P1().Z) max_corner.Z = line.Get_P1().Z;

	Center = (max_corner + min_corner) * 0.5f;
	Extent = (max_corner - min_corner) * 0.5f;
}

/***********************************************************************************************
 * AABoxClass::Init_Min_Max -- init the box from a min and max vector                          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   4/9/99     GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void AABoxClass::Init_Min_Max(const Vector3 & min,const Vector3 & max)
{
	Center = (max + min) * 0.5f;
	Extent = (max - min) * 0.5f;
}


/***********************************************************************************************
 * AABoxClass::Add_Point -- expand the box to contain the given point                          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/24/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void AABoxClass::Add_Point(const Vector3 & point)
{
	Vector3 Min = Center - Extent;
	Vector3 Max = Center + Extent;

	if (Min.X > point.X) Min.X = point.X;
	if (Min.Y > point.Y) Min.Y = point.Y;
	if (Min.Z > point.Z) Min.Z = point.Z;

	if (Max.X < point.X) Max.X = point.X;
	if (Max.Y < point.Y) Max.Y = point.Y;
	if (Max.Z < point.Z) Max.Z = point.Z;

	Center = (Max + Min) / 2.0f;
	Extent = (Max - Min) / 2.0f;
}


/***********************************************************************************************
 * AABoxClass::Add_Box -- expand this box to enclose the passed box                            *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *   9/29/2000  gth : Ok to add boxes with zero extent                                         *
 *=============================================================================================*/
WWINLINE void AABoxClass::Add_Box(const AABoxClass & b)
{
	Vector3 newmin = Center - Extent;
	Vector3 newmax = Center + Extent;
	newmin.Update_Min(b.Center - b.Extent);
	newmax.Update_Max(b.Center + b.Extent);

	Center = (newmax + newmin) * 0.5f;
	Extent = (newmax - newmin) * 0.5f;
}


/***********************************************************************************************
 * AABoxClass::Add_Box -- Expand this box to enclose the passed box                            *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *   9/29/2000  gth : Ok to add boxes with zero extent                                         *
 *=============================================================================================*/
WWINLINE void AABoxClass::Add_Box(const MinMaxAABoxClass & b)
{
	Vector3 newmin = Center - Extent;
	Vector3 newmax = Center + Extent;
	newmin.Update_Min(b.MinCorner);
	newmax.Update_Max(b.MaxCorner);

	Center = (newmax + newmin) * 0.5f;
	Extent = (newmax - newmin) * 0.5f;
}

/***********************************************************************************************
 * AABoxClass::Project_To_Axis -- compute projection onto the given axis                       *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/24/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE float AABoxClass::Project_To_Axis(const Vector3 & axis) const
{
	float x = Extent[0] * axis[0];
	float y = Extent[1] * axis[1];
	float z = Extent[2] * axis[2];

	// projection is the sum of the absolute values of the projections of the three extents
	return (WWMath::Fabs(x) + WWMath::Fabs(y) + WWMath::Fabs(z));
}

/***********************************************************************************************
 * AABoxClass::Contains -- Test whether this box contains the given box                        *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/2/98     GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE bool AABoxClass::Contains(const AABoxClass & other_box) const
{
	return CollisionMath::Overlap_Test(*this,other_box) == CollisionMath::INSIDE;
}

/***********************************************************************************************
 * AABoxClass::Contains -- Test whether this box contains the given box                        *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/2/98     GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE bool AABoxClass::Contains(const MinMaxAABoxClass & other_box) const
{
	Vector3 bmin = Center - Extent;
	Vector3 bmax = Center + Extent;

	if (other_box.MinCorner.X < bmin.X) return false;
	if (other_box.MinCorner.Y < bmin.Y) return false;
	if (other_box.MinCorner.Z < bmin.Z) return false;

	if (other_box.MaxCorner.X > bmax.X) return false;
	if (other_box.MaxCorner.Y > bmax.Y) return false;
	if (other_box.MaxCorner.Z > bmax.Z) return false;

	return true;
}

/***********************************************************************************************
 * AABoxClass::Contains -- test whether this box contains the given point                      *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/2/98     GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE bool AABoxClass::Contains(const Vector3 & point) const
{
	return CollisionMath::Overlap_Test(*this,point) == CollisionMath::INSIDE;
}

/***********************************************************************************************
 * MinMaxAABoxClass::Init -- init the box from an array of points                              *
 *                                                                                             *
 * Makes a box which encloses the given array of points                                        *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void MinMaxAABoxClass::Init(Vector3 * points,int num)
{
	assert(num > 0);
	assert(points != NULL);
	MinCorner = points[0];
	MaxCorner = points[0];
	for (int i=0; i<num; i++) {
		MinCorner.Update_Min(points[i]);
		MaxCorner.Update_Max(points[i]);
	}
}


/***********************************************************************************************
 * MinMaxAABoxClass::Init -- initializes this box from a center-extent box                     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void MinMaxAABoxClass::Init(const AABoxClass & box)
{
	MinCorner = box.Center - box.Extent;
	MaxCorner = box.Center + box.Extent;
}


/***********************************************************************************************
 * MinMaxAABoxClass::Add_Point -- updates this box so it encloses the given point              *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void MinMaxAABoxClass::Add_Point(const Vector3 & point)
{
	MinCorner.Update_Min(point);
	MaxCorner.Update_Max(point);
}


/***********************************************************************************************
 * MinMaxAABoxClass::Add_Box -- update this box to enclose the given box                       *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void MinMaxAABoxClass::Add_Box(const MinMaxAABoxClass & box)
{
	if (box.MinCorner == box.MaxCorner) return;

	MinCorner.Update_Min(box.MinCorner);
	MaxCorner.Update_Max(box.MaxCorner);
}


/***********************************************************************************************
 * MinMaxAABoxClass::Add_Box -- update this box to enclose the given box                       *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void MinMaxAABoxClass::Add_Box(const AABoxClass & box)
{
	if (box.Extent == Vector3(0.0f, 0.0f, 0.0f)) return;

	MinCorner.Update_Min(box.Center - box.Extent);
	MaxCorner.Update_Max(box.Center + box.Extent);
}

/***********************************************************************************************
 * MinMaxAABoxClass::Add_Box -- Updates this box to enclose the specified box                  *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void MinMaxAABoxClass::Add_Box(const Vector3 & min_corner,const Vector3 & max_corner)
{
	assert(max_corner.X >= min_corner.X);
	assert(max_corner.Y >= min_corner.Y);
	assert(max_corner.Z >= min_corner.Z);

	if (min_corner == max_corner) return;

	MinCorner.Update_Min(min_corner);
	MaxCorner.Update_Max(max_corner);
}


/***********************************************************************************************
 * MinMaxAABoxClass::Transform -- Updates this box to enclose its transformed version          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void MinMaxAABoxClass::Transform(const Matrix3D & tm)
{
	Vector3 oldmin = MinCorner;
	Vector3 oldmax = MaxCorner;
	tm.Transform_Min_Max_AABox(oldmin,oldmax,&MinCorner,&MaxCorner);
}


/***********************************************************************************************
 * MinMaxAABoxClass::Translate -- translates the box                                           *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   7/31/98    GTH : Created.                                                                 *
 *=============================================================================================*/
WWINLINE void MinMaxAABoxClass::Translate(const Vector3 & pos)
{
	MinCorner+=pos;
	MaxCorner+=pos;
}


#endif