public void accelerateByEnergyInJoules(SpatialVectorDouble normal, double absolvedEnergyInJoules)
{
// PHYSICS TO CHECK ASSUMPTION< we just use e = 1/2 * m * v², because v can be relative >
// see http://www.dummies.com/education/science/physics/how-to-calculate-the-kinetic-energy-of-an-object/
double vDelta = System.Math.Sqrt(absolvedEnergyInJoules * 2 / composition.mass);
relativeVelocity += normal.scale(vDelta);
}
public void integrate(ref RungeKutta4State state, float t, float dt)
{
Derivative a, b, c, d, dummy;
dummy.dx = new SpatialVectorDouble(new double[] { 0.0, 0.0, 0.0 });
dummy.dv = new SpatialVectorDouble(new double[] { 0.0, 0.0, 0.0 });
a = evaluate(ref state, t, 0.0f, ref dummy);
b = evaluate(ref state, t, dt * 0.5f, ref a);
c = evaluate(ref state, t, dt * 0.5f, ref b);
d = evaluate(ref state, t, dt, ref c);
SpatialVectorDouble dxdt = (a.dx + (b.dx + c.dx).scale(2.0f) + d.dx).scale(1.0f / 6.0f);
SpatialVectorDouble dvdt = (a.dv + (b.dv + c.dv).scale(2.0f) + d.dv).scale(1.0f / 6.0f);
state.x = state.x + dxdt.scale(dt);
state.v = state.v + dvdt.scale(dt);
}
// calculates the gravitational forces and coresponding accelerations
public void calcForcesAndAccelerationsForPhysicsComponents(IEnumerable <PhysicsComponent> physicsComponents)
{
foreach (PhysicsComponent iPhysicsComponent in physicsComponents)
{
SpatialVectorDouble sumOfForce = new SpatialVectorDouble(new double[] { 0, 0, 0 });
foreach (CelestialObjectWithPosition iCelestialObject in celestialObjects)
{
SpatialVectorDouble extrapolatedPosition = iPhysicsComponent.rungeKutta4State.x + iPhysicsComponent.rungeKutta4State.v.scale(PhysicsEngine.dt);
SpatialVectorDouble difference = iCelestialObject.position - extrapolatedPosition;
SpatialVectorDouble direction = difference.normalized();
double distanceSquared = difference.lengthSquared;
double forceMagnitude = Orbit.calculateForceBetweenObjectsByDistance(iPhysicsComponent.mass, iCelestialObject.celestialObject.mass, distanceSquared);
sumOfForce += direction.scale(forceMagnitude);
}
SpatialVectorDouble acceleration = sumOfForce.scale(iPhysicsComponent.invMass);
iPhysicsComponent.linearAcceleration += acceleration;
}
}
public void renderString(string @string, SpatialVectorDouble signScale, SpatialVectorDouble position)
{
Debug.Assert(lineRendererDriver != null);
SpatialVectorDouble currentPosition = position.deepClone();
// TODO< find optimal scale >
const float rescalingFactor = 1.0f / 16.0f;
lineRendererDriver.scale = signScale.scale(rescalingFactor); // normalize scale with scale of a typical sign
int i = 0;
foreach (char @char in @string)
{
lineRendererDriver.center = currentPosition;
// continue with next sign if we can't look it up
if (!signToHersheyCommandIndex.ContainsKey(@char))
{
continue;
}
int commandIndex = signToHersheyCommandIndex[@char];// (60+30-1) + 3*30; // signToHersheyCommandIndex[@char];
string hersheyCommands = hersheyCommandsOfLetters[commandIndex];
hesheyInterpreter.interpret(hersheyCommands, lineRendererDriver);
float widthBeforeRescaling = lineRendererDriver.positionRight - lineRendererDriver.positionLeft; // width is the difference
float width = (widthBeforeRescaling * rescalingFactor) * (float)signScale.x;
currentPosition.x += width;
i++;// for testing
}
}
static void applyForceToLinearAndAngularVelocity(PhysicsComponent physicsComponent, SpatialVectorDouble localForce, SpatialVectorDouble objectLocalPositionOfForce)
{
{ // linear part
// to calculate the linear component we use the dot product
double scaleOfLinearForce = 0.0;
if (localForce.length > double.Epsilon)
{
double dotOfForceAndLocalPosition = SpatialVectorDouble.dot(localForce.normalized(), objectLocalPositionOfForce.normalized());
scaleOfLinearForce = System.Math.Abs(dotOfForceAndLocalPosition);
}
// the linear force (and resulting acceleration) is the force scaled by the dot product
Matrix rotationMatrix = physicsComponent.calcLocalToGlobalRotationMatrix();
Matrix globalForceAsMatrix = rotationMatrix * SpatialVectorUtilities.toVector4(localForce).asMatrix;
SpatialVectorDouble globalForce = SpatialVectorUtilities.toVector3(new SpatialVectorDouble(globalForceAsMatrix));
physicsComponent.linearAcceleration += globalForce.scale(scaleOfLinearForce * physicsComponent.invMass);
}
{ // angular part
physicsComponent.eulerAngularAcceleration += physicsComponent.calcAngularAccelerationOfRigidBodyForAppliedForce(objectLocalPositionOfForce, localForce);
}
}
RayHitDescriptor?traceRayInternal(SpatialVectorDouble rayOrigin, SpatialVectorDouble rayDirection, out bool hit, double maxT = double.MaxValue)
{
CollisionDescriptor collisionDescriptor = new CollisionDescriptor();
foreach (PhysicsComponentAndCollidersPair iPhysicsComponentAndColliders in physicsAndMeshPairs)
{
if (ConvexHullRayIntersection.checkRayCollision(rayOrigin, rayDirection, iPhysicsComponentAndColliders.physicsComponent.boundingVolume.convexHull))
{
// iterate over all ColliderComponents and check for collision
foreach (ColliderComponent iCollider in iPhysicsComponentAndColliders.colliders)
{
if (iCollider.isConvex)
{
SpatialVectorDouble[] convexHullPlanes = MeshUtilities.calcAllPlanes(iCollider.faces, iCollider.transformedVertices);
SpatialVectorDouble?hitNormal;
double hitTResult;
int? hitFaceNumber;
bool isHit = ConvexHullRayIntersection.calcRayCollision(rayOrigin, rayDirection, convexHullPlanes, out hitNormal, out hitTResult, out hitFaceNumber);
if (!isHit)
{
continue;
}
if (hitTResult < 0.0)
{
continue;
}
if (hitTResult > maxT)
{
continue;
}
if (collisionDescriptor.rayDistance < hitTResult)
{
continue;
}
// store collision information
collisionDescriptor.rayDistance = hitTResult;
collisionDescriptor.faceIndex = (uint)hitFaceNumber.Value;
collisionDescriptor.faceNormal = hitNormal.Value;
collisionDescriptor.physicsComponentAndCollider = new PhysicsComponentAndCollidersPair(iPhysicsComponentAndColliders.physicsComponent, iCollider);
collisionDescriptor.hit = true;
}
else
{
throw new NotImplementedException();
}
}
}
}
hit = collisionDescriptor.hit;
if (hit)
{
// translate hit informations
RayHitDescriptor hitDescriptor = new RayHitDescriptor();
hitDescriptor.hitNormal = collisionDescriptor.faceNormal;
hitDescriptor.hitPhysicsComponentAndCollider = collisionDescriptor.physicsComponentAndCollider;
hitDescriptor.hitPosition = rayOrigin + rayDirection.scale(collisionDescriptor.rayDistance);
return(hitDescriptor);
}
else
{
return(null);
}
}