/*
** 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:: /VSS_Sync/ww3d2/coltest.h $*
* *
* Author:: Greg Hjelstrom *
* *
* $Modtime:: 9/12/01 10:01p $*
* *
* $Revision:: 4 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef COLTEST_H
#define COLTEST_H
#include "always.h"
#include "castres.h"
#include "lineseg.h"
#include "aabox.h"
#include "obbox.h"
#include "tri.h"
#include "colmath.h"
#include "coltype.h"
class RenderObjClass;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CollisionTestClass
//
// Each type of collision test will have an associated class which
// ties together all of the information necessary for the test.
// These classes also provide a perfect place to add any information
// which can be pre-calculated.
//
// The base class: CollisionTestClass simply contains a pointer to
// the user's CastResultStruct which will contain the results of
// the collision test. I store a pointer to a result structure
// because in some cases, new CollisionTestClasses are created in
// the process of checking (e.g. if the test needs to be transformed
// into another coordinate system) and I did not want to be
// constantly copying the result structure around. So, the user
// must allocate a result structure (usually on the stack) and keep it
// until the CollisionTestClass is discarded.
//
// Every CollisionTestClass should have the following functions:
//
// bool Cull(const Vector3 & min,const Vector3 & max);
// bool Cull(const AABoxClass & box);
// bool Cast_To_Triangle(const TriClass & tri);
//
// These are not virtual because I don't want to pay the price of virtual function
// calls at the point in the code where these are used. It may be possible to
// write template functions if we use these exact function prototpyes for all
// collision test classes though.
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
class CollisionTestClass
{
public:
CollisionTestClass(CastResultStruct * res,int collision_type);
CollisionTestClass(const CollisionTestClass & that);
public:
CastResultStruct * Result;
int CollisionType;
RenderObjClass * CollidedRenderObj;
};
inline CollisionTestClass::CollisionTestClass(CastResultStruct * res,int collision_type) :
Result(res),
CollisionType(collision_type),
CollidedRenderObj(NULL)
{
}
inline CollisionTestClass::CollisionTestClass(const CollisionTestClass & that) :
Result(that.Result),
CollisionType(that.CollisionType),
CollidedRenderObj(that.CollidedRenderObj)
{
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// RayCollisionTestClass
//
// Contains a linesegment to be tested and of course the inherited
// pointer to a CollisionStruct for the result
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
class RayCollisionTestClass : public CollisionTestClass
{
public:
RayCollisionTestClass(const LineSegClass & ray,CastResultStruct * res,int collision_type = COLLISION_TYPE_0,bool ignore_translucent_meshes=false);
RayCollisionTestClass(const RayCollisionTestClass & raytest,const Matrix3D & tm);
bool Cull(const Vector3 & min,const Vector3 & max);
bool Cull(const AABoxClass & box);
bool Cast_To_Triangle(const TriClass & tri);
public:
LineSegClass Ray;
bool IgnoreTranslucentMeshes;
private:
// not implemented
RayCollisionTestClass(const RayCollisionTestClass &);
RayCollisionTestClass & operator = (const RayCollisionTestClass &);
};
inline RayCollisionTestClass::RayCollisionTestClass(const LineSegClass & ray,CastResultStruct * res,int collision_type,bool ignore_translucent_meshes) :
CollisionTestClass(res,collision_type),
Ray(ray),
IgnoreTranslucentMeshes(ignore_translucent_meshes)
{
}
inline RayCollisionTestClass::RayCollisionTestClass(const RayCollisionTestClass & raytest,const Matrix3D & tm) :
CollisionTestClass(raytest),
Ray(raytest.Ray,tm),
IgnoreTranslucentMeshes(raytest.IgnoreTranslucentMeshes)
{
}
inline bool RayCollisionTestClass::Cull(const Vector3 & min,const Vector3 & max)
{
return (CollisionMath::Overlap_Test(min,max,Ray) == CollisionMath::POS);
}
inline bool RayCollisionTestClass::Cull(const AABoxClass & box)
{
return (CollisionMath::Overlap_Test(box,Ray) == CollisionMath::POS);
}
inline bool RayCollisionTestClass::Cast_To_Triangle(const TriClass & tri)
{
return CollisionMath::Collide(Ray,tri,Result);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// AABoxCollisionTestClass
//
// Contains an Axis Aligned Box and a movement vector to be tested
// for collision. Also adds Min and Max vectors both for the initial
// box and for the volume swept out by the box.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
class AABoxCollisionTestClass : public CollisionTestClass
{
public:
AABoxCollisionTestClass(const AABoxClass & aabox,const Vector3 & move,CastResultStruct * res,int collision_type = COLLISION_TYPE_0);
AABoxCollisionTestClass(const AABoxCollisionTestClass & that);
enum ROTATION_TYPE
{
ROTATE_NONE = 0,
ROTATE_Z90,
ROTATE_Z180,
ROTATE_Z270
};
bool Cull(const Vector3 & min,const Vector3 & max);
bool Cull(const AABoxClass & box);
bool Cast_To_Triangle(const TriClass & tri);
void Translate(const Vector3 & translation);
void Rotate(ROTATION_TYPE rotation);
void Transform(const Matrix3D & tm);
public:
AABoxClass Box;
Vector3 Move;
Vector3 SweepMin;
Vector3 SweepMax;
private:
// not implemented
AABoxCollisionTestClass & operator = (const AABoxCollisionTestClass &);
};
inline void AABoxCollisionTestClass::Translate(const Vector3 & translation)
{
// translate the test by the desired translation vector
Box.Center += translation;
SweepMin += translation;
SweepMax += translation;
}
inline bool AABoxCollisionTestClass::Cull(const Vector3 & min,const Vector3 & max)
{
if ((SweepMin.X > max.X) || (SweepMax.X < min.X)) {
return true;
}
if ((SweepMin.Y > max.Y) || (SweepMax.Y < min.Y)) {
return true;
}
if ((SweepMin.Z > max.Z) || (SweepMax.Z < min.Z)) {
return true;
}
return false;
}
inline bool AABoxCollisionTestClass::Cast_To_Triangle(const TriClass & tri)
{
return CollisionMath::Collide(Box,Move,tri,Result);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// OBBoxCollisionTestClass
//
// Contains an Oriented Bounding Box and a movement vector to be tested
// for collision. Also adds Min and Max vectors (axis aligned box)
// both for the initial box and for the volume swept out by the box.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
class OBBoxCollisionTestClass : public CollisionTestClass
{
public:
OBBoxCollisionTestClass(const OBBoxClass & obbox,const Vector3 & move,CastResultStruct * res,int type = COLLISION_TYPE_0);
OBBoxCollisionTestClass(const OBBoxCollisionTestClass & that);
OBBoxCollisionTestClass(const OBBoxCollisionTestClass & that,const Matrix3D & tm);
OBBoxCollisionTestClass(const AABoxCollisionTestClass & that,const Matrix3D & tm);
bool Cull(const Vector3 & min,const Vector3 & max);
bool Cull(const AABoxClass & box);
bool Cast_To_Triangle(const TriClass & tri);
public:
OBBoxClass Box;
Vector3 Move;
Vector3 SweepMin;
Vector3 SweepMax;
private:
// not implemented
OBBoxCollisionTestClass & operator = (const OBBoxCollisionTestClass &);
};
inline bool OBBoxCollisionTestClass::Cull(const Vector3 & min,const Vector3 & max)
{
if ((SweepMin.X > max.X) || (SweepMax.X < min.X)) {
return true;
}
if ((SweepMin.Y > max.Y) || (SweepMax.Y < min.Y)) {
return true;
}
if ((SweepMin.Z > max.Z) || (SweepMax.Z < min.Z)) {
return true;
}
return false;
}
inline bool OBBoxCollisionTestClass::Cast_To_Triangle(const TriClass & tri)
{
return CollisionMath::Collide(Box,Move,tri,Vector3(0,0,0),Result);
}
#endif