mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
2d2d3c7560
Working example of a plane convex type, now groundplane does not need to create a box for its collisions.
293 lines
9.1 KiB
C++
293 lines
9.1 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef _CONVEX_H_
|
|
#define _CONVEX_H_
|
|
|
|
#ifndef _MMATH_H_
|
|
#include "math/mMath.h"
|
|
#endif
|
|
#ifndef _TVECTOR_H_
|
|
#include "core/util/tVector.h"
|
|
#endif
|
|
|
|
struct Collision;
|
|
class CollisionList;
|
|
struct CollisionStateList;
|
|
class AbstractPolyList;
|
|
class SceneObject;
|
|
class BaseMatInstance;
|
|
class Convex;
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
class ConvexFeature
|
|
{
|
|
public:
|
|
struct Edge {
|
|
S32 vertex[2];
|
|
};
|
|
struct Face {
|
|
VectorF normal;
|
|
S32 vertex[3];
|
|
};
|
|
|
|
Vector<Point3F> mVertexList;
|
|
Vector<Edge> mEdgeList;
|
|
Vector<Face> mFaceList;
|
|
BaseMatInstance* material;
|
|
SceneObject* mObject;
|
|
|
|
ConvexFeature()
|
|
: mVertexList(64), mEdgeList(128), mFaceList(64), material( 0 ), mObject(NULL)
|
|
{
|
|
VECTOR_SET_ASSOCIATION(mVertexList);
|
|
VECTOR_SET_ASSOCIATION(mEdgeList);
|
|
VECTOR_SET_ASSOCIATION(mFaceList);
|
|
}
|
|
|
|
void reset();
|
|
|
|
bool collide(ConvexFeature& cf,CollisionList* cList, F32 tol = 0.1);
|
|
void testVertex(const Point3F& v,CollisionList* cList,bool,F32 tol);
|
|
void testEdge(ConvexFeature* cf,const Point3F& s1, const Point3F& e1, CollisionList* cList, F32 tol);
|
|
bool inVolume(const Point3F& v);
|
|
};
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
// TODO: This sucks... replace with registration object
|
|
// for assigning type ids.
|
|
enum ConvexType {
|
|
TSConvexType,
|
|
BoxConvexType,
|
|
TerrainConvexType,
|
|
ShapeBaseConvexType,
|
|
TSStaticConvexType,
|
|
AtlasChunkConvexType, ///< @deprecated
|
|
AtlasConvexType,
|
|
TSPolysoupConvexType,
|
|
MeshRoadConvexType,
|
|
ConvexShapeCollisionConvexType,
|
|
ForestConvexType,
|
|
PlaneConvexType
|
|
};
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
struct CollisionState
|
|
{
|
|
CollisionStateList* mLista;
|
|
CollisionStateList* mListb;
|
|
Convex* mA;
|
|
Convex* mB;
|
|
|
|
F32 mDist; // Current estimated distance
|
|
VectorF mDistvec; // Vector between closest points
|
|
|
|
//
|
|
CollisionState();
|
|
virtual ~CollisionState();
|
|
virtual void swap();
|
|
virtual void set(Convex* a,Convex* b,const MatrixF& a2w, const MatrixF& b2w);
|
|
virtual F32 distance(const MatrixF& a2w, const MatrixF& b2w, const F32 dontCareDist,
|
|
const MatrixF* w2a = NULL, const MatrixF* _w2b = NULL);
|
|
};
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
struct CollisionStateList
|
|
{
|
|
static CollisionStateList sFreeList;
|
|
CollisionStateList* mNext;
|
|
CollisionStateList* mPrev;
|
|
CollisionState* mState;
|
|
|
|
CollisionStateList();
|
|
|
|
void linkAfter(CollisionStateList* next);
|
|
void unlink();
|
|
bool isEmpty() { return mNext == this; }
|
|
|
|
static CollisionStateList* alloc();
|
|
void free();
|
|
};
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
struct CollisionWorkingList
|
|
{
|
|
static CollisionWorkingList sFreeList;
|
|
struct WLink {
|
|
CollisionWorkingList* mNext;
|
|
CollisionWorkingList* mPrev;
|
|
} wLink;
|
|
struct RLink {
|
|
CollisionWorkingList* mNext;
|
|
CollisionWorkingList* mPrev;
|
|
} rLink;
|
|
Convex* mConvex;
|
|
|
|
void wLinkAfter(CollisionWorkingList* next);
|
|
void rLinkAfter(CollisionWorkingList* next);
|
|
void unlink();
|
|
CollisionWorkingList();
|
|
|
|
static CollisionWorkingList* alloc();
|
|
void free();
|
|
};
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
class Convex {
|
|
|
|
/// @name Linked list management
|
|
/// @{
|
|
|
|
/// Next item in linked list of Convexes.
|
|
Convex* mNext;
|
|
|
|
/// Previous item in linked list of Convexes.
|
|
Convex* mPrev;
|
|
|
|
/// Insert this Convex after the provided convex
|
|
/// @param next
|
|
void linkAfter(Convex* next);
|
|
|
|
/// Remove this Convex from the linked list
|
|
void unlink();
|
|
/// @}
|
|
|
|
U32 mTag;
|
|
static U32 sTag;
|
|
|
|
protected:
|
|
CollisionStateList mList; ///< Objects we're testing against
|
|
CollisionWorkingList mWorking; ///< Objects within our bounds
|
|
CollisionWorkingList mReference; ///< Other convex testing against us
|
|
SceneObject* mObject; ///< Object this Convex is built around
|
|
ConvexType mType; ///< Type of Convex this is @see ConvexType
|
|
|
|
public:
|
|
|
|
/// Constructor
|
|
Convex();
|
|
|
|
/// Destructor
|
|
virtual ~Convex();
|
|
|
|
/// Registers another Convex by linking it after this one
|
|
void registerObject(Convex *convex);
|
|
|
|
/// Runs through the linked list of Convex objects and removes the ones
|
|
/// with no references
|
|
void collectGarbage();
|
|
|
|
/// Deletes all convex objects in the list
|
|
void nukeList();
|
|
|
|
/// Returns the type of this Convex
|
|
ConvexType getType() const { return mType; }
|
|
|
|
/// Returns the object this Convex is built from
|
|
SceneObject* getObject() const { return mObject; }
|
|
|
|
/// Adds the provided Convex to the list of objects within the bounds of this Convex
|
|
/// @param ptr Convex to add to the working list of this object
|
|
void addToWorkingList(Convex* ptr);
|
|
|
|
/// Returns the list of objects currently inside the bounds of this Convex
|
|
CollisionWorkingList& getWorkingList() { return mWorking; }
|
|
|
|
/// Finds the closest
|
|
CollisionState* findClosestState(const MatrixF& mat, const Point3F& scale, const F32 dontCareDist = 1);
|
|
|
|
/// Returns the list of objects this object is testing against
|
|
CollisionStateList* getStateList() const { return mList.mNext; }
|
|
|
|
/// Updates the CollisionStateList (mList) with new collision states and removing
|
|
/// ones no longer under consideration
|
|
/// @param mat Used as the matrix to create a bounding box for updating the list
|
|
/// @param scale Used to scale the bounding box
|
|
/// @param displacement Bounding box displacement (optional)
|
|
void updateStateList(const MatrixF& mat, const Point3F& scale, const Point3F* displacement = NULL);
|
|
|
|
/// Updates the working collision list of objects which are currently colliding with
|
|
/// (inside the bounds of) this Convex.
|
|
///
|
|
/// @param box Used as the bounding box.
|
|
/// @param colMask Mask of objects to check against.
|
|
void updateWorkingList(const Box3F& box, const U32 colMask);
|
|
|
|
/// Clear out the working collision list of objects
|
|
void clearWorkingList();
|
|
|
|
/// Returns the transform of the object this is built around
|
|
virtual const MatrixF& getTransform() const;
|
|
|
|
/// Returns the scale of the object this is built around
|
|
virtual const Point3F& getScale() const;
|
|
|
|
/// Returns the bounding box for the object this is built around in world space
|
|
virtual Box3F getBoundingBox() const;
|
|
|
|
/// Returns the object space bounding box for the object this is built around
|
|
/// transformed and scaled
|
|
/// @param mat Matrix to transform the object-space box by
|
|
/// @param scale Scaling factor to scale the bounding box by
|
|
virtual Box3F getBoundingBox(const MatrixF& mat, const Point3F& scale) const;
|
|
|
|
/// Returns the farthest point, along a vector, still bound by the convex
|
|
/// @param v Vector
|
|
virtual Point3F support(const VectorF& v) const;
|
|
|
|
/// This is used by the GJK collision in Vehicle.
|
|
/// The Convex class should add verts, edges, and faces to the passed
|
|
/// ConvexFeature that face towards the passed normal vector. Verts added
|
|
/// in this way should also be transformed by the passed matrix.
|
|
/// @param mat Transform which should be applied to verts added to the ConvexFeature
|
|
/// @param n Normal vector
|
|
/// @param cf ConvexFeature to add data to.
|
|
virtual void getFeatures(const MatrixF& mat,const VectorF& n, ConvexFeature* cf);
|
|
|
|
/// Builds a collision poly list out of this convex
|
|
/// @param list (Out) Poly list built
|
|
virtual void getPolyList(AbstractPolyList* list);
|
|
|
|
///
|
|
bool getCollisionInfo(const MatrixF& mat, const Point3F& scale, CollisionList* cList,F32 tol);
|
|
|
|
/// Render convex(s) for debugging purposes.
|
|
virtual void renderWorkingList();
|
|
|
|
/// Render this convex for debugging purposes.
|
|
virtual void render();
|
|
};
|
|
|
|
#endif // _CONVEX_H_
|