From 46bbb88d711049f6f3ede2b9076d5fe0d5e4bd6f Mon Sep 17 00:00:00 2001 From: Azaezel Date: Thu, 15 Mar 2018 17:31:28 -0500 Subject: [PATCH] CollisionState membervar clarification --- Engine/source/T3D/rigidShape.cpp | 6 +- Engine/source/T3D/vehicles/vehicle.cpp | 6 +- Engine/source/collision/convex.cpp | 18 +-- Engine/source/collision/convex.h | 8 +- Engine/source/collision/gjk.cpp | 204 ++++++++++++------------- Engine/source/collision/gjk.h | 18 +-- 6 files changed, 130 insertions(+), 130 deletions(-) diff --git a/Engine/source/T3D/rigidShape.cpp b/Engine/source/T3D/rigidShape.cpp index c7f876305..69144461f 100644 --- a/Engine/source/T3D/rigidShape.cpp +++ b/Engine/source/T3D/rigidShape.cpp @@ -1194,7 +1194,7 @@ bool RigidShape::updateCollision(F32 dt) mCollisionList.clear(); CollisionState *state = mConvex.findClosestState(cmat, getScale(), mDataBlock->collisionTol); - if (state && state->dist <= mDataBlock->collisionTol) + if (state && state->mDist <= mDataBlock->collisionTol) { //resolveDisplacement(ns,state,dt); 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) { - SceneObject* obj = (state->a->getObject() == this)? - state->b->getObject(): state->a->getObject(); + SceneObject* obj = (state->mA->getObject() == this)? + state->mB->getObject(): state->mA->getObject(); if (obj->isDisplacable() && ((obj->getTypeMask() & ShapeBaseObjectType) != 0)) { diff --git a/Engine/source/T3D/vehicles/vehicle.cpp b/Engine/source/T3D/vehicles/vehicle.cpp index cdfff2827..a173d61fd 100644 --- a/Engine/source/T3D/vehicles/vehicle.cpp +++ b/Engine/source/T3D/vehicles/vehicle.cpp @@ -1364,7 +1364,7 @@ bool Vehicle::updateCollision(F32 dt) mCollisionList.clear(); CollisionState *state = mConvex.findClosestState(cmat, getScale(), mDataBlock->collisionTol); - if (state && state->dist <= mDataBlock->collisionTol) + if (state && state->mDist <= mDataBlock->collisionTol) { //resolveDisplacement(ns,state,dt); mConvex.getCollisionInfo(cmat, getScale(), &mCollisionList, mDataBlock->collisionTol); @@ -1497,8 +1497,8 @@ bool Vehicle::resolveDisplacement(Rigid& ns,CollisionState *state, F32 dt) { PROFILE_SCOPE( Vehicle_ResolveDisplacement ); - SceneObject* obj = (state->a->getObject() == this)? - state->b->getObject(): state->a->getObject(); + SceneObject* obj = (state->mA->getObject() == this)? + state->mB->getObject(): state->mA->getObject(); if (obj->isDisplacable() && ((obj->getTypeMask() & ShapeBaseObjectType) != 0)) { diff --git a/Engine/source/collision/convex.cpp b/Engine/source/collision/convex.cpp index 0fda42812..01583c9f0 100644 --- a/Engine/source/collision/convex.cpp +++ b/Engine/source/collision/convex.cpp @@ -520,7 +520,7 @@ void Convex::updateStateList(const MatrixF& mat, const Point3F& scale, const Poi // Destroy states which are no longer intersecting 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; if (!box1.isOverlapped(cv->getBoundingBox())) { CollisionState* cs = itr->mState; @@ -568,9 +568,9 @@ CollisionState* Convex::findClosestState(const MatrixF& mat, const Point3F& scal state->swap(); // Prepare scaled version of transform - MatrixF bxform = state->b->getTransform(); + MatrixF bxform = state->mB->getTransform(); temp = bxform; - Point3F bscale = state->b->getScale(); + Point3F bscale = state->mB->getScale(); bxform.scale(bscale); MatrixF bxforminv(true); 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) state->swap(); - if (state->dist <= tol) + if (state->mDist <= tol) { fa.reset(); fb.reset(); @@ -628,18 +628,18 @@ bool Convex::getCollisionInfo(const MatrixF& mat, const Point3F& scale, Collisio MatrixF imat = omat; imat.inverse(); - imat.mulV(-state->v,&v); + imat.mulV(-state->mDistvec,&v); getFeatures(omat,v,&fa); - imat = state->b->getTransform(); - imat.scale(state->b->getScale()); + imat = state->mB->getTransform(); + imat.scale(state->mB->getScale()); MatrixF bxform = imat; 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); } diff --git a/Engine/source/collision/convex.h b/Engine/source/collision/convex.h index 5de048abc..fa6106f83 100644 --- a/Engine/source/collision/convex.h +++ b/Engine/source/collision/convex.h @@ -100,11 +100,11 @@ struct CollisionState { CollisionStateList* mLista; CollisionStateList* mListb; - Convex* a; - Convex* b; + Convex* mA; + Convex* mB; - F32 dist; // Current estimated distance - VectorF v; // Vector between closest points + F32 mDist; // Current estimated distance + VectorF mDistvec; // Vector between closest points // CollisionState(); diff --git a/Engine/source/collision/gjk.cpp b/Engine/source/collision/gjk.cpp index 5dff5ec92..e9debee81 100644 --- a/Engine/source/collision/gjk.cpp +++ b/Engine/source/collision/gjk.cpp @@ -46,7 +46,7 @@ S32 num_irregularities = 0; GjkCollisionState::GjkCollisionState() { - a = b = 0; + mA = mB = 0; } GjkCollisionState::~GjkCollisionState() @@ -58,9 +58,9 @@ GjkCollisionState::~GjkCollisionState() void GjkCollisionState::swap() { - Convex* t = a; a = b; b = t; + Convex* t = mA; mA = mB; mB = t; 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 for (S32 i = 0, bit = 1; i < 4; ++i, bit <<=1) - if (bits & bit) - dp[i][last] = dp[last][i] = mDot(y[i], y[last]); - dp[last][last] = mDot(y[last], y[last]); + if (mBits & bit) + mDP[i][mLast] = mDP[mLast][i] = mDot(mY[i], mY[mLast]); + mDP[mLast][mLast] = mDot(mY[mLast], mY[mLast]); // Calulate the determinent - det[last_bit][last] = 1; + mDet[mLast_bit][mLast] = 1; for (S32 j = 0, sj = 1; j < 4; ++j, sj <<= 1) { - if (bits & sj) { - S32 s2 = sj | last_bit; - det[s2][j] = dp[last][last] - dp[last][j]; - det[s2][last] = dp[j][j] - dp[j][last]; + if (mBits & sj) { + S32 s2 = sj | mLast_bit; + mDet[s2][j] = mDP[mLast][mLast] - mDP[mLast][j]; + mDet[s2][mLast] = mDP[j][j] - mDP[j][mLast]; for (S32 k = 0, sk = 1; k < j; ++k, sk <<= 1) { - if (bits & sk) { + if (mBits & sk) { S32 s3 = sk | s2; - det[s3][k] = det[s2][j] * (dp[j][j] - dp[j][k]) + - det[s2][last] * (dp[last][j] - dp[last][k]); - det[s3][j] = det[sk | last_bit][k] * (dp[k][k] - dp[k][j]) + - det[sk | last_bit][last] * (dp[last][k] - dp[last][j]); - det[s3][last] = det[sk | sj][k] * (dp[k][k] - dp[k][last]) + - det[sk | sj][j] * (dp[j][k] - dp[j][last]); + mDet[s3][k] = mDet[s2][j] * (mDP[j][j] - mDP[j][k]) + + mDet[s2][mLast] * (mDP[mLast][j] - mDP[mLast][k]); + mDet[s3][j] = mDet[sk | mLast_bit][k] * (mDP[k][k] - mDP[k][j]) + + mDet[sk | mLast_bit][mLast] * (mDP[mLast][k] - mDP[mLast][j]); + mDet[s3][mLast] = mDet[sk | sj][k] * (mDP[k][k] - mDP[k][mLast]) + + mDet[sk | sj][j] * (mDP[j][k] - mDP[j][mLast]); } } } } - if (all_bits == 15) { - det[15][0] = det[14][1] * (dp[1][1] - dp[1][0]) + - det[14][2] * (dp[2][1] - dp[2][0]) + - det[14][3] * (dp[3][1] - dp[3][0]); - det[15][1] = det[13][0] * (dp[0][0] - dp[0][1]) + - det[13][2] * (dp[2][0] - dp[2][1]) + - det[13][3] * (dp[3][0] - dp[3][1]); - det[15][2] = det[11][0] * (dp[0][0] - dp[0][2]) + - det[11][1] * (dp[1][0] - dp[1][2]) + - det[11][3] * (dp[3][0] - dp[3][2]); - det[15][3] = det[7][0] * (dp[0][0] - dp[0][3]) + - det[7][1] * (dp[1][0] - dp[1][3]) + - det[7][2] * (dp[2][0] - dp[2][3]); + if (mAll_bits == 15) { + mDet[15][0] = mDet[14][1] * (mDP[1][1] - mDP[1][0]) + + mDet[14][2] * (mDP[2][1] - mDP[2][0]) + + mDet[14][3] * (mDP[3][1] - mDP[3][0]); + mDet[15][1] = mDet[13][0] * (mDP[0][0] - mDP[0][1]) + + mDet[13][2] * (mDP[2][0] - mDP[2][1]) + + mDet[13][3] * (mDP[3][0] - mDP[3][1]); + mDet[15][2] = mDet[11][0] * (mDP[0][0] - mDP[0][2]) + + mDet[11][1] * (mDP[1][0] - mDP[1][2]) + + mDet[11][3] * (mDP[3][0] - mDP[3][2]); + mDet[15][3] = mDet[7][0] * (mDP[0][0] - mDP[0][3]) + + mDet[7][1] * (mDP[1][0] - mDP[1][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); for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) { if (bits & bit) { - sum += det[bits][i]; - v += y[i] * det[bits][i]; + sum += mDet[bits][i]; + v += mY[i] * mDet[bits][i]; } } v *= 1 / sum; @@ -133,13 +133,13 @@ inline void GjkCollisionState::compute_vector(S32 bits, VectorF& v) inline bool GjkCollisionState::valid(S32 s) { for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) { - if (all_bits & bit) { + if (mAll_bits & bit) { if (s & bit) { - if (det[s][i] <= 0) + if (mDet[s][i] <= 0) return false; } else - if (det[s | bit][i] > 0) + if (mDet[s | bit][i] > 0) return false; } } @@ -152,19 +152,19 @@ inline bool GjkCollisionState::valid(S32 s) inline bool GjkCollisionState::closest(VectorF& v) { compute_det(); - for (S32 s = bits; s; --s) { - if ((s & bits) == s) { - if (valid(s | last_bit)) { - bits = s | last_bit; - if (bits != 15) - compute_vector(bits, v); + for (S32 s = mBits; s; --s) { + if ((s & mBits) == s) { + if (valid(s | mLast_bit)) { + mBits = s | mLast_bit; + if (mBits != 15) + compute_vector(mBits, v); return true; } } } - if (valid(last_bit)) { - bits = last_bit; - v = y[last]; + if (valid(mLast_bit)) { + mBits = mLast_bit; + v = mY[mLast]; return true; } return false; @@ -176,7 +176,7 @@ inline bool GjkCollisionState::closest(VectorF& v) inline bool GjkCollisionState::degenerate(const VectorF& w) { 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 false; } @@ -186,11 +186,11 @@ inline bool GjkCollisionState::degenerate(const VectorF& w) inline void GjkCollisionState::nextBit() { - last = 0; - last_bit = 1; - while (bits & last_bit) { - ++last; - last_bit <<= 1; + mLast = 0; + mLast_bit = 1; + while (mBits & mLast_bit) { + ++mLast; + mLast_bit <<= 1; } } @@ -203,11 +203,11 @@ inline void GjkCollisionState::nextBit() void GjkCollisionState::set(Convex* aa, Convex* bb, const MatrixF& a2w, const MatrixF& b2w) { - a = aa; - b = bb; + mA = aa; + mB = bb; - bits = 0; - all_bits = 0; + mBits = 0; + mAll_bits = 0; reset(a2w,b2w); // link @@ -223,10 +223,10 @@ void GjkCollisionState::set(Convex* aa, Convex* bb, void GjkCollisionState::reset(const MatrixF& a2w, const MatrixF& b2w) { VectorF zero(0,0,0),sa,sb; - a2w.mulP(a->support(zero),&sa); - b2w.mulP(b->support(zero),&sb); - v = sa - sb; - dist = v.len(); + a2w.mulP(mA->support(zero),&sa); + b2w.mulP(mB->support(zero),&sb); + mDistvec = sa - sb; + mDist = mDistvec.len(); } @@ -237,18 +237,18 @@ void GjkCollisionState::getCollisionInfo(const MatrixF& mat, Collision* info) AssertFatal(false, "GjkCollisionState::getCollisionInfo() - There remain scaling problems here."); // This assumes that the shapes do not intersect Point3F pa,pb; - if (bits) { + if (mBits) { getClosestPoints(pa,pb); mat.mulP(pa,&info->point); - b->getTransform().mulP(pb,&pa); + mB->getTransform().mulP(pb,&pa); info->normal = info->point - pa; } else { - mat.mulP(p[last],&info->point); - info->normal = v; + mat.mulP(mP[mLast],&info->point); + info->normal = mDistvec; } info->normal.normalize(); - info->object = b->getObject(); + info->object = mB->getObject(); } void GjkCollisionState::getClosestPoints(Point3F& p1, Point3F& p2) @@ -257,10 +257,10 @@ void GjkCollisionState::getClosestPoints(Point3F& p1, Point3F& p2) p1.set(0, 0, 0); p2.set(0, 0, 0); for (S32 i = 0, bit = 1; i < 4; ++i, bit <<= 1) { - if (bits & bit) { - sum += det[bits][i]; - p1 += p[i] * det[bits][i]; - p2 += q[i] * det[bits][i]; + if (mBits & bit) { + sum += mDet[mBits][i]; + p1 += mP[i] * mDet[mBits][i]; + p2 += mQ[i] * mDet[mBits][i]; } } F32 s = 1 / sum; @@ -282,40 +282,40 @@ bool GjkCollisionState::intersect(const MatrixF& a2w, const MatrixF& b2w) w2b.inverse(); reset(a2w,b2w); - bits = 0; - all_bits = 0; + mBits = 0; + mAll_bits = 0; do { nextBit(); VectorF va,sa; - w2a.mulV(-v,&va); - p[last] = a->support(va); - a2w.mulP(p[last],&sa); + w2a.mulV(-mDistvec,&va); + mP[mLast] = mA->support(va); + a2w.mulP(mP[mLast],&sa); VectorF vb,sb; - w2b.mulV(v,&vb); - q[last] = b->support(vb); - b2w.mulP(q[last],&sb); + w2b.mulV(mDistvec,&vb); + mQ[mLast] = mB->support(vb); + b2w.mulP(mQ[mLast],&sb); VectorF w = sa - sb; - if (mDot(v,w) > 0) + if (mDot(mDistvec,w) > 0) return false; if (degenerate(w)) { ++num_irregularities; return false; } - y[last] = w; - all_bits = bits | last_bit; + mY[mLast] = w; + mAll_bits = mBits | mLast_bit; ++num_iterations; - if (!closest(v) || num_iterations > sIteration) { + if (!closest(mDistvec) || num_iterations > sIteration) { ++num_irregularities; return false; } } - while (bits < 15 && v.lenSquared() > sEpsilon2); + while (mBits < 15 && mDistvec.lenSquared() > sEpsilon2); return true; } @@ -337,51 +337,51 @@ F32 GjkCollisionState::distance(const MatrixF& a2w, const MatrixF& b2w, } reset(a2w,b2w); - bits = 0; - all_bits = 0; + mBits = 0; + mAll_bits = 0; F32 mu = 0; do { nextBit(); VectorF va,sa; - w2a.mulV(-v,&va); - p[last] = a->support(va); - a2w.mulP(p[last],&sa); + w2a.mulV(-mDistvec,&va); + mP[mLast] = mA->support(va); + a2w.mulP(mP[mLast],&sa); VectorF vb,sb; - w2b.mulV(v,&vb); - q[last] = b->support(vb); - b2w.mulP(q[last],&sb); + w2b.mulV(mDistvec,&vb); + mQ[mLast] = mB->support(vb); + b2w.mulP(mQ[mLast],&sb); VectorF w = sa - sb; - F32 nm = mDot(v, w) / dist; + F32 nm = mDot(mDistvec, w) / mDist; if (nm > mu) mu = nm; if (mu > dontCareDist) return mu; - if (mFabs(dist - mu) <= dist * rel_error) - return dist; + if (mFabs(mDist - mu) <= mDist * rel_error) + return mDist; ++num_iterations; if (degenerate(w) || num_iterations > sIteration) { ++num_irregularities; - return dist; + return mDist; } - y[last] = w; - all_bits = bits | last_bit; + mY[mLast] = w; + mAll_bits = mBits | mLast_bit; - if (!closest(v)) { + if (!closest(mDistvec)) { ++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) - dist = 0; - return dist; + if (mBits == 15 && mu <= 0) + mDist = 0; + return mDist; } diff --git a/Engine/source/collision/gjk.h b/Engine/source/collision/gjk.h index b35f4570d..906007bb3 100644 --- a/Engine/source/collision/gjk.h +++ b/Engine/source/collision/gjk.h @@ -43,17 +43,17 @@ struct GjkCollisionState: public CollisionState { /// @name Temporary values /// @{ - Point3F p[4]; ///< support points of object A in local coordinates - Point3F q[4]; ///< support points of object B in local coordinates - VectorF y[4]; ///< support points of A - B in world coordinates + Point3F mP[4]; ///< support points of object A in local coordinates + Point3F mQ[4]; ///< support points of object B in local coordinates + VectorF mY[4]; ///< support points of A - B in world coordinates - S32 bits; ///< identifies current simplex - S32 all_bits; ///< all_bits = bits | last_bit - F32 det[16][4]; ///< cached sub-determinants - F32 dp[4][4]; ///< cached dot products + S32 mBits; ///< identifies current simplex + S32 mAll_bits; ///< all_bits = bits | last_bit + F32 mDet[16][4]; ///< cached sub-determinants + F32 mDP[4][4]; ///< cached dot products - S32 last; ///< identifies last found support point - S32 last_bit; ///< last_bit = 1<