public override void SupportMapping(ref TSVector direction, out TSVector result) { TSVector tSVector; TSVector.Normalize(ref direction, out tSVector); TSVector.Multiply(ref tSVector, this.sphericalExpansion, out tSVector); int num = 0; FP y = TSVector.Dot(ref this.points[0], ref direction); FP fP = TSVector.Dot(ref this.points[1], ref direction); bool flag = fP > y; if (flag) { y = fP; num = 1; } fP = TSVector.Dot(ref this.points[2], ref direction); bool flag2 = fP > y; if (flag2) { num = 2; } TSVector.Add(ref this.points[num], ref tSVector, out result); }
/// <summary> /// Normalizes the given vector. /// </summary> /// <param name="value">The vector which should be normalized.</param> /// <returns>A normalized vector.</returns> #region public static JVector Normalize(JVector value) public static TSVector Normalize(TSVector value) { TSVector result; TSVector.Normalize(ref value, out result); return(result); }
public override void SupportMapping(ref TSVector direction, out TSVector result) { FP fP = FP.Sqrt(direction.x * direction.x + direction.z * direction.z); bool flag = FP.Abs(direction.y) > FP.Zero; if (flag) { TSVector tSVector; TSVector.Normalize(ref direction, out tSVector); TSVector.Multiply(ref tSVector, this.radius, out result); result.y += FP.Sign(direction.y) * FP.Half * this.length; } else { bool flag2 = fP > FP.Zero; if (flag2) { result.x = direction.x / fP * this.radius; result.y = FP.Zero; result.z = direction.z / fP * this.radius; } else { result.x = FP.Zero; result.y = FP.Zero; result.z = FP.Zero; } } }
public override void PrepareForIteration(FP timestep) { TSVector.Transform(ref this.localAnchor1, ref this.body1.orientation, out this.r1); TSVector.Transform(ref this.localAnchor2, ref this.body2.orientation, out this.r2); TSVector value; TSVector.Add(ref this.body1.position, ref this.r1, out value); TSVector value2; TSVector.Add(ref this.body2.position, ref this.r2, out value2); TSVector tSVector; TSVector.Subtract(ref value2, ref value, out tSVector); FP x = tSVector.magnitude - this.distance; bool flag = this.behavior == PointPointDistance.DistanceBehavior.LimitMaximumDistance && x <= FP.Zero; if (flag) { this.skipConstraint = true; } else { bool flag2 = this.behavior == PointPointDistance.DistanceBehavior.LimitMinimumDistance && x >= FP.Zero; if (flag2) { this.skipConstraint = true; } else { this.skipConstraint = false; TSVector value3 = value2 - value; bool flag3 = value3.sqrMagnitude != FP.Zero; if (flag3) { value3.Normalize(); } this.jacobian[0] = -FP.One * value3; this.jacobian[1] = -FP.One * (this.r1 % value3); this.jacobian[2] = FP.One * value3; this.jacobian[3] = this.r2 % value3; this.effectiveMass = this.body1.inverseMass + this.body2.inverseMass + TSVector.Transform(this.jacobian[1], this.body1.invInertiaWorld) * this.jacobian[1] + TSVector.Transform(this.jacobian[3], this.body2.invInertiaWorld) * this.jacobian[3]; this.softnessOverDt = this.softness / timestep; this.effectiveMass += this.softnessOverDt; this.effectiveMass = FP.One / this.effectiveMass; this.bias = x * this.biasFactor * (FP.One / timestep); bool flag4 = !this.body1.isStatic; if (flag4) { this.body1.linearVelocity += this.body1.inverseMass * this.accumulatedImpulse * this.jacobian[0]; this.body1.angularVelocity += TSVector.Transform(this.accumulatedImpulse * this.jacobian[1], this.body1.invInertiaWorld); } bool flag5 = !this.body2.isStatic; if (flag5) { this.body2.linearVelocity += this.body2.inverseMass * this.accumulatedImpulse * this.jacobian[2]; this.body2.angularVelocity += TSVector.Transform(this.accumulatedImpulse * this.jacobian[3], this.body2.invInertiaWorld); } } } }
public void SupportMapping(ref TSVector direction, out TSVector result) { FP y = TSVector.Dot(ref this.owner.points[this.indices.I0].position, ref direction); FP fP = TSVector.Dot(ref this.owner.points[this.indices.I1].position, ref direction); TSVector position = this.owner.points[this.indices.I0].position; bool flag = fP > y; if (flag) { y = fP; position = this.owner.points[this.indices.I1].position; } fP = TSVector.Dot(ref this.owner.points[this.indices.I2].position, ref direction); bool flag2 = fP > y; if (flag2) { position = this.owner.points[this.indices.I2].position; } TSVector tSVector; TSVector.Normalize(ref direction, out tSVector); tSVector *= this.owner.triangleExpansion; result = position + tSVector; }
public override void SupportMapping(ref TSVector direction, out TSVector result) { TSVector tSVector; TSVector.Normalize(ref direction, out tSVector); tSVector *= this.sphericalExpansion; FP y = TSVector.Dot(ref this.vecs[0], ref direction); int num = 0; FP fP = TSVector.Dot(ref this.vecs[1], ref direction); bool flag = fP > y; if (flag) { y = fP; num = 1; } fP = TSVector.Dot(ref this.vecs[2], ref direction); bool flag2 = fP > y; if (flag2) { num = 2; } result = this.vecs[num] + tSVector; }
public PointOnLine(RigidBody body1, RigidBody body2, TSVector lineStartPointBody1, TSVector pointBody2) : base(body1, body2) { TSVector.Subtract(ref lineStartPointBody1, ref body1.position, out this.localAnchor1); TSVector.Subtract(ref pointBody2, ref body2.position, out this.localAnchor2); TSVector.Transform(ref this.localAnchor1, ref body1.invOrientation, out this.localAnchor1); TSVector.Transform(ref this.localAnchor2, ref body2.invOrientation, out this.localAnchor2); this.lineNormal = TSVector.Normalize(lineStartPointBody1 - pointBody2); }
public override int Prepare(ref TSVector rayOrigin, ref TSVector rayDelta) { this.potentialTriangles.Clear(); TSVector tSVector; TSVector.Normalize(ref rayDelta, out tSVector); tSVector = rayDelta + tSVector * this.sphericalExpansion; this.octree.GetTrianglesIntersectingRay(this.potentialTriangles, rayOrigin, tSVector); return(this.potentialTriangles.Count); }
public override int Prepare(ref TSVector rayOrigin, ref TSVector rayDelta) { TSBBox smallBox = TSBBox.SmallBox; TSVector value; TSVector.Normalize(ref rayDelta, out value); value = rayOrigin + rayDelta + value * this.sphericalExpansion; smallBox.AddPoint(ref rayOrigin); smallBox.AddPoint(ref value); return(this.Prepare(ref smallBox)); }
public override void PrepareForIteration(FP timestep) { TSVector.Transform(ref this.localAnchor1, ref this.body1.orientation, out this.r1); TSVector.Transform(ref this.localAnchor2, ref this.body2.orientation, out this.r2); TSVector tSVector; TSVector.Add(ref this.body1.position, ref this.r1, out tSVector); TSVector tSVector2; TSVector.Add(ref this.body2.position, ref this.r2, out tSVector2); TSVector tSVector3; TSVector.Subtract(ref tSVector2, ref tSVector, out tSVector3); TSVector tSVector4 = TSVector.Transform(this.lineNormal, this.body1.orientation); tSVector4.Normalize(); TSVector tSVector5 = (tSVector - tSVector2) % tSVector4; bool flag = tSVector5.sqrMagnitude != FP.Zero; if (flag) { tSVector5.Normalize(); } tSVector5 %= tSVector4; this.jacobian[0] = tSVector5; this.jacobian[1] = (this.r1 + tSVector2 - tSVector) % tSVector5; this.jacobian[2] = -FP.One * tSVector5; this.jacobian[3] = -FP.One * this.r2 % tSVector5; this.effectiveMass = this.body1.inverseMass + this.body2.inverseMass + TSVector.Transform(this.jacobian[1], this.body1.invInertiaWorld) * this.jacobian[1] + TSVector.Transform(this.jacobian[3], this.body2.invInertiaWorld) * this.jacobian[3]; this.softnessOverDt = this.softness / timestep; this.effectiveMass += this.softnessOverDt; bool flag2 = this.effectiveMass != 0; if (flag2) { this.effectiveMass = FP.One / this.effectiveMass; } this.bias = -(tSVector4 % (tSVector2 - tSVector)).magnitude * this.biasFactor * (FP.One / timestep); bool flag3 = !this.body1.isStatic; if (flag3) { this.body1.linearVelocity += this.body1.inverseMass * this.accumulatedImpulse * this.jacobian[0]; this.body1.angularVelocity += TSVector.Transform(this.accumulatedImpulse * this.jacobian[1], this.body1.invInertiaWorld); } bool flag4 = !this.body2.isStatic; if (flag4) { this.body2.linearVelocity += this.body2.inverseMass * this.accumulatedImpulse * this.jacobian[2]; this.body2.angularVelocity += TSVector.Transform(this.accumulatedImpulse * this.jacobian[3], this.body2.invInertiaWorld); } }
public static bool ClosestPoints(ISupportMappable support1, ISupportMappable support2, ref TSMatrix orientation1, ref TSMatrix orientation2, ref TSVector position1, ref TSVector position2, out TSVector p1, out TSVector p2, out TSVector normal) { VoronoiSimplexSolver @new = GJKCollide.simplexSolverPool.GetNew(); @new.Reset(); p1 = (p2 = TSVector.zero); TSVector value = position1 - position2; TSVector tSVector = TSVector.Negate(value); TSVector tSVector2; GJKCollide.SupportMapTransformed(support1, ref orientation1, ref position1, ref tSVector, out tSVector2); TSVector tSVector3; GJKCollide.SupportMapTransformed(support2, ref orientation2, ref position2, ref value, out tSVector3); TSVector tSVector4 = tSVector2 - tSVector3; normal = TSVector.zero; int num = 15; FP x = tSVector4.sqrMagnitude; FP eN = FP.EN5; while (x > eN && num-- != 0) { TSVector tSVector5 = TSVector.Negate(tSVector4); GJKCollide.SupportMapTransformed(support1, ref orientation1, ref position1, ref tSVector5, out tSVector2); GJKCollide.SupportMapTransformed(support2, ref orientation2, ref position2, ref tSVector4, out tSVector3); TSVector w = tSVector2 - tSVector3; bool flag = [email protected](w); if (flag) { @new.AddVertex(w, tSVector2, tSVector3); } bool flag2 = @new.Closest(out tSVector4); if (flag2) { x = tSVector4.sqrMagnitude; normal = tSVector4; } else { x = FP.Zero; } } @new.ComputePoints(out p1, out p2); bool flag3 = normal.sqrMagnitude > TSMath.Epsilon * TSMath.Epsilon; if (flag3) { normal.Normalize(); } GJKCollide.simplexSolverPool.GiveBack(@new); return(true); }
public static TSQuaternion AngleAxis(FP angle, TSVector axis) { axis *= FP.Deg2Rad; axis.Normalize(); FP fP = angle * FP.Deg2Rad * FP.Half; FP fP2 = FP.Sin(fP); TSQuaternion result; result.x = axis.x * fP2; result.y = axis.y * fP2; result.z = axis.z * fP2; result.w = FP.Cos(fP); return(result); }
public override void PrepareForIteration(FP timestep) { TSVector tSVector; TSVector.Subtract(ref this.body2.position, ref this.body1.position, out tSVector); FP x = tSVector.magnitude - this.distance; bool flag = this.behavior == SoftBody.Spring.DistanceBehavior.LimitMaximumDistance && x <= FP.Zero; if (flag) { this.skipConstraint = true; } else { bool flag2 = this.behavior == SoftBody.Spring.DistanceBehavior.LimitMinimumDistance && x >= FP.Zero; if (flag2) { this.skipConstraint = true; } else { this.skipConstraint = false; TSVector value = tSVector; bool flag3 = value.sqrMagnitude != FP.Zero; if (flag3) { value.Normalize(); } this.jacobian[0] = -FP.One * value; this.jacobian[1] = FP.One * value; this.effectiveMass = this.body1.inverseMass + this.body2.inverseMass; this.softnessOverDt = this.softness / timestep; this.effectiveMass += this.softnessOverDt; this.effectiveMass = FP.One / this.effectiveMass; this.bias = x * this.biasFactor * (FP.One / timestep); bool flag4 = !this.body1.isStatic; if (flag4) { this.body1.linearVelocity += this.body1.inverseMass * this.accumulatedImpulse * this.jacobian[0]; } bool flag5 = !this.body2.isStatic; if (flag5) { this.body2.linearVelocity += this.body2.inverseMass * this.accumulatedImpulse * this.jacobian[1]; } } } }
public static TSQuaternion AngleAxis(FP angle, TSVector axis) { axis = axis * FP.Deg2Rad; axis.Normalize(); FP halfAngle = angle * FP.Deg2Rad * FP.Half; TSQuaternion rotation; FP sin = FP.Sin(halfAngle); rotation.x = axis.x * sin; rotation.y = axis.y * sin; rotation.z = axis.z * sin; rotation.w = FP.Cos(halfAngle); return(rotation); }
public override void PrepareForIteration(FP timestep) { TSVector.Transform(ref this.localAnchor1, ref this.body1.orientation, out this.r1); TSVector.Transform(ref this.localAnchor2, ref this.body2.orientation, out this.r2); TSVector value; TSVector.Add(ref this.body1.position, ref this.r1, out value); TSVector value2; TSVector.Add(ref this.body2.position, ref this.r2, out value2); TSVector tSVector; TSVector.Subtract(ref value2, ref value, out tSVector); FP magnitude = tSVector.magnitude; TSVector value3 = value2 - value; bool flag = value3.sqrMagnitude != FP.Zero; if (flag) { value3.Normalize(); } this.jacobian[0] = -FP.One * value3; this.jacobian[1] = -FP.One * (this.r1 % value3); this.jacobian[2] = FP.One * value3; this.jacobian[3] = this.r2 % value3; this.effectiveMass = this.body1.inverseMass + this.body2.inverseMass + TSVector.Transform(this.jacobian[1], this.body1.invInertiaWorld) * this.jacobian[1] + TSVector.Transform(this.jacobian[3], this.body2.invInertiaWorld) * this.jacobian[3]; this.softnessOverDt = this.softness / timestep; this.effectiveMass += this.softnessOverDt; this.effectiveMass = FP.One / this.effectiveMass; this.bias = magnitude * this.biasFactor * (FP.One / timestep); bool flag2 = !this.body1.isStatic; if (flag2) { this.body1.linearVelocity += this.body1.inverseMass * this.accumulatedImpulse * this.jacobian[0]; this.body1.angularVelocity += TSVector.Transform(this.accumulatedImpulse * this.jacobian[1], this.body1.invInertiaWorld); } bool flag3 = !this.body2.isStatic; if (flag3) { this.body2.linearVelocity += this.body2.inverseMass * this.accumulatedImpulse * this.jacobian[2]; this.body2.angularVelocity += TSVector.Transform(this.accumulatedImpulse * this.jacobian[3], this.body2.invInertiaWorld); } }
public static void LookAt(out TSMatrix result, TSVector position, TSVector target) { TSVector tSVector = target - position; tSVector.Normalize(); TSVector tSVector2 = TSVector.Cross(TSVector.up, tSVector); tSVector2.Normalize(); TSVector tSVector3 = TSVector.Cross(tSVector, tSVector2); result.M11 = tSVector2.x; result.M21 = tSVector3.x; result.M31 = tSVector.x; result.M12 = tSVector2.y; result.M22 = tSVector3.y; result.M32 = tSVector.y; result.M13 = tSVector2.z; result.M23 = tSVector3.z; result.M33 = tSVector.z; }
public override void SupportMapping(ref TSVector direction, out TSVector result) { result = direction; result.Normalize(); TSVector.Multiply(ref result, this.radius, out result); }
public static bool Raycast(ISupportMappable support, ref TSMatrix orientation, ref TSMatrix invOrientation, ref TSVector position, ref TSVector origin, ref TSVector direction, out FP fraction, out TSVector normal) { VoronoiSimplexSolver @new = GJKCollide.simplexSolverPool.GetNew(); @new.Reset(); normal = TSVector.zero; fraction = FP.MaxValue; FP fP = FP.Zero; TSVector tSVector = direction; TSVector p = origin; TSVector tSVector2; GJKCollide.SupportMapTransformed(support, ref orientation, ref position, ref tSVector, out tSVector2); TSVector tSVector3; TSVector.Subtract(ref p, ref tSVector2, out tSVector3); int num = 15; FP x = tSVector3.sqrMagnitude; FP eN = FP.EN6; bool result; while (x > eN && num-- != 0) { TSVector q; GJKCollide.SupportMapTransformed(support, ref orientation, ref position, ref tSVector3, out q); TSVector w; TSVector.Subtract(ref p, ref q, out w); FP x2 = TSVector.Dot(ref tSVector3, ref w); bool flag = x2 > FP.Zero; if (flag) { FP fP2 = TSVector.Dot(ref tSVector3, ref tSVector); bool flag2 = fP2 >= -TSMath.Epsilon; if (flag2) { GJKCollide.simplexSolverPool.GiveBack(@new); result = false; return(result); } fP -= x2 / fP2; TSVector.Multiply(ref tSVector, fP, out p); TSVector.Add(ref origin, ref p, out p); TSVector.Subtract(ref p, ref q, out w); normal = tSVector3; } bool flag3 = [email protected](w); if (flag3) { @new.AddVertex(w, p, q); } bool flag4 = @new.Closest(out tSVector3); if (flag4) { x = tSVector3.sqrMagnitude; } else { x = FP.Zero; } } TSVector tSVector4; TSVector value; @new.ComputePoints(out tSVector4, out value); value -= origin; fraction = value.magnitude / direction.magnitude; bool flag5 = normal.sqrMagnitude > TSMath.Epsilon * TSMath.Epsilon; if (flag5) { normal.Normalize(); } GJKCollide.simplexSolverPool.GiveBack(@new); result = true; return(result); }
public virtual void MakeHull(ref List <TSVector> triangleList, int generationThreshold) { FP zero = FP.Zero; bool flag = generationThreshold < 0; if (flag) { generationThreshold = 4; } Stack <Shape.ClipTriangle> stack = new Stack <Shape.ClipTriangle>(); TSVector[] array = new TSVector[] { new TSVector(-1, 0, 0), new TSVector(1, 0, 0), new TSVector(0, -1, 0), new TSVector(0, 1, 0), new TSVector(0, 0, -1), new TSVector(0, 0, 1) }; int[,] array2 = new int[, ] { { 5, 1, 3 }, { 4, 3, 1 }, { 3, 4, 0 }, { 0, 5, 3 }, { 5, 2, 1 }, { 4, 1, 2 }, { 2, 0, 4 }, { 0, 2, 5 } }; for (int i = 0; i < 8; i++) { stack.Push(new Shape.ClipTriangle { n1 = array[array2[i, 0]], n2 = array[array2[i, 1]], n3 = array[array2[i, 2]], generation = 0 }); } while (stack.Count > 0) { Shape.ClipTriangle clipTriangle = stack.Pop(); TSVector tSVector; this.SupportMapping(ref clipTriangle.n1, out tSVector); TSVector tSVector2; this.SupportMapping(ref clipTriangle.n2, out tSVector2); TSVector tSVector3; this.SupportMapping(ref clipTriangle.n3, out tSVector3); FP sqrMagnitude = (tSVector2 - tSVector).sqrMagnitude; FP sqrMagnitude2 = (tSVector3 - tSVector2).sqrMagnitude; FP sqrMagnitude3 = (tSVector - tSVector3).sqrMagnitude; bool flag2 = TSMath.Max(TSMath.Max(sqrMagnitude, sqrMagnitude2), sqrMagnitude3) > zero && clipTriangle.generation < generationThreshold; if (flag2) { Shape.ClipTriangle item = default(Shape.ClipTriangle); Shape.ClipTriangle item2 = default(Shape.ClipTriangle); Shape.ClipTriangle item3 = default(Shape.ClipTriangle); Shape.ClipTriangle item4 = default(Shape.ClipTriangle); item.generation = clipTriangle.generation + 1; item2.generation = clipTriangle.generation + 1; item3.generation = clipTriangle.generation + 1; item4.generation = clipTriangle.generation + 1; item.n1 = clipTriangle.n1; item2.n2 = clipTriangle.n2; item3.n3 = clipTriangle.n3; TSVector tSVector4 = FP.Half * (clipTriangle.n1 + clipTriangle.n2); tSVector4.Normalize(); item.n2 = tSVector4; item2.n1 = tSVector4; item4.n3 = tSVector4; tSVector4 = FP.Half * (clipTriangle.n2 + clipTriangle.n3); tSVector4.Normalize(); item2.n3 = tSVector4; item3.n2 = tSVector4; item4.n1 = tSVector4; tSVector4 = FP.Half * (clipTriangle.n3 + clipTriangle.n1); tSVector4.Normalize(); item.n3 = tSVector4; item3.n1 = tSVector4; item4.n2 = tSVector4; stack.Push(item); stack.Push(item2); stack.Push(item3); stack.Push(item4); } else { bool flag3 = ((tSVector3 - tSVector) % (tSVector2 - tSVector)).sqrMagnitude > TSMath.Epsilon; if (flag3) { triangleList.Add(tSVector); triangleList.Add(tSVector2); triangleList.Add(tSVector3); } } } }
public static bool Detect(ISupportMappable support1, ISupportMappable support2, ref TSMatrix orientation1, ref TSMatrix orientation2, ref TSVector position1, ref TSVector position2, out TSVector point, out TSVector normal, out FP penetration) { TSVector zero = TSVector.zero; TSVector zero2 = TSVector.zero; TSVector zero3 = TSVector.zero; point = (normal = TSVector.zero); penetration = FP.Zero; TSVector tSVector; support1.SupportCenter(out tSVector); TSVector.Transform(ref tSVector, ref orientation1, out tSVector); TSVector.Add(ref position1, ref tSVector, out tSVector); TSVector tSVector2; support2.SupportCenter(out tSVector2); TSVector.Transform(ref tSVector2, ref orientation2, out tSVector2); TSVector.Add(ref position2, ref tSVector2, out tSVector2); TSVector tSVector3; TSVector.Subtract(ref tSVector2, ref tSVector, out tSVector3); bool flag = tSVector3.IsNearlyZero(); if (flag) { tSVector3 = new TSVector(FP.EN4, 0, 0); } TSVector tSVector4 = tSVector3; TSVector.Negate(ref tSVector3, out normal); TSVector tSVector5; XenoCollide.SupportMapTransformed(support1, ref orientation1, ref position1, ref tSVector4, out tSVector5); TSVector tSVector6; XenoCollide.SupportMapTransformed(support2, ref orientation2, ref position2, ref normal, out tSVector6); TSVector tSVector7; TSVector.Subtract(ref tSVector6, ref tSVector5, out tSVector7); bool flag2 = TSVector.Dot(ref tSVector7, ref normal) <= FP.Zero; bool result; if (flag2) { result = false; } else { TSVector.Cross(ref tSVector7, ref tSVector3, out normal); bool flag3 = normal.IsNearlyZero(); if (flag3) { TSVector.Subtract(ref tSVector7, ref tSVector3, out normal); normal.Normalize(); point = tSVector5; TSVector.Add(ref point, ref tSVector6, out point); TSVector.Multiply(ref point, FP.Half, out point); TSVector tSVector8; TSVector.Subtract(ref tSVector6, ref tSVector5, out tSVector8); penetration = TSVector.Dot(ref tSVector8, ref normal); result = true; } else { TSVector.Negate(ref normal, out tSVector4); TSVector tSVector9; XenoCollide.SupportMapTransformed(support1, ref orientation1, ref position1, ref tSVector4, out tSVector9); TSVector tSVector10; XenoCollide.SupportMapTransformed(support2, ref orientation2, ref position2, ref normal, out tSVector10); TSVector tSVector11; TSVector.Subtract(ref tSVector10, ref tSVector9, out tSVector11); bool flag4 = TSVector.Dot(ref tSVector11, ref normal) <= FP.Zero; if (flag4) { result = false; } else { TSVector tSVector8; TSVector.Subtract(ref tSVector7, ref tSVector3, out tSVector8); TSVector tSVector12; TSVector.Subtract(ref tSVector11, ref tSVector3, out tSVector12); TSVector.Cross(ref tSVector8, ref tSVector12, out normal); FP x = TSVector.Dot(ref normal, ref tSVector3); bool flag5 = x > FP.Zero; if (flag5) { TSVector.Swap(ref tSVector7, ref tSVector11); TSVector.Swap(ref tSVector5, ref tSVector9); TSVector.Swap(ref tSVector6, ref tSVector10); TSVector.Negate(ref normal, out normal); Debug.Log("normal: " + normal); } int num = 0; int num2 = 0; bool flag6 = false; while (true) { bool flag7 = num2 > 34; if (flag7) { break; } num2++; TSVector.Negate(ref normal, out tSVector4); TSVector tSVector13; XenoCollide.SupportMapTransformed(support1, ref orientation1, ref position1, ref tSVector4, out tSVector13); TSVector tSVector14; XenoCollide.SupportMapTransformed(support2, ref orientation2, ref position2, ref normal, out tSVector14); TSVector tSVector15; TSVector.Subtract(ref tSVector14, ref tSVector13, out tSVector15); bool flag8 = TSVector.Dot(ref tSVector15, ref normal) <= FP.Zero; if (flag8) { goto Block_7; } TSVector.Cross(ref tSVector7, ref tSVector15, out tSVector8); bool flag9 = TSVector.Dot(ref tSVector8, ref tSVector3) < FP.Zero; if (flag9) { tSVector11 = tSVector15; tSVector9 = tSVector13; tSVector10 = tSVector14; TSVector.Subtract(ref tSVector7, ref tSVector3, out tSVector8); TSVector.Subtract(ref tSVector15, ref tSVector3, out tSVector12); TSVector.Cross(ref tSVector8, ref tSVector12, out normal); } else { TSVector.Cross(ref tSVector15, ref tSVector11, out tSVector8); bool flag10 = TSVector.Dot(ref tSVector8, ref tSVector3) < FP.Zero; if (!flag10) { goto IL_385; } tSVector7 = tSVector15; tSVector5 = tSVector13; tSVector6 = tSVector14; TSVector.Subtract(ref tSVector15, ref tSVector3, out tSVector8); TSVector.Subtract(ref tSVector11, ref tSVector3, out tSVector12); TSVector.Cross(ref tSVector8, ref tSVector12, out normal); } } result = false; return(result); Block_7: result = false; return(result); IL_385: while (true) { num++; TSVector.Subtract(ref tSVector11, ref tSVector7, out tSVector8); TSVector tSVector15; TSVector.Subtract(ref tSVector15, ref tSVector7, out tSVector12); TSVector.Cross(ref tSVector8, ref tSVector12, out normal); bool flag11 = normal.IsNearlyZero(); if (flag11) { break; } normal.Normalize(); FP x2 = TSVector.Dot(ref normal, ref tSVector7); bool flag12 = x2 >= 0 && !flag6; if (flag12) { flag6 = true; } TSVector.Negate(ref normal, out tSVector4); XenoCollide.SupportMapTransformed(support1, ref orientation1, ref position1, ref tSVector4, out zero); XenoCollide.SupportMapTransformed(support2, ref orientation2, ref position2, ref normal, out zero2); TSVector.Subtract(ref zero2, ref zero, out zero3); TSVector.Subtract(ref zero3, ref tSVector15, out tSVector8); FP x3 = TSVector.Dot(ref tSVector8, ref normal); penetration = TSVector.Dot(ref zero3, ref normal); bool flag13 = x3 <= XenoCollide.CollideEpsilon || penetration <= FP.Zero || num > 34; if (flag13) { goto Block_15; } TSVector.Cross(ref zero3, ref tSVector3, out tSVector8); FP x4 = TSVector.Dot(ref tSVector8, ref tSVector7); bool flag14 = x4 >= FP.Zero; if (flag14) { x4 = TSVector.Dot(ref tSVector8, ref tSVector11); bool flag15 = x4 >= FP.Zero; if (flag15) { tSVector7 = zero3; tSVector5 = zero; tSVector6 = zero2; } else { tSVector15 = zero3; TSVector tSVector13 = zero; TSVector tSVector14 = zero2; } } else { x4 = TSVector.Dot(ref tSVector8, ref tSVector15); bool flag16 = x4 >= FP.Zero; if (flag16) { tSVector11 = zero3; tSVector9 = zero; tSVector10 = zero2; } else { tSVector7 = zero3; tSVector5 = zero; tSVector6 = zero2; } } } result = true; return(result); Block_15: bool flag17 = flag6; if (flag17) { TSVector.Cross(ref tSVector7, ref tSVector11, out tSVector8); TSVector tSVector15; FP fP = TSVector.Dot(ref tSVector8, ref tSVector15); TSVector.Cross(ref tSVector15, ref tSVector11, out tSVector8); FP fP2 = TSVector.Dot(ref tSVector8, ref tSVector3); TSVector.Cross(ref tSVector3, ref tSVector7, out tSVector8); FP fP3 = TSVector.Dot(ref tSVector8, ref tSVector15); TSVector.Cross(ref tSVector11, ref tSVector7, out tSVector8); FP fP4 = TSVector.Dot(ref tSVector8, ref tSVector3); FP fP5 = fP + fP2 + fP3 + fP4; bool flag18 = fP5 <= 0; if (flag18) { fP = 0; TSVector.Cross(ref tSVector11, ref tSVector15, out tSVector8); fP2 = TSVector.Dot(ref tSVector8, ref normal); TSVector.Cross(ref tSVector15, ref tSVector7, out tSVector8); fP3 = TSVector.Dot(ref tSVector8, ref normal); TSVector.Cross(ref tSVector7, ref tSVector11, out tSVector8); fP4 = TSVector.Dot(ref tSVector8, ref normal); fP5 = fP2 + fP3 + fP4; } FP x5 = FP.One / fP5; TSVector.Multiply(ref tSVector, fP, out point); TSVector.Multiply(ref tSVector5, fP2, out tSVector8); TSVector.Add(ref point, ref tSVector8, out point); TSVector.Multiply(ref tSVector9, fP3, out tSVector8); TSVector.Add(ref point, ref tSVector8, out point); TSVector tSVector13; TSVector.Multiply(ref tSVector13, fP4, out tSVector8); TSVector.Add(ref point, ref tSVector8, out point); TSVector.Multiply(ref tSVector2, fP, out tSVector12); TSVector.Add(ref tSVector12, ref point, out point); TSVector.Multiply(ref tSVector6, fP2, out tSVector8); TSVector.Add(ref point, ref tSVector8, out point); TSVector.Multiply(ref tSVector10, fP3, out tSVector8); TSVector.Add(ref point, ref tSVector8, out point); TSVector tSVector14; TSVector.Multiply(ref tSVector14, fP4, out tSVector8); TSVector.Add(ref point, ref tSVector8, out point); TSVector.Multiply(ref point, x5 * FP.Half, out point); } result = flag6; } } } return(result); }