/* ** 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 . */ /*********************************************************************************************** *** 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