TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-14 16:14:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

CollisionState membervar clarification

Browse source
This commit is contained in:
Azaezel 2018-03-15 17:31:28 -05:00
parent e23487b4b1
commit 46bbb88d71
6 changed files with 130 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Engine/source/T3D/rigidShape.cpp
View file

@ -1194,7 +1194,7 @@ bool RigidShape::updateCollision(F32 dt)
mCollisionList.clear(); mCollisionList.clear();
CollisionState *state = mConvex.findClosestState(cmat, getScale(), mDataBlock->collisionTol); CollisionState *state = mConvex.findClosestState(cmat, getScale(), mDataBlock->collisionTol);
if (state && state->dist <= mDataBlock->collisionTol) if (state && state->mDist <= mDataBlock->collisionTol)
{ {
//resolveDisplacement(ns,state,dt); //resolveDisplacement(ns,state,dt);
mConvex.getCollisionInfo(cmat, getScale(), &mCollisionList, mDataBlock->collisionTol); mConvex.getCollisionInfo(cmat, getScale(), &mCollisionList, mDataBlock->collisionTol);
@ -1326,8 +1326,8 @@ bool RigidShape::resolveContacts(Rigid& ns,CollisionList& cList,F32 dt)
bool RigidShape::resolveDisplacement(Rigid& ns,CollisionState *state, F32 dt) bool RigidShape::resolveDisplacement(Rigid& ns,CollisionState *state, F32 dt)
{ {
SceneObject* obj = (state->a->getObject() == this)? SceneObject* obj = (state->mA->getObject() == this)?
state->b->getObject(): state->a->getObject(); state->mB->getObject(): state->mA->getObject();
if (obj->isDisplacable() && ((obj->getTypeMask() & ShapeBaseObjectType) != 0)) if (obj->isDisplacable() && ((obj->getTypeMask() & ShapeBaseObjectType) != 0))
{ {

6
Engine/source/T3D/vehicles/vehicle.cpp
View file

@ -1364,7 +1364,7 @@ bool Vehicle::updateCollision(F32 dt)
mCollisionList.clear(); mCollisionList.clear();
CollisionState *state = mConvex.findClosestState(cmat, getScale(), mDataBlock->collisionTol); CollisionState *state = mConvex.findClosestState(cmat, getScale(), mDataBlock->collisionTol);
if (state && state->dist <= mDataBlock->collisionTol) if (state && state->mDist <= mDataBlock->collisionTol)
{ {
//resolveDisplacement(ns,state,dt); //resolveDisplacement(ns,state,dt);
mConvex.getCollisionInfo(cmat, getScale(), &mCollisionList, mDataBlock->collisionTol); mConvex.getCollisionInfo(cmat, getScale(), &mCollisionList, mDataBlock->collisionTol);
@ -1497,8 +1497,8 @@ bool Vehicle::resolveDisplacement(Rigid& ns,CollisionState *state, F32 dt)
{ {
PROFILE_SCOPE( Vehicle_ResolveDisplacement ); PROFILE_SCOPE( Vehicle_ResolveDisplacement );
SceneObject* obj = (state->a->getObject() == this)? SceneObject* obj = (state->mA->getObject() == this)?
state->b->getObject(): state->a->getObject(); state->mB->getObject(): state->mA->getObject();
if (obj->isDisplacable() && ((obj->getTypeMask() & ShapeBaseObjectType) != 0)) if (obj->isDisplacable() && ((obj->getTypeMask() & ShapeBaseObjectType) != 0))
{ {

18
Engine/source/collision/convex.cpp
View file

@ -520,7 +520,7 @@ void Convex::updateStateList(const MatrixF& mat, const Point3F& scale, const Poi
// Destroy states which are no longer intersecting // Destroy states which are no longer intersecting
for (CollisionStateList* itr = mList.mNext; itr != &mList; itr = itr->mNext) { for (CollisionStateList* itr = mList.mNext; itr != &mList; itr = itr->mNext) {
Convex* cv = (itr->mState->a == this)? itr->mState->b: itr->mState->a; Convex* cv = (itr->mState->mA == this)? itr->mState->mB: itr->mState->mA;
cv->mTag = sTag; cv->mTag = sTag;
if (!box1.isOverlapped(cv->getBoundingBox())) { if (!box1.isOverlapped(cv->getBoundingBox())) {
CollisionState* cs = itr->mState; CollisionState* cs = itr->mState;
@ -568,9 +568,9 @@ CollisionState* Convex::findClosestState(const MatrixF& mat, const Point3F& scal
state->swap(); state->swap();
// Prepare scaled version of transform // Prepare scaled version of transform
MatrixF bxform = state->b->getTransform(); MatrixF bxform = state->mB->getTransform();
temp = bxform; temp = bxform;
Point3F bscale = state->b->getScale(); Point3F bscale = state->mB->getScale();
bxform.scale(bscale); bxform.scale(bscale);
MatrixF bxforminv(true); MatrixF bxforminv(true);
bxforminv.scale(Point3F(1.0f/bscale.x, 1.0f/bscale.y, 1.0f/bscale.z)); bxforminv.scale(Point3F(1.0f/bscale.x, 1.0f/bscale.y, 1.0f/bscale.z));
@ -613,7 +613,7 @@ bool Convex::getCollisionInfo(const MatrixF& mat, const Point3F& scale, Collisio
if (state->mLista != itr) if (state->mLista != itr)
state->swap(); state->swap();
if (state->dist <= tol) if (state->mDist <= tol)
{ {
fa.reset(); fa.reset();
fb.reset(); fb.reset();
@ -628,18 +628,18 @@ bool Convex::getCollisionInfo(const MatrixF& mat, const Point3F& scale, Collisio
MatrixF imat = omat; MatrixF imat = omat;
imat.inverse(); imat.inverse();
imat.mulV(-state->v,&v); imat.mulV(-state->mDistvec,&v);
getFeatures(omat,v,&fa); getFeatures(omat,v,&fa);
imat = state->b->getTransform(); imat = state->mB->getTransform();
imat.scale(state->b->getScale()); imat.scale(state->mB->getScale());
MatrixF bxform = imat; MatrixF bxform = imat;
imat.inverse(); imat.inverse();
imat.mulV(state->v,&v); imat.mulV(state->mDistvec,&v);
state->b->getFeatures(bxform,v,&fb); state->mB->getFeatures(bxform,v,&fb);
fa.collide(fb,cList,tol); fa.collide(fb,cList,tol);
} }

8
Engine/source/collision/convex.h
View file

@ -100,11 +100,11 @@ struct CollisionState
{ {
CollisionStateList* mLista; CollisionStateList* mLista;
CollisionStateList* mListb; CollisionStateList* mListb;
Convex* a; Convex* mA;
Convex* b; Convex* mB;
F32 dist; // Current estimated distance F32 mDist; // Current estimated distance
VectorF v; // Vector between closest points VectorF mDistvec; // Vector between closest points
// //
CollisionState(); CollisionState();

204
Engine/source/collision/gjk.cpp
View file

@ -46,7 +46,7 @@ S32 num_irregularities = 0;
GjkCollisionState::GjkCollisionState() GjkCollisionState::GjkCollisionState()
{ {
a = b = 0; mA = mB = 0;
} }
GjkCollisionState::~GjkCollisionState() GjkCollisionState::~GjkCollisionState()
@ -58,9 +58,9 @@ GjkCollisionState::~GjkCollisionState()
void GjkCollisionState::swap() void GjkCollisionState::swap()
{ {
Convex* t = a; a = b; b = t; Convex* t = mA; mA = mB; mB = t;
CollisionStateList* l = mLista; mLista = mListb; mListb = l; CollisionStateList* l = mLista; mLista = mListb; mListb = l;
v.neg(); mDistvec.neg();
} }
@ -70,44 +70,44 @@ void GjkCollisionState::compute_det()
{ {
// Dot new point with current set // Dot new point with current set
for (S32 i = 0, bit = 1; i < 4; ++i, bit <<=1) for (S32 i = 0, bit = 1; i < 4; ++i, bit <<=1)
if (bits & bit) if (mBits & bit)
dp[i][last] = dp[last][i] = mDot(y[i], y[last]); mDP[i][mLast] = mDP[mLast][i] = mDot(mY[i], mY[mLast]);
dp[last][last] = mDot(y[last], y[last]); mDP[mLast][mLast] = mDot(mY[mLast], mY[mLast]);
// Calulate the determinent // Calulate the determinent
det[last_bit][last] = 1; mDet[mLast_bit][mLast] = 1;
for (S32 j = 0, sj = 1; j < 4; ++j, sj <<= 1) { for (S32 j = 0, sj = 1; j < 4; ++j, sj <<= 1) {
if (bits & sj) { if (mBits & sj) {
S32 s2 = sj | last_bit; S32 s2 = sj | mLast_bit;
det[s2][j] = dp[last][last] - dp[last][j]; mDet[s2][j] = mDP[mLast][mLast] - mDP[mLast][j];
det[s2][last] = dp[j][j] - dp[j][last]; mDet[s2][mLast] = mDP[j][j] - mDP[j][mLast];
for (S32 k = 0, sk = 1; k < j; ++k, sk <<= 1) { for (S32 k = 0, sk = 1; k < j; ++k, sk <<= 1) {
if (bits & sk) { if (mBits & sk) {
S32 s3 = sk | s2; S32 s3 = sk | s2;
det[s3][k] = det[s2][j] * (dp[j][j] - dp[j][k]) + mDet[s3][k] = mDet[s2][j] * (mDP[j][j] - mDP[j][k]) +
det[s2][last] * (dp[last][j] - dp[last][k]); mDet[s2][mLast] * (mDP[mLast][j] - mDP[mLast][k]);
det[s3][j] = det[sk | last_bit][k] * (dp[k][k] - dp[k][j]) + mDet[s3][j] = mDet[sk | mLast_bit][k] * (mDP[k][k] - mDP[k][j]) +
det[sk | last_bit][last] * (dp[last][k] - dp[last][j]); mDet[sk | mLast_bit][mLast] * (mDP[mLast][k] - mDP[mLast][j]);
det[s3][last] = det[sk | sj][k] * (dp[k][k] - dp[k][last]) + mDet[s3][mLast] = mDet[sk | sj][k] * (mDP[k][k] - mDP[k][mLast]) +
det[sk | sj][j] * (dp[j][k] - dp[j][last]); mDet[sk | sj][j] * (mDP[j][k] - mDP[j][mLast]);
} }
} }
} }
} }
if (all_bits == 15) { if (mAll_bits == 15) {
det[15][0] = det[14][1] * (dp[1][1] - dp[1][0]) + mDet[15][0] = mDet[14][1] * (mDP[1][1] - mDP[1][0]) +
det[14][2] * (dp[2][1] - dp[2][0]) + mDet[14][2] * (mDP[2][1] - mDP[2][0]) +
det[14][3] * (dp[3][1] - dp[3][0]); mDet[14][3] * (mDP[3][1] - mDP[3][0]);
det[15][1] = det[13][0] * (dp[0][0] - dp[0][1]) + mDet[15][1] = mDet[13][0] * (mDP[0][0] - mDP[0][1]) +
det[13][2] * (dp[2][0] - dp[2][1]) + mDet[13][2] * (mDP[2][0] - mDP[2][1]) +
det[13][3] * (dp[3][0] - dp[3][1]); mDet[13][3] * (mDP[3][0] - mDP[3][1]);
det[15][2] = det[11][0] * (dp[0][0] - dp[0][2]) + mDet[15][2] = mDet[11][0] * (mDP[0][0] - mDP[0][2]) +
det[11][1] * (dp[1][0] - dp[1][2]) + mDet[11][1] * (mDP[1][0] - mDP[1][2]) +
det[11][3] * (dp[3][0] - dp[3][2]); mDet[11][3] * (mDP[3][0] - mDP[3][2]);
det[15][3] = det[7][0] * (dp[0][0] - dp[0][3]) + mDet[15][3] = mDet[7][0] * (mDP[0][0] - mDP[0][3]) +
det[7][1] * (dp[1][0] - dp[1][3]) + mDet[7][1] * (mDP[1][0] - mDP[1][3]) +
det[7][2] * (dp[2][0] - dp[2][3]); mDet[7][2] * (mDP[2][0] - mDP[2][3]);
} }
} }
@ -120,8 +120,8 @@ inline void GjkCollisionState::compute_vector(S32 bits, VectorF& v)
v.set(0, 0, 0); v.set(0, 0, 0);
for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) { for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) {
if (bits & bit) { if (bits & bit) {
sum += det[bits][i]; sum += mDet[bits][i];
v += y[i] * det[bits][i]; v += mY[i] * mDet[bits][i];
} }
} }
v *= 1 / sum; v *= 1 / sum;
@ -133,13 +133,13 @@ inline void GjkCollisionState::compute_vector(S32 bits, VectorF& v)
inline bool GjkCollisionState::valid(S32 s) inline bool GjkCollisionState::valid(S32 s)
{ {
for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) { for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) {
if (all_bits & bit) { if (mAll_bits & bit) {
if (s & bit) { if (s & bit) {
if (det[s][i] <= 0) if (mDet[s][i] <= 0)
return false; return false;
} }
else else
if (det[s | bit][i] > 0) if (mDet[s | bit][i] > 0)
return false; return false;
} }
} }
@ -152,19 +152,19 @@ inline bool GjkCollisionState::valid(S32 s)
inline bool GjkCollisionState::closest(VectorF& v) inline bool GjkCollisionState::closest(VectorF& v)
{ {
compute_det(); compute_det();
for (S32 s = bits; s; --s) { for (S32 s = mBits; s; --s) {
if ((s & bits) == s) { if ((s & mBits) == s) {
if (valid(s | last_bit)) { if (valid(s | mLast_bit)) {
bits = s | last_bit; mBits = s | mLast_bit;
if (bits != 15) if (mBits != 15)
compute_vector(bits, v); compute_vector(mBits, v);
return true; return true;
} }
} }
} }
if (valid(last_bit)) { if (valid(mLast_bit)) {
bits = last_bit; mBits = mLast_bit;
v = y[last]; v = mY[mLast];
return true; return true;
} }
return false; return false;
@ -176,7 +176,7 @@ inline bool GjkCollisionState::closest(VectorF& v)
inline bool GjkCollisionState::degenerate(const VectorF& w) inline bool GjkCollisionState::degenerate(const VectorF& w)
{ {
for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1)
if ((all_bits & bit) && y[i] == w) if ((mAll_bits & bit) && mY[i] == w)
return true; return true;
return false; return false;
} }
@ -186,11 +186,11 @@ inline bool GjkCollisionState::degenerate(const VectorF& w)
inline void GjkCollisionState::nextBit() inline void GjkCollisionState::nextBit()
{ {
last = 0; mLast = 0;
last_bit = 1; mLast_bit = 1;
while (bits & last_bit) { while (mBits & mLast_bit) {
++last; ++mLast;
last_bit <<= 1; mLast_bit <<= 1;
} }
} }
@ -203,11 +203,11 @@ inline void GjkCollisionState::nextBit()
void GjkCollisionState::set(Convex* aa, Convex* bb, void GjkCollisionState::set(Convex* aa, Convex* bb,
const MatrixF& a2w, const MatrixF& b2w) const MatrixF& a2w, const MatrixF& b2w)
{ {
a = aa; mA = aa;
b = bb; mB = bb;
bits = 0; mBits = 0;
all_bits = 0; mAll_bits = 0;
reset(a2w,b2w); reset(a2w,b2w);
// link // link
@ -223,10 +223,10 @@ void GjkCollisionState::set(Convex* aa, Convex* bb,
void GjkCollisionState::reset(const MatrixF& a2w, const MatrixF& b2w) void GjkCollisionState::reset(const MatrixF& a2w, const MatrixF& b2w)
{ {
VectorF zero(0,0,0),sa,sb; VectorF zero(0,0,0),sa,sb;
a2w.mulP(a->support(zero),&sa); a2w.mulP(mA->support(zero),&sa);
b2w.mulP(b->support(zero),&sb); b2w.mulP(mB->support(zero),&sb);
v = sa - sb; mDistvec = sa - sb;
dist = v.len(); mDist = mDistvec.len();
} }
@ -237,18 +237,18 @@ void GjkCollisionState::getCollisionInfo(const MatrixF& mat, Collision* info)
AssertFatal(false, "GjkCollisionState::getCollisionInfo() - There remain scaling problems here."); AssertFatal(false, "GjkCollisionState::getCollisionInfo() - There remain scaling problems here.");
// This assumes that the shapes do not intersect // This assumes that the shapes do not intersect
Point3F pa,pb; Point3F pa,pb;
if (bits) { if (mBits) {
getClosestPoints(pa,pb); getClosestPoints(pa,pb);
mat.mulP(pa,&info->point); mat.mulP(pa,&info->point);
b->getTransform().mulP(pb,&pa); mB->getTransform().mulP(pb,&pa);
info->normal = info->point - pa; info->normal = info->point - pa;
} }
else { else {
mat.mulP(p[last],&info->point); mat.mulP(mP[mLast],&info->point);
info->normal = v; info->normal = mDistvec;
} }
info->normal.normalize(); info->normal.normalize();
info->object = b->getObject(); info->object = mB->getObject();
} }
void GjkCollisionState::getClosestPoints(Point3F& p1, Point3F& p2) void GjkCollisionState::getClosestPoints(Point3F& p1, Point3F& p2)
@ -257,10 +257,10 @@ void GjkCollisionState::getClosestPoints(Point3F& p1, Point3F& p2)
p1.set(0, 0, 0); p1.set(0, 0, 0);
p2.set(0, 0, 0); p2.set(0, 0, 0);
for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) { for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) {
if (bits & bit) { if (mBits & bit) {
sum += det[bits][i]; sum += mDet[mBits][i];
p1 += p[i] * det[bits][i]; p1 += mP[i] * mDet[mBits][i];
p2 += q[i] * det[bits][i]; p2 += mQ[i] * mDet[mBits][i];
} }
} }
F32 s = 1 / sum; F32 s = 1 / sum;
@ -282,40 +282,40 @@ bool GjkCollisionState::intersect(const MatrixF& a2w, const MatrixF& b2w)
w2b.inverse(); w2b.inverse();
reset(a2w,b2w); reset(a2w,b2w);
bits = 0; mBits = 0;
all_bits = 0; mAll_bits = 0;
do { do {
nextBit(); nextBit();
VectorF va,sa; VectorF va,sa;
w2a.mulV(-v,&va); w2a.mulV(-mDistvec,&va);
p[last] = a->support(va); mP[mLast] = mA->support(va);
a2w.mulP(p[last],&sa); a2w.mulP(mP[mLast],&sa);
VectorF vb,sb; VectorF vb,sb;
w2b.mulV(v,&vb); w2b.mulV(mDistvec,&vb);
q[last] = b->support(vb); mQ[mLast] = mB->support(vb);
b2w.mulP(q[last],&sb); b2w.mulP(mQ[mLast],&sb);
VectorF w = sa - sb; VectorF w = sa - sb;
if (mDot(v,w) > 0) if (mDot(mDistvec,w) > 0)
return false; return false;
if (degenerate(w)) { if (degenerate(w)) {
++num_irregularities; ++num_irregularities;
return false; return false;
} }
y[last] = w; mY[mLast] = w;
all_bits = bits | last_bit; mAll_bits = mBits | mLast_bit;
++num_iterations; ++num_iterations;
if (!closest(v) || num_iterations > sIteration) { if (!closest(mDistvec) || num_iterations > sIteration) {
++num_irregularities; ++num_irregularities;
return false; return false;
} }
} }
while (bits < 15 && v.lenSquared() > sEpsilon2); while (mBits < 15 && mDistvec.lenSquared() > sEpsilon2);
return true; return true;
} }
@ -337,51 +337,51 @@ F32 GjkCollisionState::distance(const MatrixF& a2w, const MatrixF& b2w,
} }
reset(a2w,b2w); reset(a2w,b2w);
bits = 0; mBits = 0;
all_bits = 0; mAll_bits = 0;
F32 mu = 0; F32 mu = 0;
do { do {
nextBit(); nextBit();
VectorF va,sa; VectorF va,sa;
w2a.mulV(-v,&va); w2a.mulV(-mDistvec,&va);
p[last] = a->support(va); mP[mLast] = mA->support(va);
a2w.mulP(p[last],&sa); a2w.mulP(mP[mLast],&sa);
VectorF vb,sb; VectorF vb,sb;
w2b.mulV(v,&vb); w2b.mulV(mDistvec,&vb);
q[last] = b->support(vb); mQ[mLast] = mB->support(vb);
b2w.mulP(q[last],&sb); b2w.mulP(mQ[mLast],&sb);
VectorF w = sa - sb; VectorF w = sa - sb;
F32 nm = mDot(v, w) / dist; F32 nm = mDot(mDistvec, w) / mDist;
if (nm > mu) if (nm > mu)
mu = nm; mu = nm;
if (mu > dontCareDist) if (mu > dontCareDist)
return mu; return mu;
if (mFabs(dist - mu) <= dist * rel_error) if (mFabs(mDist - mu) <= mDist * rel_error)
return dist; return mDist;
++num_iterations; ++num_iterations;
if (degenerate(w) || num_iterations > sIteration) { if (degenerate(w) || num_iterations > sIteration) {
++num_irregularities; ++num_irregularities;
return dist; return mDist;
} }
y[last] = w; mY[mLast] = w;
all_bits = bits | last_bit; mAll_bits = mBits | mLast_bit;
if (!closest(v)) { if (!closest(mDistvec)) {
++num_irregularities; ++num_irregularities;
return dist; return mDist;
} }
dist = v.len(); mDist = mDistvec.len();
} }
while (bits < 15 && dist > sTolerance) ; while (mBits < 15 && mDist > sTolerance) ;
if (bits == 15 && mu <= 0) if (mBits == 15 && mu <= 0)
dist = 0; mDist = 0;
return dist; return mDist;
} }

18
Engine/source/collision/gjk.h
View file

@ -43,17 +43,17 @@ struct GjkCollisionState: public CollisionState
{ {
/// @name Temporary values /// @name Temporary values
/// @{ /// @{
Point3F p[4]; ///< support points of object A in local coordinates Point3F mP[4]; ///< support points of object A in local coordinates
Point3F q[4]; ///< support points of object B in local coordinates Point3F mQ[4]; ///< support points of object B in local coordinates
VectorF y[4]; ///< support points of A - B in world coordinates VectorF mY[4]; ///< support points of A - B in world coordinates
S32 bits; ///< identifies current simplex S32 mBits; ///< identifies current simplex
S32 all_bits; ///< all_bits = bits | last_bit S32 mAll_bits; ///< all_bits = bits | last_bit
F32 det[16][4]; ///< cached sub-determinants F32 mDet[16][4]; ///< cached sub-determinants
F32 dp[4][4]; ///< cached dot products F32 mDP[4][4]; ///< cached dot products
S32 last; ///< identifies last found support point S32 mLast; ///< identifies last found support point
S32 last_bit; ///< last_bit = 1<<last S32 mLast_bit; ///< last_bit = 1<<last
/// @} /// @}
/// ///