TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-20 23:23:47 +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();
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))
{

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

@ -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))
{

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
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);
}

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

@ -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();

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

@ -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;
}

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

@ -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<<last
S32 mLast; ///< identifies last found support point
S32 mLast_bit; ///< last_bit = 1<<last
/// @}
///