public static bool ClosestPoints(ISupportMappable support1, ISupportMappable support2, ref JMatrix orientation1,
ref JMatrix orientation2, ref JVector position1, ref JVector position2,
out JVector p1, out JVector p2, out JVector normal)
{
VoronoiSimplexSolver simplexSolver = simplexSolverPool.GetNew();
simplexSolver.Reset();
p1 = p2 = JVector.Zero;
JVector r = position1 - position2;
JVector w, v;
JVector supVertexA;
JVector rn, vn;
rn = JVector.Negate(r);
SupportMapTransformed(support1, ref orientation1, ref position1, ref rn, out supVertexA);
JVector supVertexB;
SupportMapTransformed(support2, ref orientation2, ref position2, ref r, out supVertexB);
v = supVertexA - supVertexB;
normal = JVector.Zero;
int iter = 0;
float distSq = v.LengthSquared();
float epsilon = 0.00001f;
while ((distSq > epsilon) && (iter++ < MaxIterations))
{
IterationsTaken = iter;
vn = JVector.Negate(v);
SupportMapTransformed(support1, ref orientation1, ref position1, ref vn, out supVertexA);
SupportMapTransformed(support2, ref orientation2, ref position2, ref v, out supVertexB);
w = supVertexA - supVertexB;
if (!simplexSolver.InSimplex(w)) simplexSolver.AddVertex(w, supVertexA, supVertexB);
if (simplexSolver.Closest(out v))
{
distSq = v.LengthSquared();
normal = v;
}
else distSq = 0.0f;
}
simplexSolver.ComputePoints(out p1, out p2);
if (normal.LengthSquared() > JMath.Epsilon * JMath.Epsilon)
normal.Normalize();
simplexSolverPool.GiveBack(simplexSolver);
return true;
}
public FixedLinearSpring(RigidBody body, JVector localAnchor, JVector worldAnchor, float springConstant, float dampingConstant)
{
Body = body;
LocalAnchor = localAnchor;
WorldAnchor = worldAnchor;
SpringConstant = springConstant;
DampingConstant = dampingConstant;
Length = (worldAnchor - Body.LocalToWorld(localAnchor)).Length();
}
/// <summary>
/// Discrete Box vs Box test. Very fast. No contact info. NOTE: ensure UpdateAxes is called for each BoxShape prior.
/// </summary>
/// <param name="A">BoxShape A.</param>
/// <param name="PA">BoxShape A's position.</param>
/// <param name="B">BoxShape B.</param>
/// <param name="PB">BoxShape B's position.</param>
/// <returns></returns>
public static bool BoxBoxTest(ref BoxShape A, ref JVector PA, ref BoxShape B, ref JVector PB)
{
JVector T = PB - PA;
// cache scaled local axes
JVector Ax = A.halfSize.X * A.xAxis;
JVector Ay = A.halfSize.Y * A.yAxis;
JVector Bx = B.halfSize.X * B.xAxis;
JVector By = B.halfSize.Y * B.yAxis;
// axis to test
JVector L = A.xAxis;
float TL = Math.Abs(T * L);
float a = Math.Abs((Ax) * L) + Math.Abs((Ay) * L);
float b = Math.Abs((Bx) * L) + Math.Abs((By) * L);
if (TL > (a + b))
return false;
// axis to test
L = A.yAxis;
TL = Math.Abs(T * L);
a = Math.Abs((Ax) * L) + Math.Abs((Ay) * L);
b = Math.Abs((Bx) * L) + Math.Abs((By) * L);
if (TL > (a + b))
return false;
// axis to test
L = B.xAxis;
TL = Math.Abs(T * L);
a = Math.Abs((Ax) * L) + Math.Abs((Ay) * L);
b = Math.Abs((Bx) * L) + Math.Abs((By) * L);
if (TL > (a + b))
return false;
// axis to test
L = B.yAxis;
TL = Math.Abs(T * L);
a = Math.Abs((Ax) * L) + Math.Abs((Ay) * L);
b = Math.Abs((Bx) * L) + Math.Abs((By) * L);
if (TL > (a + b))
return false;
// if all axes overlap collision exists
return true;
}
public static void SupportMapTransformed(ISupportMappable support,
ref JMatrix orientation, ref JVector position, ref JVector direction, out JVector result)
{
// THIS IS *THE* HIGH FREQUENCY CODE OF THE COLLLISION PART OF THE ENGINE
result.X = ((direction.X * orientation.M11) + (direction.Y * orientation.M12));
result.Y = ((direction.X * orientation.M21) + (direction.Y * orientation.M22));
support.SupportMapping(ref result, out result);
float x = ((result.X * orientation.M11) + (result.Y * orientation.M21));
float y = ((result.X * orientation.M12) + (result.Y * orientation.M22));
result.X = position.X + x;
result.Y = position.Y + y;
}
/// <summary>
/// SupportMapping. Finds the point in the shape furthest away from the given direction.
/// Imagine a plane with a normal in the search direction. Now move the plane along the normal
/// until the plane does not intersect the shape. The last intersection point is the result.
/// </summary>
/// <param name="direction">The direction.</param>
/// <param name="result">The result.</param>
public override void SupportMapping(ref JVector direction, out JVector result)
{
float maxDotProduct = float.MinValue;
int maxIndex = 0;
float dotProduct;
for (int i = 0; i < vertices.Count; i++)
{
dotProduct = JVector.Dot(vertices[i], direction);
if (dotProduct > maxDotProduct)
{
maxDotProduct = dotProduct;
maxIndex = i;
}
}
result = vertices[maxIndex] - this.shifted;
}
public static bool CircleCircleTest(JVector centerA, float radiusA, JVector centerB, float radiusB, out JVector pointA, out JVector pointB, out JVector normal, out float distance)
{
// ||A-B|| - (r1+r2) < 0
float d = JVector.Distance(centerA, centerB);
float r = radiusA + radiusB;
distance = d - r;
normal = (centerA - centerB) / d;
//penetrationVector = normal * distance;
// calculate closest 2 points
pointA = JVector.Negate(normal) * radiusA + centerA;
pointB = normal * radiusB + centerB;
if (distance < 0.0f)
return true;
else
return false;
}
/// <summary>
/// Transforms the bounding box into the space given by orientation and position.
/// </summary>
/// <param name="position"></param>
/// <param name="orientation"></param>
/// <param name="result"></param>
internal void InverseTransform(ref JVector position, ref JMatrix orientation)
{
JVector.Subtract(ref Max, ref position, out Max);
JVector.Subtract(ref Min, ref position, out Min);
JVector center;
JVector.Add(ref Max, ref Min, out center);
center.X *= 0.5f; center.Y *= 0.5f;
JVector halfExtents;
JVector.Subtract(ref Max, ref Min, out halfExtents);
halfExtents.X *= 0.5f; halfExtents.Y *= 0.5f;
JVector.TransposedTransform(ref center, ref orientation, out center);
JMatrix abs; JMath.Absolute(ref orientation, out abs);
JVector.TransposedTransform(ref halfExtents, ref abs, out halfExtents);
JVector.Add(ref center, ref halfExtents, out Max);
JVector.Subtract(ref center, ref halfExtents, out Min);
}
public static bool CircleCapsuleTest(JVector centerA, float radiusA, JVector centerB, JVector axis, float length, float radiusB, out JVector pointA, out JVector pointB, out JVector normal, out float distance)
{
// get capsule endpoints
var p0 = centerB - axis * (length * 0.5f);
var p1 = centerB + axis * (length * 0.5f);
// get vector from endpoint to circle
var D = centerA - p0;
// project vector onto axis and clamp
var d = JVector.Dot(D, axis);
d = JMath.Clamp(d, 0, length);
// get point on axis
var R = p0 + axis * d;
// distance
var b = Math.Abs((centerA - R).Length());
normal = (centerA - R) / b;
// calculate closest 2 points
var RH = JVector.Normalize(centerA - R);
pointA = JVector.Negate(RH) * radiusA + centerA;
pointB = RH * radiusB + R;
normal.Negate();
distance = b - (radiusA + radiusB);
//
if (b < radiusA + radiusB)
return true;
return false;
}
public void AddPoint(JVector point)
{
AddPoint(ref point);
}
public bool SegmentIntersect(JVector origin, JVector direction)
{
return(SegmentIntersect(ref origin, ref direction));
}
/// <summary>
/// Checks wether a point is within a box or not.
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public ContainmentType Contains(JVector point)
{
return(this.Contains(ref point));
}
/// <summary>
/// Transforms a vector by the transposed of the given Matrix.
/// </summary>
/// <param name="position">The vector to transform.</param>
/// <param name="matrix">The transform matrix.</param>
/// <param name="result">The transformed vector.</param>
public static void TransposedTransform(ref JVector position, ref JMatrix matrix, out JVector result)
{
float num0 = ((position.X * matrix.M11) + (position.Y * matrix.M12));
float num1 = ((position.X * matrix.M21) + (position.Y * matrix.M22));
result.X = num0;
result.Y = num1;
}
static JVector()
{
One = new JVector(1, 1);
Zero = new JVector(0, 0);
Left = new JVector(1, 0);
Right = new JVector(-1, 0);
Up = new JVector(0, 1);
Down = new JVector(0, -1);
MinValue = new JVector(float.MinValue);
MaxValue = new JVector(float.MaxValue);
Arbitrary = new JVector(1, 1);
InternalZero = Zero;
}
/// <summary>
/// Subtracts to vectors.
/// </summary>
/// <param name="value1">The first vector.</param>
/// <param name="value2">The second vector.</param>
/// <param name="result">The difference of both vectors.</param>
public static void Subtract(ref JVector value1, ref JVector value2, out JVector result)
{
float num0 = value1.X - value2.X;
float num1 = value1.Y - value2.Y;
result.X = num0;
result.Y = num1;
}
public static JVector Transform(JVector position, JMatrix matrix)
{
JVector result;
JVector.Transform(ref position, ref matrix, out result);
return result;
}
/// <summary>
/// Adds two vectors.
/// </summary>
/// <param name="value1">The first vector.</param>
/// <param name="value2">The second vector.</param>
/// <returns>The sum of both vectors.</returns>
#region public static JVector operator +(JVector value1, JVector value2)
public static JVector operator +(JVector value1, JVector value2)
{
JVector result; JVector.Add(ref value1, ref value2, out result);
return(result);
}
public static JVector Cross(JVector a, float s)
{
return(new JVector(s * a.Y, -s * a.X));
}
/// <summary>
/// Calculates the dot product of two vectors.
/// </summary>
/// <param name="value1">The first vector.</param>
/// <param name="value2">The second vector.</param>
/// <returns>Returns the dot product of both.</returns>
#region public static float operator *(JVector value1, JVector value2)
public static float operator *(JVector value1, JVector value2)
{
return(JVector.Dot(ref value1, ref value2));
}
/// <summary>
/// Subtracts two vectors.
/// </summary>
/// <param name="value1">The first vector.</param>
/// <param name="value2">The second vector.</param>
/// <returns>The difference of both vectors.</returns>
#region public static JVector operator -(JVector value1, JVector value2)
public static JVector operator -(JVector value1, JVector value2)
{
JVector result; JVector.Subtract(ref value1, ref value2, out result);
return(result);
}
/// <summary>
/// Calculates the cross product of two vectors.
/// </summary>
/// <param name="value1">The first vector.</param>
/// <param name="value2">The second vector.</param>
/// <returns>Returns the cross product of both.</returns>
#region public static JVector operator %(JVector value1, JVector value2)
public static float operator %(JVector value1, JVector value2)
{
float result; JVector.Cross(ref value1, ref value2, out result);
return(result);
}
/// <summary>
/// Multiply a vector with a factor.
/// </summary>
/// <param name="value1">The vector to multiply.</param>
/// <param name="scaleFactor">The scale factor.</param>
/// <param name="result">Returns the multiplied vector.</param>
public static void Multiply(ref JVector value1, float scaleFactor, out JVector result)
{
result.X = value1.X * scaleFactor;
result.Y = value1.Y * scaleFactor;
}
/// <summary>
/// Calculates the dot product of both vectors.
/// </summary>
/// <param name="vector1">The first vector.</param>
/// <param name="vector2">The second vector.</param>
/// <returns>Returns the dot product of both vectors.</returns>
public static float Dot(ref JVector vector1, ref JVector vector2)
{
return((vector1.X * vector2.X) + (vector1.Y * vector2.Y));
}
///// <summary>
///// Returns the largest box possible.
///// </summary>
//public static readonly JBBox LargeBox;
///// <summary>
///// Returns the smalltest box possible.
///// </summary>
//public static readonly JBBox SmallBox;
//static JBBox()
//{
// LargeBox.Min = new JVector(float.MinValue);
// LargeBox.Max = new JVector(float.MaxValue);
// SmallBox.Min = new JVector(float.MaxValue);
// SmallBox.Max = new JVector(float.MinValue);
//}
/// <summary>
/// Constructor
/// </summary>
/// <param name="min">The minimum point of the box.</param>
/// <param name="max">The maximum point of the box.</param>
public JBBox(JVector min, JVector max)
{
this.Min = min;
this.Max = max;
}
public static JVector Cross(float s, JVector a)
{
return(new JVector(-s * a.Y, s * a.X));
}
/// <summary>
/// Calculates the dot product of two vectors.
/// </summary>
/// <param name="vector1">The first vector.</param>
/// <param name="vector2">The second vector.</param>
/// <returns>Returns the dot product of both vectors.</returns>
#region public static float Dot(JVector vector1, JVector vector2)
public static float Dot(JVector vector1, JVector vector2)
{
return(JVector.Dot(ref vector1, ref vector2));
}
internal static JVector Clamp(JVector v, float len)
{
return((JVector.Dot(v, v) > len * len) ? JVector.Multiply(JVector.Normalize(v), len) : v);
}
/// <summary>
/// Swaps the components of both vectors.
/// </summary>
/// <param name="vector1">The first vector to swap with the second.</param>
/// <param name="vector2">The second vector to swap with the first.</param>
public static void Swap(ref JVector vector1, ref JVector vector2)
{
float temp;
temp = vector1.X;
vector1.X = vector2.X;
vector2.X = temp;
temp = vector1.Y;
vector1.Y = vector2.Y;
vector2.Y = temp;
}
public static JVector Multiply(JVector value1, float scaleFactor)
{
JVector result;
JVector.Multiply(ref value1, scaleFactor, out result);
return result;
}
/// <summary>
/// Transforms a vector by the transposed of the given Matrix.
/// </summary>
/// <param name="position">The vector to transform.</param>
/// <param name="matrix">The transform matrix.</param>
/// <param name="result">The transformed vector.</param>
public static JVector TransposedTransform(JVector position, JMatrix matrix)
{
JVector result;
float num0 = ((position.X * matrix.M11) + (position.Y * matrix.M12));
float num1 = ((position.X * matrix.M21) + (position.Y * matrix.M22));
result.X = num0;
result.Y = num1;
return result;
}
/// <summary>
/// Multiply a vector with a factor.
/// </summary>
/// <param name="value1">The vector to multiply.</param>
/// <param name="scaleFactor">The scale factor.</param>
/// <param name="result">Returns the multiplied vector.</param>
public static void Multiply(ref JVector value1, float scaleFactor, out JVector result)
{
result.X = value1.X * scaleFactor;
result.Y = value1.Y * scaleFactor;
}
internal static JVector Clamp(JVector v, float len)
{
return (JVector.Dot(v, v) > len * len) ? JVector.Multiply(JVector.Normalize(v), len) : v;
}
public override bool Raycast(JVector rayOrigin, JVector rayDirection, RaycastCallback raycast, out RigidBody body, out JVector normal, out float fraction)
{
throw new NotImplementedException();
//body = null; normal = JVector.Zero; fraction = float.MaxValue;
//JVector tempNormal; float tempFraction;
//bool result = false;
//// TODO: This can be done better in CollisionSystemPersistenSAP
//foreach (IBroadphaseEntity e in bodyList)
//{
// if (e is SoftBody)
// {
// SoftBody softBody = e as SoftBody;
// foreach (RigidBody b in softBody.VertexBodies)
// {
// if (this.Raycast(b, rayOrigin, rayDirection, out tempNormal, out tempFraction))
// {
// if (tempFraction < fraction && (raycast == null || raycast(b, tempNormal, tempFraction)))
// {
// body = b;
// normal = tempNormal;
// fraction = tempFraction;
// result = true;
// }
// }
// }
// }
// else
// {
// RigidBody b = e as RigidBody;
// if (this.Raycast(b, rayOrigin, rayDirection, out tempNormal, out tempFraction))
// {
// if (tempFraction < fraction && (raycast == null || raycast(b, tempNormal, tempFraction)))
// {
// body = b;
// normal = tempNormal;
// fraction = tempFraction;
// result = true;
// }
// }
// }
//}
//return result;
}
public JVector ScreenToWorldSpace(JVector position)
{
var t = this.Game.GraphicsDevice.Viewport.Unproject(new Vector3(position.X, position.Y, 0), Projection, View, Matrix.Identity);
return new JVector(t.X, t.Y);
}
public static Vector2 ToXNAVector2(JVector vector)
{
return new Vector2(vector.X, vector.Y);
}
public bool RayIntersect(JVector origin, JVector direction)
{
return(RayIntersect(ref origin, ref direction));
}
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
KeyboardState keys = Keyboard.GetState();
JVector moveVector = JVector.Zero;
float amountOfMovement = 0.05f;
if (keys.IsKeyDown(Keys.Right))
moveVector.X += amountOfMovement;
if (keys.IsKeyDown(Keys.Left))
moveVector.X -= amountOfMovement;
if (keys.IsKeyDown(Keys.Down))
moveVector.Y -= amountOfMovement;
if (keys.IsKeyDown(Keys.Up))
moveVector.Y += amountOfMovement;
PB += moveVector;
OA = (float)gameTime.TotalGameTime.TotalSeconds * 0.1f;
OB = (float)gameTime.TotalGameTime.TotalSeconds * -0.1f;
DrawBox(A, PA, OA, Color.Blue * 0.25f);
DrawBox(B, PB, OB, Color.Green * 0.25f);
float t = 0.0f;
JVector[] CA = new JVector[2], CB = new JVector[2];
int NumContacts = 0;
sw.Start();
JMatrix OAM = JMatrix.CreateRotationZ(OA);
JMatrix OBM = JMatrix.CreateRotationZ(OB);
for (int i = 0; i < 1; i++)
{
A.UpdateAxes(OA);
B.UpdateAxes(OB);
//hit = Collision.BoxBoxTest(ref A, ref PA, ref B, ref PB);
//AV = new List<JVector> { A.GetCorner(0), A.GetCorner(1), A.GetCorner(2), A.GetCorner(3) };
//BV = new List<JVector> { B.GetCorner(0), B.GetCorner(1), B.GetCorner(2), B.GetCorner(3) };
//hit = SAT.Collide(ref AV, ref PA, ref VA, ref OAM,
// ref BV, ref PB, ref VB, ref OBM,
// ref normal, ref t);
//if (hit)
//{
// SAT.FindContacts(ref AV, ref PA, ref VA, ref OAM,
// ref BV, ref PB, ref VB, ref OBM,
// ref normal, t, out CA, out CB, out NumContacts);
// normal.Normalize();
//}
hit = Collision.BoxBoxTestContact(ref A, ref PA, ref OAM, ref B, ref PB, ref OBM,
out normal, out t, out CA, out CB, out NumContacts);
penetration = t;
iterations = NumContacts;
}
sw.Stop();
ticks = sw.ElapsedTicks / 1;
sw.Reset();
if (hit)
{
//DrawBox(A, PA + normal * (t * 0.5f), OA, Color.Blue);
//DrawBox(B, PB - normal * (t * 0.5f), OB, Color.Green);
for (int i = 0; i < NumContacts; i++)
{
DebugDrawer.DrawPoint(CA[i]);// + normal * (t * 0.5f));
DebugDrawer.DrawPoint(CB[i]);// - normal * (t * 0.5f));
}
}
base.Update(gameTime);
}
/// <summary>
/// Checks whether a point is inside, outside or intersecting
/// a point.
/// </summary>
/// <param name="point">A point in space.</param>
/// <returns>The ContainmentType of the point.</returns>
public ContainmentType Contains(ref JVector point)
{
return((((this.Min.X <= point.X) && (point.X <= this.Max.X)) &&
((this.Min.Y <= point.Y) && (point.Y <= this.Max.Y))) ? ContainmentType.Contains : ContainmentType.Disjoint);
}
void DrawPoly(List<JVector> poly, JVector pos, JMatrix o, Color color)
{
for (int i = 0; i < poly.Count - 1; i++)
{
JVector a = JVector.Transform(poly[i], o * JMatrix.CreateTranslation(pos));
JVector b = JVector.Transform(poly[i + 1], o * JMatrix.CreateTranslation(pos));
DebugDrawer.DrawLine(a, b, color);
}
JVector c = JVector.Transform(poly[0], o * JMatrix.CreateTranslation(pos));
JVector d = JVector.Transform(poly[poly.Count - 1], o * JMatrix.CreateTranslation(pos));
DebugDrawer.DrawLine(c, d, color);
}
public void AddPoint(ref JVector point)
{
JVector.Max(ref this.Max, ref point, out this.Max);
JVector.Min(ref this.Min, ref point, out this.Min);
}
/// <summary>
/// Gets a vector with the maximum x and y values of both vectors.
/// </summary>
/// <param name="value1">The first value.</param>
/// <param name="value2">The second value.</param>
/// <param name="result">A vector with the maximum x and y values of both vectors.</param>
public static void Max(ref JVector value1, ref JVector value2, out JVector result)
{
result.X = (value1.X > value2.X) ? value1.X : value2.X;
result.Y = (value1.Y > value2.Y) ? value1.Y : value2.Y;
}
/// <summary>
/// Inverses the direction of a vector.
/// </summary>
/// <param name="value">The vector to inverse.</param>
/// <returns>The negated vector.</returns>
public static JVector Negate(JVector value)
{
JVector result;
JVector.Negate(ref value, out result);
return result;
}
/// <summary>
/// Transforms a vector by the transposed of the given Matrix.
/// </summary>
/// <param name="position">The vector to transform.</param>
/// <param name="matrix">The transform matrix.</param>
/// <param name="result">The transformed vector.</param>
public static void TransposedTransform(ref JVector position, ref JMatrix matrix, out JVector result)
{
float num0 = ((position.X * matrix.M11) + (position.Y * matrix.M12));
float num1 = ((position.X * matrix.M21) + (position.Y * matrix.M22));
result.X = num0;
result.Y = num1;
}
public override bool Raycast(RigidBody body, JVector rayOrigin, JVector rayDirection, out JVector normal, out float fraction)
{
throw new NotImplementedException();
//fraction = float.MaxValue; normal = JVector.Zero;
//if (!body.BoundingBox.RayIntersect(ref rayOrigin, ref rayDirection)) return false;
//if (body.Shape is Multishape)
//{
// Multishape ms = (body.Shape as Multishape).RequestWorkingClone();
// JVector tempNormal; float tempFraction;
// bool multiShapeCollides = false;
// JVector transformedOrigin; JVector.Subtract(ref rayOrigin, ref body.position, out transformedOrigin);
// JVector.Transform(ref transformedOrigin, ref body.invOrientation, out transformedOrigin);
// JVector transformedDirection; JVector.Transform(ref rayDirection, ref body.invOrientation, out transformedDirection);
// int msLength = ms.Prepare(ref transformedOrigin, ref transformedDirection);
// for (int i = 0; i < msLength; i++)
// {
// ms.SetCurrentShape(i);
// if (GJKCollide.Raycast(ms, ref body.orientation, ref body.invOrientation, ref body.position,
// ref rayOrigin, ref rayDirection, out tempFraction, out tempNormal))
// {
// if (tempFraction < fraction)
// {
// if (useTerrainNormal && ms is TerrainShape)
// {
// (ms as TerrainShape).CollisionNormal(out tempNormal);
// JVector.Transform(ref tempNormal, ref body.orientation, out tempNormal);
// tempNormal.Negate();
// }
// else if (useTriangleMeshNormal && ms is TriangleMeshShape)
// {
// (ms as TriangleMeshShape).CollisionNormal(out tempNormal);
// JVector.Transform(ref tempNormal, ref body.orientation, out tempNormal);
// tempNormal.Negate();
// }
// normal = tempNormal;
// fraction = tempFraction;
// multiShapeCollides = true;
// }
// }
// }
// ms.ReturnWorkingClone();
// return multiShapeCollides;
//}
//else
//{
// return (GJKCollide.Raycast(body.Shape, ref body.orientation, ref body.invOrientation, ref body.position,
// ref rayOrigin, ref rayDirection, out fraction, out normal));
//}
}
/// <summary>
/// Inverses the direction of a vector.
/// </summary>
/// <param name="value">The vector to inverse.</param>
/// <param name="result">The negated vector.</param>
public static void Negate(ref JVector value, out JVector result)
{
float num0 = -value.X;
float num1 = -value.Y;
result.X = num0;
result.Y = num1;
}
public static Vector3 ToXNAVector3(JVector vector)
{
return new Vector3(vector.X, vector.Y, 0.0f);
}
public static JVector Normalize(JVector value)
{
JVector result;
JVector.Normalize(ref value, out result);
return result;
}
void DrawBox(BoxShape box, JVector pos, float orientation, Color color)
{
List<JVector> poly = new List<JVector>
{
new JVector(-box.Size.X * 0.5f, -box.Size.Y * 0.5f),
new JVector(box.Size.X * 0.5f, -box.Size.Y * 0.5f),
new JVector(box.Size.X * 0.5f, box.Size.Y * 0.5f),
new JVector(-box.Size.X * 0.5f,box.Size.Y * 0.5f)
};
DrawPoly(poly, pos, JMatrix.CreateRotationZ(orientation), color);
}
/// <summary>
/// Normalizes the given vector.
/// </summary>
/// <param name="value">The vector which should be normalized.</param>
/// <param name="result">A normalized vector.</param>
public static void Normalize(ref JVector value, out JVector result)
{
float num2 = (value.X * value.X) + (value.Y * value.Y);
float num = 1f / ((float)Math.Sqrt((double)num2));
result.X = value.X * num;
result.Y = value.Y * num;
}
protected override void Initialize()
{
DebugDrawer = new DebugDrawer(this);
this.Components.Add(DebugDrawer);
Camera = new Camera(this);
this.Components.Add(Camera);
A = new BoxShape(4, 1);
PA = new JVector(-1, 2);
VA = new JVector(0, 0);
OA = MathHelper.ToRadians(0);
B = new BoxShape(1, 4);
PB = new JVector(-3, 0);
VB = new JVector(0, 0);
OB = 0;
base.Initialize();
}
public static JVector Subtract(JVector value1, JVector value2)
{
JVector result;
JVector.Subtract(ref value1, ref value2, out result);
return result;
}