From ec6cd72f3c42e261b2dc6b249e9c7a5b2e6dbb2c Mon Sep 17 00:00:00 2001 From: Dander7BD Date: Mon, 16 Dec 2013 13:33:33 +0100 Subject: [PATCH] SeperatingAxisTest_AxisAlignedVsTransformedBox overloaded --- Code/OysterPhysics3D/OysterCollision3D.cpp | 183 +++++++++++++++++++++ 1 file changed, 183 insertions(+) diff --git a/Code/OysterPhysics3D/OysterCollision3D.cpp b/Code/OysterPhysics3D/OysterCollision3D.cpp index 25a8948b..1dcd24ab 100644 --- a/Code/OysterPhysics3D/OysterCollision3D.cpp +++ b/Code/OysterPhysics3D/OysterCollision3D.cpp @@ -203,6 +203,188 @@ namespace Oyster { namespace Collision3D { namespace Utility return true; } + + bool SeperatingAxisTest_AxisAlignedVsTransformedBox( const Float3 &boundingOffsetA, const Float3 &boundingOffsetB, const Float4x4 &rotationB, const Float3 &worldOffset, Float3 &worldPointOfContact ) + { // by Dan Andersson + + /***************************************************************** + * Uses the Seperating Axis Theorem + * if( |t dot s| > hA dot |s * RA| + hB dot |s * RB| ) then not intersecting + * |t dot s| > hA dot |s| + hB dot |s * RB| .. as RA = I + * + * t: objectB's offset from objectA [worldOffset] + * s: current comparison axis + * hA: boundingReach vector of objectA. Only absolute values is assumed. [boundingOffsetA] + * hB: boundingReach vector of objectB. Only absolute values is assumed. [boundingOffsetB] + * RA: rotation matrix of objectA. Is identity matrix here, thus omitted. + * RB: rotation matrix of objectB. Is transformed into objectA's view at this point. [rotationB] + * + * Note: s * RB = (RB^T * s)^T = (RB^-1 * s)^T .... vector == vector^T + *****************************************************************/ + + /***************************************************************** + * Distance Alghorithm based on .. something Dan came up with + * pi = si * ( |t dot si| * (hA dot |si|) / (hA dot |si| + hB dot |si * RB|) ) + * p = point of contact + * = ( p1 + p2 + ... + p13 + p14 ) / 5 + *****************************************************************/ + + Float4 t = Float4( worldOffset, 0.0f ), + s = Float4::standard_unit_x, + hA = Float4( boundingOffsetA, 0.0f ), + hB = Float4( boundingOffsetB, 0.0f ); + Float centerSeperation = Abs( t.Dot(s) ), + eA = hA.Dot( Abs(s) ), + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + Float4 sumPoints = s * ( centerSeperation * eA / edgeSeperation ); + + s = Float4::standard_unit_y; + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s * ( centerSeperation * eA / edgeSeperation ); + + s = Float4::standard_unit_z; + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s * ( centerSeperation * eA / edgeSeperation ); + + s = rotationB.v[0]; + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s * ( centerSeperation * eA / edgeSeperation ); + + s = rotationB.v[1]; + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s * ( centerSeperation * eA / edgeSeperation ); + + s = rotationB.v[2]; + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_x.Cross(rotationB.v[0].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_x.Cross(rotationB.v[1].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_x.Cross(rotationB.v[2].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_y.Cross(rotationB.v[0].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_y.Cross(rotationB.v[1].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_y.Cross(rotationB.v[2].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_z.Cross(rotationB.v[0].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_z.Cross(rotationB.v[1].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + s = Float4( Float3::standard_unit_z.Cross(rotationB.v[2].xyz), 0.0f ); + centerSeperation = Abs( t.Dot(s) ); + eA = hA.Dot( Abs(s) ); + edgeSeperation = eA + hB.Dot( Abs(s * rotationB) ); + if( centerSeperation > edgeSeperation ) + { // no intersection + return false; + } + sumPoints += s.GetNormalized() * ( centerSeperation * eA / edgeSeperation ); + + worldPointOfContact = ((1.0f/5.0f) * sumPoints).xyz; + return true; + } } // PUBLIC BODY ////////////////////////////////////////////////////// @@ -293,6 +475,7 @@ namespace Oyster { namespace Collision3D { namespace Utility bool Intersect( const Ray &rayA, const Ray &rayB, ::Oyster::Math::Float &connectDistanceA, ::Oyster::Math::Float &connectDistanceB, ::Oyster::Math::Float3& worldPointOfContact ) { + //! @todo TODO: implement Stub return false; }