This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/ww3d2/coltest.cpp

368 lines
11 KiB
C++

/*
** 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 : WW3D *
* *
* $Archive:: /Commando/Code/ww3d2/coltest.cpp $*
* *
* Author:: Greg Hjelstrom *
* *
* $Modtime:: 5/07/01 10:26a $*
* *
* $Revision:: 2 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "coltest.h"
AABoxCollisionTestClass::AABoxCollisionTestClass(const AABoxCollisionTestClass & that) :
CollisionTestClass(that),
Box(that.Box),
Move(that.Move),
SweepMin(that.SweepMin),
SweepMax(that.SweepMax)
{
}
AABoxCollisionTestClass::AABoxCollisionTestClass(const AABoxClass & aabox,const Vector3 & move,CastResultStruct * res,int collision_type) :
CollisionTestClass(res,collision_type),
Box(aabox),
Move(move)
{
SweepMin = Box.Center - Box.Extent;
SweepMax = Box.Center + Box.Extent;
Vector3 endmin = Box.Center + move - Box.Extent;
Vector3 endmax = Box.Center + move + Box.Extent;
if (endmax.X > SweepMax.X) SweepMax.X = endmax.X;
if (endmax.Y > SweepMax.Y) SweepMax.Y = endmax.Y;
if (endmax.Z > SweepMax.Z) SweepMax.Z = endmax.Z;
if (endmin.X < SweepMin.X) SweepMin.X = endmin.X;
if (endmin.Y < SweepMin.Y) SweepMin.Y = endmin.Y;
if (endmin.Z < SweepMin.Z) SweepMin.Z = endmin.Z;
}
bool AABoxCollisionTestClass::Cull(const AABoxClass & box)
{
// const float MOVE_THRESHOLD = 2.0f;
// if (WWMath::Fabs(Move.X) + WWMath::Fabs(Move.Y) + WWMath::Fabs(Move.Z) > MOVE_THRESHOLD) {
// CastResultStruct res;
// return !Box.Cast_To_Box(Move,box,&res);
// } else {
Vector3 min_corner;
Vector3 max_corner;
Vector3::Subtract(box.Center,box.Extent,&min_corner);
Vector3::Add(box.Center,box.Extent,&max_corner);
if ((SweepMin.X > max_corner.X) || (SweepMax.X < min_corner.X)) {
return true;
}
if ((SweepMin.Y > max_corner.Y) || (SweepMax.Y < min_corner.Y)) {
return true;
}
if ((SweepMin.Z > max_corner.Z) || (SweepMax.Z < min_corner.Z)) {
return true;
}
return false;
// }
}
void AABoxCollisionTestClass::Rotate(ROTATION_TYPE rotation)
{
#ifndef NDEBUG
int i;
Matrix3D tm(1);
switch(rotation) {
case ROTATE_NONE:
break;
case ROTATE_Z90:
tm = Matrix3D::RotateZ90;
break;
case ROTATE_Z180:
tm = Matrix3D::RotateZ180;
break;
case ROTATE_Z270:
tm = Matrix3D::RotateZ270;
break;
}
Vector3 realcenter = tm * Box.Center;
Vector3 pts[8];
Vector3 & min = SweepMin;
Vector3 & max = SweepMax;
pts[0].Set(min.X,min.Y,min.Z);
pts[1].Set(min.X,max.Y,min.Z);
pts[2].Set(max.X,max.Y,min.Z);
pts[3].Set(max.X,min.Y,min.Z);
pts[4].Set(min.X,min.Y,max.Z);
pts[5].Set(min.X,max.Y,max.Z);
pts[6].Set(max.X,max.Y,max.Z);
pts[7].Set(max.X,min.Y,max.Z);
for (i=0; i<8; i++) {
pts[i] = tm * pts[i];
}
Vector3 realmin = pts[0];
Vector3 realmax = pts[0];
for (i=1; i<8; i++) {
if (realmin.X >= pts[i].X) realmin.X = pts[i].X;
if (realmin.Y >= pts[i].Y) realmin.Y = pts[i].Y;
if (realmin.Z >= pts[i].Z) realmin.Z = pts[i].Z;
if (realmax.X <= pts[i].X) realmax.X = pts[i].X;
if (realmax.Y <= pts[i].Y) realmax.Y = pts[i].Y;
if (realmax.Z <= pts[i].Z) realmax.Z = pts[i].Z;
}
#endif
// rotate the test by the desired rotation about the Z axis, special cased for
// 90 degree rotations about Z. arbitrary rotations cause the axis aligned
// box to not be aligned any more :-)
float tmp,minx,miny,maxx,maxy;
switch(rotation) {
case ROTATE_NONE:
break;
case ROTATE_Z90:
// rotate the center point and the move vector
tmp = Box.Center.X; Box.Center.X = -Box.Center.Y; Box.Center.Y = tmp;
tmp = Move.X; Move.X = -Move.Y; Move.Y = tmp;
// swap x and y for the extent
tmp = Box.Extent.X; Box.Extent.X = Box.Extent.Y; Box.Extent.Y = tmp;
// update sweep bounding box
minx = SweepMin.X; miny = SweepMin.Y; maxx = SweepMax.X; maxy = SweepMax.Y;
SweepMin.X = -maxy;
SweepMin.Y = minx;
SweepMax.X = -miny;
SweepMax.Y = maxx;
break;
case ROTATE_Z180:
// rotate center and move vector
Box.Center.X = -Box.Center.X;
Box.Center.Y = -Box.Center.Y;
Move.X = -Move.X;
Move.Y = -Move.Y;
// update min/max boxes
minx = SweepMin.X; miny = SweepMin.Y; maxx = SweepMax.X; maxy = SweepMax.Y;
SweepMin.X = -maxx;
SweepMin.Y = -maxy;
SweepMax.X = -minx;
SweepMax.Y = -miny;
break;
case ROTATE_Z270:
// rotate center and move.
tmp = Box.Center.X; Box.Center.X = Box.Center.Y; Box.Center.Y = -tmp;
tmp = Move.X; Move.X = Move.Y; Move.Y = -tmp;
// update extent (x and y axis swap)
tmp = Box.Extent.X; Box.Extent.X = Box.Extent.Y; Box.Extent.Y = tmp;
// update min/max boxes
minx = SweepMin.X; miny = SweepMin.Y; maxx = SweepMax.X; maxy = SweepMax.Y;
SweepMin.X = miny;
SweepMin.Y = -maxx;
SweepMax.X = maxy;
SweepMax.Y = -minx;
break;
}
#ifndef NDEBUG
assert((Box.Center - realcenter).Length() < 0.001f);
assert((SweepMin - realmin).Length() < 0.001f);
assert((SweepMax - realmax).Length() < 0.001f);
#endif
}
void AABoxCollisionTestClass::Transform(const Matrix3D & tm)
{
// NOTE: this function will expand the box to enclose the rotated
// form of the original box. In practice, this function was only
// implemented to double-check the results of the Translate and Rotate
// functions.
int i;
Vector3 tmpcenter = Box.Center;
Vector3 tmpextent = Box.Extent;
tm.Transform_Center_Extent_AABox(tmpcenter,tmpextent,&Box.Center,&Box.Extent);
Move = tm.Rotate_Vector(Move);
Vector3 pts[8];
Vector3 & min = SweepMin;
Vector3 & max = SweepMax;
pts[0].Set(min.X,min.Y,min.Z);
pts[1].Set(min.X,max.Y,min.Z);
pts[2].Set(max.X,max.Y,min.Z);
pts[3].Set(max.X,min.Y,min.Z);
pts[4].Set(min.X,min.Y,max.Z);
pts[5].Set(min.X,max.Y,max.Z);
pts[6].Set(max.X,max.Y,max.Z);
pts[7].Set(max.X,min.Y,max.Z);
for (i=0; i<8; i++) {
pts[i] = tm * pts[i];
}
Vector3 realmin = pts[0];
Vector3 realmax = pts[0];
for (i=1; i<8; i++) {
if (realmin.X >= pts[i].X) realmin.X = pts[i].X;
if (realmin.Y >= pts[i].Y) realmin.Y = pts[i].Y;
if (realmin.Z >= pts[i].Z) realmin.Z = pts[i].Z;
if (realmax.X <= pts[i].X) realmax.X = pts[i].X;
if (realmax.Y <= pts[i].Y) realmax.Y = pts[i].Y;
if (realmax.Z <= pts[i].Z) realmax.Z = pts[i].Z;
}
SweepMin = realmin;
SweepMax = realmax;
}
OBBoxCollisionTestClass::OBBoxCollisionTestClass
(
const OBBoxClass & obbox,
const Vector3 & move,
CastResultStruct * res,
int type
) :
CollisionTestClass(res,type),
Box(obbox),
Move(move)
{
Vector3 max_extent;
max_extent.X = WWMath::Fabs(Box.Basis[0][0] * Box.Extent.X) +
WWMath::Fabs(Box.Basis[0][1] * Box.Extent.Y) +
WWMath::Fabs(Box.Basis[0][2] * Box.Extent.Z) + 0.01f;
max_extent.Y = WWMath::Fabs(Box.Basis[1][0] * Box.Extent.X) +
WWMath::Fabs(Box.Basis[1][1] * Box.Extent.Y) +
WWMath::Fabs(Box.Basis[1][2] * Box.Extent.Z) + 0.01f;
max_extent.Z = WWMath::Fabs(Box.Basis[2][0] * Box.Extent.X) +
WWMath::Fabs(Box.Basis[2][1] * Box.Extent.Y) +
WWMath::Fabs(Box.Basis[2][2] * Box.Extent.Z) + 0.01f;
SweepMin = Box.Center - max_extent;
SweepMax = Box.Center + max_extent;
Vector3 endmin = Box.Center + move - max_extent;
Vector3 endmax = Box.Center + move + max_extent;
if (endmax.X > SweepMax.X) SweepMax.X = endmax.X;
if (endmax.Y > SweepMax.Y) SweepMax.Y = endmax.Y;
if (endmax.Z > SweepMax.Z) SweepMax.Z = endmax.Z;
if (endmin.X < SweepMin.X) SweepMin.X = endmin.X;
if (endmin.Y < SweepMin.Y) SweepMin.Y = endmin.Y;
if (endmin.Z < SweepMin.Z) SweepMin.Z = endmin.Z;
}
OBBoxCollisionTestClass::OBBoxCollisionTestClass(const OBBoxCollisionTestClass & that) :
CollisionTestClass(that),
Box(that.Box),
Move(that.Move),
SweepMin(that.SweepMin),
SweepMax(that.SweepMax)
{
}
OBBoxCollisionTestClass::OBBoxCollisionTestClass
(
const OBBoxCollisionTestClass & that,
const Matrix3D & tm
) :
CollisionTestClass(that)
{
tm.Transform_Min_Max_AABox(that.SweepMin,that.SweepMax,&SweepMin,&SweepMax);
Matrix3D::Rotate_Vector(tm,that.Move,&Move);
OBBoxClass::Transform(tm,that.Box,&Box);
}
OBBoxCollisionTestClass::OBBoxCollisionTestClass
(
const AABoxCollisionTestClass & that,
const Matrix3D & tm
) :
CollisionTestClass(that)
{
tm.Transform_Min_Max_AABox(that.SweepMin,that.SweepMax,&SweepMin,&SweepMax);
Matrix3D::Rotate_Vector(tm,that.Move,&Move);
Matrix3D::Transform_Vector(tm,that.Box.Center,&(Box.Center));
Box.Extent = that.Box.Extent;
Box.Basis = tm; // copies the 3x3 rotation portion of the transform
}
bool OBBoxCollisionTestClass::Cull(const AABoxClass & box)
{
Vector3 min_corner;
Vector3 max_corner;
Vector3::Subtract(box.Center,box.Extent,&min_corner);
Vector3::Add(box.Center,box.Extent,&max_corner);
if ((SweepMin.X > max_corner.X) || (SweepMax.X < min_corner.X)) {
return true;
}
if ((SweepMin.Y > max_corner.Y) || (SweepMax.Y < min_corner.Y)) {
return true;
}
if ((SweepMin.Z > max_corner.Z) || (SweepMax.Z < min_corner.Z)) {
return true;
}
return false;
}