public void Update(GameTime gameTime)
{
if (!SystemCore.PhysicsOnBackgroundThread)
{
if (Simulated)
{
ParentObject.Transform.AbsoluteTransform = MonoMathHelper.GenerateMonoMatrixFromBepu(PhysicsEntity.WorldTransform);
}
else
{
PhysicsEntity.WorldTransform =
MonoMathHelper.GenerateBepuMatrixFromMono(ParentObject.Transform.AbsoluteTransform);
}
}
else
{
if (Simulated)
{
ParentObject.Transform.AbsoluteTransform =
MonoMathHelper.GenerateMonoMatrixFromBepu(PhysicsEntity.BufferedStates.States.WorldTransform);
}
else
{
PhysicsEntity.BufferedStates.States.WorldTransform =
MonoMathHelper.GenerateBepuMatrixFromMono(ParentObject.Transform.AbsoluteTransform);
}
}
}
public void MoveForward(float amountToMove)
{
if ((DateTime.Now - lastMovement).TotalMilliseconds < movementFrequency)
{
return;
}
lastMovement = DateTime.Now;
var forward = new RestRequest("player/actions", Method.POST);
forward.RequestFormat = DataFormat.Json;
forward.AddBody(new PlayerAction()
{
type = "forward", amount = amountToMove
});
apiHandler.EnqueueRequest(false, forward, x =>
{
moving = false;
});
if (MonoMathHelper.DistanceBetween(lastKnownPositionBeforeMovementCommand, ParentObject.Transform.AbsoluteTransform.Translation) < 0.2f)
{
movementAttemptsWithNoPositionChange++;
}
lastKnownPositionBeforeMovementCommand = ParentObject.Transform.AbsoluteTransform.Translation;
}
public bool IntersectsALevelSegment(Vector3 a, Vector3 b, bool onlyCareAboutVisibility)
{
foreach (Bucket buck in buckets)
{
if (buck.LineIntersects(a, b) || (buck.PointIn(a) && buck.PointIn(b)))
{
List <IPartitionItem> linesInBucket = buck.itemsInBucket.FindAll(x => x.Type == "DoomLine");
foreach (DoomLine line in linesInBucket)
{
//this is a test of LOS only, so ignore lines that prevent traverse but allow LOS
//e.g. testing for LOS for a monster on a high pillar
if (onlyCareAboutVisibility)
{
if (!line.BlocksLineOfSight)
{
continue;
}
}
if (MonoMathHelper.LineIntersection(line.start.ToVector2XZ(), line.end.ToVector2XZ(), a.ToVector2XZ(), b.ToVector2XZ()))
{
return(true);
}
}
}
}
return(false);
}
public void Initialise()
{
if (PhysicsEntity == null)
{
if (PhysicsMeshType == PhysicsMeshType.box)
{
GenerateBoxCollider();
}
if (PhysicsMeshType == PhysicsMeshType.sphere)
{
GenerateSphereCollider();
}
if (!movable)
{
PhysicsEntity.BecomeKinematic();
}
}
PhysicsEntity.Tag = ParentObject;
PhysicsEntity.CollisionInformation.Tag = ParentObject;
if (!SystemCore.PhysicsOnBackgroundThread)
{
PhysicsEntity.WorldTransform =
MonoMathHelper.GenerateBepuMatrixFromMono(ParentObject.Transform.AbsoluteTransform);
SystemCore.PhysicsSimulation.Add(PhysicsEntity);
}
else
{
PhysicsEntity.BufferedStates.States.WorldTransform =
MonoMathHelper.GenerateBepuMatrixFromMono(ParentObject.Transform.AbsoluteTransform);
SystemCore.PhysicsSimulation.SpaceObjectBuffer.Add(PhysicsEntity);
}
}
internal float GetHeading()
{
var currentForward = Transform.AbsoluteTransform.Forward.ToVector2XZ();
float heading = MathHelper.ToDegrees(MonoMathHelper.GetHeadingFromVector(currentForward));
heading = (heading + 360) % 360;
return(heading);
}
public void SetPositionAndLookDir(Vector3 pos, Vector3 target)
{
World = MonoMathHelper.GenerateWorldMatrixFromPositionAndTarget(pos, target, Vector3.Up);
if (HighPrecisionMode)
{
World.Translation = Vector3.Zero;
}
View = Matrix.Invert(World);
}
private void GenerateSphereCollider()
{
RenderGeometryComponent geometry = ParentObject.GetComponent <RenderGeometryComponent>();
List <Vector3> verts = geometry.GetVertices();
BoundingSphere sphere = BoundingSphere.CreateFromPoints(verts);
PhysicsEntity = new Sphere(MonoMathHelper.Translate(ParentObject.Transform.AbsoluteTransform.Translation),
sphere.Radius, 1);
PhysicsEntity.Tag = ParentObject;
}
internal void SetPosition(Vector3 position)
{
//not yet initialized
if (PhysicsEntity == null)
{
return;
}
PhysicsEntity.WorldTransform =
MonoMathHelper.GenerateBepuMatrixFromMono(ParentObject.Transform.AbsoluteTransform);
}
private void FeelForward()
{
DoomComponent playerDoomComponent = ParentObject.GetComponent <DoomComponent>();
Vector3 pos = ParentObject.Transform.AbsoluteTransform.Translation;
Vector3 forwardVec = ParentObject.Transform.AbsoluteTransform.Translation + ParentObject.Transform.AbsoluteTransform.Forward * playerDoomComponent.HitVectorSize;
Vector3 rightVec = MonoMathHelper.RotateAroundPoint(forwardVec, ParentObject.Transform.AbsoluteTransform.Translation, Vector3.Up, MathHelper.PiOver4 / 2);
Vector3 leftVec = MonoMathHelper.RotateAroundPoint(forwardVec, ParentObject.Transform.AbsoluteTransform.Translation, Vector3.Up, -MathHelper.PiOver4 / 2);
pos.Y = 0;
forwardVec.Y = 0;
rightVec.Y = 0;
leftVec.Y = 0;
Color forwardColor = Color.Red;
Color leftColor = Color.Red;
Color rightColor = Color.Red;
if (mapHandler.IntersectsLevel(pos, forwardVec))
{
forwardColor = Color.Blue;
}
if (mapHandler.IntersectsLevel(pos, rightVec))
{
rightColor = Color.Blue;
var strafe = new RestRequest("player/actions", Method.POST);
strafe.RequestFormat = DataFormat.Json;
strafe.AddBody(new PlayerAction()
{
type = "strafe-left", amount = 2
});
apiHandler.EnqueueCoolDownRequest("strafe-left", strafe, 400, x => { });
}
if (mapHandler.IntersectsLevel(pos, leftVec))
{
leftColor = Color.Blue;
var strafe = new RestRequest("player/actions", Method.POST);
strafe.RequestFormat = DataFormat.Json;
strafe.AddBody(new PlayerAction()
{
type = "strafe-right", amount = 2
});
apiHandler.EnqueueCoolDownRequest("strafe-right", strafe, 400, x => { });
}
DebugShapeRenderer.AddLine(pos, forwardVec, forwardColor);
DebugShapeRenderer.AddLine(pos, leftVec, leftColor);
DebugShapeRenderer.AddLine(pos, rightVec, rightColor);
}
public override void Render(GameTime gameTime)
{
SystemCore.GraphicsDevice.Clear(Color.Black);
DebugShapeRenderer.VisualiseAxes(5f);
RenderLineDefs();
RenderFloodFill();
RenderPath();
//RenderPartition();
if (playerObj != null)
{
DoomComponent playerDoomComponent = playerObj.GetComponent <DoomComponent>();
Color forwardColor = Color.Red;
Color leftColor = Color.Red;
Color rightColor = Color.Red;
if (playerDoomComponent.ForwardHitVector)
{
forwardColor = Color.Blue;
}
if (playerDoomComponent.LeftHitVector)
{
leftColor = Color.Blue;
}
if (playerDoomComponent.RightHightVector)
{
rightColor = Color.Blue;
}
Vector3 pos = playerObj.Transform.AbsoluteTransform.Translation;
Vector3 forwardVec = playerObj.Transform.AbsoluteTransform.Translation + playerObj.Transform.AbsoluteTransform.Forward * playerDoomComponent.HitVectorSize;
Vector3 rightVec = MonoMathHelper.RotateAroundPoint(forwardVec, playerObj.Transform.AbsoluteTransform.Translation, Vector3.Up, MathHelper.PiOver4);
Vector3 leftVec = MonoMathHelper.RotateAroundPoint(forwardVec, playerObj.Transform.AbsoluteTransform.Translation, Vector3.Up, -MathHelper.PiOver4);
DebugShapeRenderer.AddLine(pos, forwardVec, forwardColor);
DebugShapeRenderer.AddLine(pos, leftVec, leftColor);
DebugShapeRenderer.AddLine(pos, rightVec, rightColor);
DebugText.Write(playerObj.Transform.AbsoluteTransform.Translation.ToString());
DebugText.Write(playerAngle.ToString());
}
base.Render(gameTime);
}
internal bool IntersectsHazardLine(Vector3 start, Vector3 end)
{
foreach (DoomLine line in HazardLines)
{
if (MonoMathHelper.LineIntersection(start.ToVector2XZ(), end.ToVector2XZ(), line.start.ToVector2XZ(), line.end.ToVector2XZ()))
{
return(true);
}
}
return(false);
}
public void RotateAround(Vector3 axis, Vector3 OrbitPoint, float amount)
{
AbsoluteTransform.Translation -= OrbitPoint;
AbsoluteTransform = AbsoluteTransform *= Matrix.CreateFromAxisAngle(axis, amount);
AbsoluteTransform.Translation += OrbitPoint;
if (ParentObject.ContainsComponent <PhysicsComponent>())
{
Entity physicsentity = ParentObject.GetComponent <PhysicsComponent>().PhysicsEntity;
physicsentity.WorldTransform = MonoMathHelper.GenerateBepuMatrixFromMono(ParentObject.Transform.AbsoluteTransform);
}
}
internal void SetHeadingToPointToVector(Vector3 targetVec)
{
Vector3 toTarget = targetVec - ParentObject.Transform.AbsoluteTransform.Translation;
toTarget.Normalize();
float heading = MathHelper.ToDegrees(MonoMathHelper.GetHeadingFromVector(toTarget.ToVector2XZ()));
heading = (heading + 360) % 360;
player.DesiredHeading = heading;
}
private static void CreateTestArena()
{
float arenaSize = 40f;
ProceduralCuboid a = new ProceduralCuboid(arenaSize, 1, arenaSize / 5);
a.Translate(new Vector3(0, arenaSize / 5, arenaSize));
a.SetColor(Color.LightGray);
ProceduralShape b = a.Clone();
b.Translate(new Vector3(0, 0, -arenaSize * 2));
ProceduralShape c = ProceduralShape.Combine(a, b);
ProceduralShape d = b.Clone();
d.Transform(MonoMathHelper.RotateNinetyDegreesAroundUp(true));
ProceduralShape e = ProceduralShape.Combine(c, d);
var side2 = e.Clone();
var side3 = e.Clone();
var side4 = e.Clone();
e.Translate(new Vector3(-arenaSize * 2, 0, 0));
side2.Transform(MonoMathHelper.RotateHundredEightyDegreesAroundUp(true));
side2.Translate(new Vector3(arenaSize * 2, 0, 0));
side3.Transform(MonoMathHelper.RotateNinetyDegreesAroundUp(true));
side3.Translate(new Vector3(0, 0, arenaSize * 2));
side4.Transform(MonoMathHelper.RotateNinetyDegreesAroundUp(false));
side4.Translate(new Vector3(0, 0, -arenaSize * 2));
var final = ProceduralShape.Combine(e, side2, side3, side4);
var arenaObject = GameObjectFactory.CreateRenderableGameObjectFromShape(final,
EffectLoader.LoadSM5Effect("flatshaded"));
arenaObject.AddComponent(new StaticMeshColliderComponent(arenaObject, final.GetVertices(),
final.GetIndicesAsInt().ToArray(), Vector3.Zero));
arenaObject.AddComponent(new ShadowCasterComponent());
SystemCore.GameObjectManager.AddAndInitialiseGameObject(arenaObject);
}
public void Update(GameTime gameTime)
{
if (Dead)
{
return;
}
PlayerLabel.Text = Name;
PlayerLabel.SetPosition(MonoMathHelper.ScreenProject(Transform.AbsoluteTransform.Translation - Vector3.Forward * 5, SystemCore.Viewport,
SystemCore.ActiveCamera.View,
SystemCore.ActiveCamera.Projection,
Matrix.Identity).ToVector2XY());
}
private void TurnToDesiredHeading()
{
//get current heading
var heading = player.GetHeading();
Vector2 desiredForward = MonoMathHelper.GetVectorFromHeading(MathHelper.ToRadians(player.DesiredHeading - 360));
var lookMatrix = Matrix.CreateWorld(ParentObject.Transform.AbsoluteTransform.Translation,
new Vector3(desiredForward.X, 0, desiredForward.Y), Vector3.Up);
var bepuMatrix = MonoMathHelper.GenerateBepuMatrixFromMono(lookMatrix);
BEPUutilities.Quaternion desiredRot = BEPUutilities.Quaternion.CreateFromRotationMatrix(bepuMatrix);
rotator.TargetOrientation = desiredRot;
}
public void Update(GameTime gameTime, bool inAtmosphere)
{
float thrustToUse = forwardThrustInSpace;
if (inAtmosphere)
{
thrustToUse = forwardThrustInAtmosphere;
}
ShipObject.Transform.AbsoluteTransform = MonoMathHelper.GenerateMonoMatrixFromBepu(PhysicsBody.WorldTransform);
if (IsActive)
{
var currentLeft = PhysicsBody.WorldTransform.Left;
var currentForward = PhysicsBody.WorldTransform.Forward;
var currentUp = PhysicsBody.WorldTransform.Up;
Microsoft.Xna.Framework.Vector2 leftStick = SystemCore.Input.GetLeftStickState(playerIndex);
leftStick.X = -leftStick.X;
Microsoft.Xna.Framework.Vector2 rightStick = SystemCore.Input.GetRightStickState(playerIndex);
float rightTrigger = SystemCore.Input.GetRightTrigger(playerIndex);
if (rightTrigger > 0)
{
PhysicsBody.LinearVelocity += PhysicsBody.WorldTransform.Forward * (rightTrigger * (thrustToUse));
}
float speed = 0.05f;
BEPUutilities.Vector3 left = currentLeft * leftStick.Y * speed;
PhysicsBody.AngularVelocity += currentLeft * leftStick.Y * speed;
PhysicsBody.AngularVelocity += currentUp * leftStick.X * speed;
if (SystemCore.Input.GamePadButtonDown(Buttons.RightShoulder, playerIndex))
{
PhysicsBody.AngularVelocity += currentForward * speed;
}
if (SystemCore.Input.GamePadButtonDown(Buttons.LeftShoulder, playerIndex))
{
PhysicsBody.AngularVelocity -= currentForward * speed;
}
PhysicsBody.LinearVelocity += PhysicsBody.WorldTransform.Up * rightStick.Y;
PhysicsBody.LinearVelocity -= PhysicsBody.WorldTransform.Left * rightStick.X;
}
}
public static ProceduralShape Mirror(ProceduralShape shapeToMirror, Plane mirrorAxis)
{
ProceduralShape newShape = shapeToMirror.Clone();
for (int i = 0; i < shapeToMirror.Vertices.Length; i++)
{
//newShape.Vertices[i].Normal = -shapeToMirror.Vertices[i].Normal;
newShape.Vertices[i].Position = MonoMathHelper.MirrorInPlane(shapeToMirror.Vertices[i].Position,
mirrorAxis);
}
newShape.ReverseIndices();
newShape.FlipNormals();
return(newShape);
}
public void Update(GameTime gameTime, Planet currentPlanet, PlayerIndex playerIndex)
{
float radius = currentPlanet.radius;
Vector3 desiredCameraPos = buggy.BuggyObject.Transform.AbsoluteTransform.Translation;
desiredCameraPos.Normalize();
desiredCameraPos *= (radius + 200f);
CameraObject.Transform.AbsoluteTransform = MonoMathHelper.GenerateWorldMatrixFromPositionAndTarget(desiredCameraPos, buggy.BuggyObject.Transform.AbsoluteTransform.Translation);
Vector3 desiredForward = currentPlanet.Position - buggy.BuggyObject.Transform.AbsoluteTransform.Translation;
desiredForward.Normalize();
Vector3 desiredUp = Vector3.Cross(desiredForward, Vector3.Right);
desiredUp.Normalize();
Vector3 desiredRight = Vector3.Cross(desiredUp, desiredForward);
desiredRight.Normalize();
CameraObject.Transform.RotateAround(desiredUp, buggy.BuggyObject.Transform.AbsoluteTransform.Translation, xTilt);
CameraObject.Transform.RotateAround(desiredRight, buggy.BuggyObject.Transform.AbsoluteTransform.Translation, yTilt);
if (SystemCore.Input.GetRightStickState(playerIndex).X > 0)
{
xTilt += 0.01f;
}
if (SystemCore.Input.GetRightStickState(playerIndex).X < 0)
{
xTilt -= 0.01f;
}
if (SystemCore.Input.GetRightStickState(playerIndex).Y > 0)
{
yTilt += 0.01f;
}
if (SystemCore.Input.GetRightStickState(playerIndex).Y < 0)
{
yTilt -= 0.01f;
}
}
public void Update(GameTime gameTime)
{
if (e.DesiredPosiiton != e.Transform.AbsoluteTransform.Translation)
{
mover.TargetPosition = e.DesiredPosiiton.ToBepuVector();
Vector3 newForward = e.DesiredPosiiton - e.Transform.AbsoluteTransform.Translation;
newForward.Normalize();
Vector3 newRight = Vector3.Cross(newForward, Vector3.Up);
Vector3 newUp = Vector3.Cross(newRight, newForward);
var lookMatrix = Matrix.CreateWorld(ParentObject.Transform.AbsoluteTransform.Translation, newForward, newUp);
var bepuMatrix = MonoMathHelper.GenerateBepuMatrixFromMono(lookMatrix);
BEPUutilities.Quaternion desiredRot = BEPUutilities.Quaternion.CreateFromRotationMatrix(bepuMatrix);
rotator.TargetOrientation = desiredRot;
}
}
internal float DistanceFromClosestWall(Vector3 p)
{
float closest = float.MaxValue;
foreach (Bucket b in buckets)
{
List <IPartitionItem> linesInBucket = b.itemsInBucket.FindAll(x => x.Type == "DoomLine");
foreach (DoomLine line in linesInBucket)
{
float dist = MonoMathHelper.DistanceLineSegmentToPoint(line.start.ToVector2XZ(), line.end.ToVector2XZ(), p.ToVector2XZ());
if (dist < closest)
{
closest = dist;
}
}
}
return(closest);
}
private bool CrossesHazardLine(NavigationNode current, NavigationNode adjacent)
{
if (mapHandler == null)
{
return(false);
}
foreach (DoomLine hazardLine in mapHandler.HazardLines)
{
if (MonoMathHelper.LineIntersection(current.WorldPosition.ToVector2XZ(), adjacent.WorldPosition.ToVector2XZ(),
hazardLine.start.ToVector2XZ(), hazardLine.end.ToVector2XZ()))
{
return(true);
}
}
return(false);
}
private void RequestHitVectorData()
{
if (playerObj == null)
{
return;
}
DoomComponent playerDoomComponent = playerObj.GetComponent <DoomComponent>();
Vector3 forwardVec = playerObj.Transform.AbsoluteTransform.Translation
+ playerObj.Transform.AbsoluteTransform.Forward * playerDoomComponent.HitVectorSize;
Vector3 rightVec = MonoMathHelper.RotateAroundPoint(forwardVec, playerObj.Transform.AbsoluteTransform.Translation, Vector3.Up, MathHelper.PiOver4);
Vector3 leftVec = MonoMathHelper.RotateAroundPoint(forwardVec, playerObj.Transform.AbsoluteTransform.Translation, Vector3.Up, -MathHelper.PiOver4);
forwardVec *= scale;
leftVec *= scale;
rightVec *= scale;
string paramString = "id=" + playerObj.ID + "&x=" + forwardVec.X + "&y=" + forwardVec.Z;
string paramStringLeft = "id=" + playerObj.ID + "&x=" + leftVec.X + "&y=" + leftVec.Z;
string paramStringRight = "id=" + playerObj.ID + "&x=" + rightVec.X + "&y=" + rightVec.Z;
if (requestVec == 0)
{
apiHandler.EnqueueRequest(false, "leftHitVec", new RestRequest("world/movetest?" + paramStringLeft));
requestVec++;
}
if (requestVec == 1)
{
apiHandler.EnqueueRequest(false, "rightHitVec", new RestRequest("world/movetest?" + paramStringRight));
requestVec++;
}
if (requestVec == 2)
{
apiHandler.EnqueueRequest(false, "forwardHitVec", new RestRequest("world/movetest?" + paramString));
requestVec = 0;
timeOfLastHitVectorUpdate = DateTime.Now;
}
}
//Determines whether an edge is shared by a neighbouring patch.
private bool SharesTwoCorners(Vector3 cornerA, Vector3 cornerB, Vector3 thisMin, Vector3 thisMax, Vector3 thisNormal, float thisStep)
{
//calculate info about this neighbour patch.
Vector3 se1, sw1, mid11, mid21, nw1, ne1, midBottom1, midRight1, midLeft1, midTop1;
CalculatePatchBoundaries(thisNormal, thisStep, thisMin, thisMax, out se1, out sw1, out mid11, out mid21, out nw1, out ne1, out midBottom1, out midRight1, out midLeft1, out midTop1);
List <Vector3> first = new List <Vector3>();
first.Add(cornerA);
first.Add(cornerB);
List <Vector3> second = new List <Vector3>();
second.Add(se1);
second.Add(sw1);
second.Add(nw1);
second.Add(ne1);
second.Add(midBottom1);
second.Add(midRight1);
second.Add(midLeft1);
second.Add(midTop1);
int match = 0;
foreach (Vector3 corner in first)
{
foreach (Vector3 neighbourVec in second)
{
if (MonoMathHelper.Vector3ComponentAlmostEquals(corner, neighbourVec, step / 2))
{
match++;
}
}
}
if (match == 2)
{
return(true);
}
return(false);
}
public bool LineIntersects(Vector3 a, Vector3 b)
{
if (MonoMathHelper.LineIntersection(a.ToVector2XZ(), b.ToVector2XZ(), topLeft.ToVector2XZ(), topRight.ToVector2XZ()))
{
return(true);
}
if (MonoMathHelper.LineIntersection(a.ToVector2XZ(), b.ToVector2XZ(), topLeft.ToVector2XZ(), bottomLeft.ToVector2XZ()))
{
return(true);
}
if (MonoMathHelper.LineIntersection(a.ToVector2XZ(), b.ToVector2XZ(), bottomLeft.ToVector2XZ(), bottomRight.ToVector2XZ()))
{
return(true);
}
if (MonoMathHelper.LineIntersection(a.ToVector2XZ(), b.ToVector2XZ(), bottomRight.ToVector2XZ(), topRight.ToVector2XZ()))
{
return(true);
}
return(false);
}
/// <summary>
/// Builds a composite shape composed of a cylinder and two spheres.
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="width"></param>
/// <returns></returns>
public static ProceduralShape Capsule(Vector3 start, Vector3 end, float width)
{
ProceduralSphereTwo s = new ProceduralSphereTwo(20);
ProceduralSphereTwo e = new ProceduralSphereTwo(20);
s.Scale(width);
e.Scale(width);
Vector3 translation = Vector3.Zero - ((start + end) / 2);
//untranslated cylinder will have a centroid at zero, a bottom point at (0,-length/2,0) and a top point at (0,length/2,0).
// we want to find the transform that takes these points to our desired start + end.
Vector3 length = start - end;
float l = length.Length();
Vector3 oldBottom = new Vector3(0, -l / 2, 0);
Vector3 oldTop = new Vector3(0, l / 2, 0);
s.Translate(oldBottom);
e.Translate(oldTop);
Vector3 oldLength = oldBottom - oldTop;
Vector3 crossAxis = Vector3.Cross(Vector3.Normalize(oldLength), Vector3.Normalize(length));
ProceduralCylinder cylinder = new ProceduralCylinder(width, width, l, 20, 2);
var finalShape = ProceduralShape.Combine(cylinder, s, e);
if (crossAxis != Vector3.Zero)
{
float angleOfRotation = (float)MonoMathHelper.GetSignedAngleBetween2DVectors(oldLength, length);
Matrix rotation = Matrix.CreateFromAxisAngle(Vector3.Normalize(crossAxis), angleOfRotation);
finalShape.Transform(rotation);
}
finalShape.Translate(-translation);
return(finalShape);
}
public void Rotate(Vector3 axis, float amount)
{
if (ParentObject.ParentGameObject == null)
{
Vector3 pos = AbsoluteTransform.Translation;
AbsoluteTransform.Translation = Vector3.Zero;
AbsoluteTransform = AbsoluteTransform *= Matrix.CreateFromAxisAngle(axis, amount);
AbsoluteTransform.Translation = pos;
}
else
{
Vector3 pos = RelativeTransform.Translation;
RelativeTransform.Translation = Vector3.Zero;
RelativeTransform = RelativeTransform *= Matrix.CreateFromAxisAngle(axis, amount);
RelativeTransform.Translation = pos;
}
if (ParentObject.ContainsComponent <PhysicsComponent>())
{
Entity physicsentity = ParentObject.GetComponent <PhysicsComponent>().PhysicsEntity;
physicsentity.WorldTransform = MonoMathHelper.GenerateBepuMatrixFromMono(ParentObject.Transform.AbsoluteTransform);
}
}
public static Vector3 Unproject(Vector3 inWorldPoint)
{
return(MonoMathHelper.ScreenProject(inWorldPoint, SystemCore.Viewport, SystemCore.ActiveCamera.View, SystemCore.ActiveCamera.Projection, Matrix.Identity));
}
public void Update(GameTime gameTime)
{
BuggyObject.Transform.AbsoluteTransform = MonoMathHelper.GenerateMonoMatrixFromBepu(vehicle.Body.WorldTransform);
for (int i = 0; i < vehicle.Wheels.Count; i++)
{
Wheel w = vehicle.Wheels[i];
wheels[i].Transform.AbsoluteTransform = MonoMathHelper.GenerateMonoMatrixFromBepu(w.Shape.WorldTransform);
var particleSystem = wheels[i].GetComponent <SquareParticleSystem>();
if (w.HasSupport)
{
if (particleSystem != null && (w.DrivingMotor.TargetSpeed == ForwardSpeed || w.DrivingMotor.TargetSpeed == BackwardSpeed))
{
particleSystem.AddParticle(wheels[i].Transform.AbsoluteTransform.Translation, Microsoft.Xna.Framework.Vector3.Zero);
}
}
}
if (!IsActive)
{
return;
}
if (SystemCore.Input.IsKeyDown(Keys.E) || SystemCore.Input.GamePadButtonDown(Buttons.RightTrigger, playerIndex))
{
//Drive
vehicle.Wheels[1].DrivingMotor.TargetSpeed = ForwardSpeed;
vehicle.Wheels[3].DrivingMotor.TargetSpeed = ForwardSpeed;
vehicle.Wheels[2].DrivingMotor.TargetSpeed = ForwardSpeed;
vehicle.Wheels[0].DrivingMotor.TargetSpeed = ForwardSpeed;
}
else if (SystemCore.Input.IsKeyDown(Keys.D) || SystemCore.Input.GamePadButtonDown(Buttons.LeftTrigger, playerIndex))
{
//Reverse
vehicle.Wheels[1].DrivingMotor.TargetSpeed = BackwardSpeed;
vehicle.Wheels[3].DrivingMotor.TargetSpeed = BackwardSpeed;
vehicle.Wheels[2].DrivingMotor.TargetSpeed = BackwardSpeed;
vehicle.Wheels[0].DrivingMotor.TargetSpeed = BackwardSpeed;
}
else
{
//Idle
vehicle.Wheels[1].DrivingMotor.TargetSpeed = 0;
vehicle.Wheels[3].DrivingMotor.TargetSpeed = 0;
vehicle.Wheels[2].DrivingMotor.TargetSpeed = 0;
vehicle.Wheels[0].DrivingMotor.TargetSpeed = 0;
}
if (SystemCore.Input.IsKeyDown(Keys.Space))
{
//Brake
foreach (Wheel wheel in vehicle.Wheels)
{
wheel.Brake.IsBraking = true;
}
}
else
{
//Release brake
foreach (Wheel wheel in vehicle.Wheels)
{
wheel.Brake.IsBraking = false;
}
}
//Use smooth steering; while held down, move towards maximum.
//When not pressing any buttons, smoothly return to facing forward.
float angle;
bool steered = false;
if (SystemCore.Input.IsKeyDown(Keys.S) || SystemCore.Input.GetLeftStickState(playerIndex).X < 0)
{
steered = true;
angle = Math.Max(vehicle.Wheels[1].Shape.SteeringAngle - TurnSpeed * (float)gameTime.ElapsedGameTime.TotalSeconds, -MaximumTurnAngle);
vehicle.Wheels[1].Shape.SteeringAngle = angle;
vehicle.Wheels[3].Shape.SteeringAngle = angle;
}
if (SystemCore.Input.IsKeyDown(Keys.F) || SystemCore.Input.GetLeftStickState(playerIndex).X > 0)
{
steered = true;
angle = Math.Min(vehicle.Wheels[1].Shape.SteeringAngle + TurnSpeed * (float)gameTime.ElapsedGameTime.TotalSeconds, MaximumTurnAngle);
vehicle.Wheels[1].Shape.SteeringAngle = angle;
vehicle.Wheels[3].Shape.SteeringAngle = angle;
}
if (!steered)
{
//Neither key was pressed, so de-steer.
if (vehicle.Wheels[1].Shape.SteeringAngle > 0)
{
angle = Math.Max(vehicle.Wheels[1].Shape.SteeringAngle - TurnSpeed * (float)gameTime.ElapsedGameTime.TotalSeconds, 0);
vehicle.Wheels[1].Shape.SteeringAngle = angle;
vehicle.Wheels[3].Shape.SteeringAngle = angle;
}
else
{
angle = Math.Min(vehicle.Wheels[1].Shape.SteeringAngle + TurnSpeed * (float)gameTime.ElapsedGameTime.TotalSeconds, 0);
vehicle.Wheels[1].Shape.SteeringAngle = angle;
vehicle.Wheels[3].Shape.SteeringAngle = angle;
}
}
}
private void UpdateVehicle(float dt)
{
if (vehicleObject != null)
{
vehicleObject.Transform.AbsoluteTransform = MonoMathHelper.GenerateMonoMatrixFromBepu(testVehicle.Body.WorldTransform);
wheel1.Transform.AbsoluteTransform = MonoMathHelper.GenerateMonoMatrixFromBepu(testVehicle.Wheels[0].Shape.WorldTransform);
if (input.IsKeyDown(Keys.E))
{
//Drive
testVehicle.Wheels[1].DrivingMotor.TargetSpeed = ForwardSpeed;
testVehicle.Wheels[3].DrivingMotor.TargetSpeed = ForwardSpeed;
}
else if (input.IsKeyDown(Keys.D))
{
//Reverse
testVehicle.Wheels[1].DrivingMotor.TargetSpeed = BackwardSpeed;
testVehicle.Wheels[3].DrivingMotor.TargetSpeed = BackwardSpeed;
}
else
{
//Idle
testVehicle.Wheels[1].DrivingMotor.TargetSpeed = 0;
testVehicle.Wheels[3].DrivingMotor.TargetSpeed = 0;
}
if (input.IsKeyDown(Keys.Space))
{
//Brake
foreach (Wheel wheel in testVehicle.Wheels)
{
wheel.Brake.IsBraking = true;
}
}
else
{
//Release brake
foreach (Wheel wheel in testVehicle.Wheels)
{
wheel.Brake.IsBraking = false;
}
}
//Use smooth steering; while held down, move towards maximum.
//When not pressing any buttons, smoothly return to facing forward.
float angle;
bool steered = false;
if (input.IsKeyDown(Keys.S))
{
steered = true;
angle = Math.Max(testVehicle.Wheels[1].Shape.SteeringAngle - TurnSpeed * dt, -MaximumTurnAngle);
testVehicle.Wheels[1].Shape.SteeringAngle = angle;
testVehicle.Wheels[3].Shape.SteeringAngle = angle;
}
if (input.IsKeyDown(Keys.F))
{
steered = true;
angle = Math.Min(testVehicle.Wheels[1].Shape.SteeringAngle + TurnSpeed * dt, MaximumTurnAngle);
testVehicle.Wheels[1].Shape.SteeringAngle = angle;
testVehicle.Wheels[3].Shape.SteeringAngle = angle;
}
if (!steered)
{
//Neither key was pressed, so de-steer.
if (testVehicle.Wheels[1].Shape.SteeringAngle > 0)
{
angle = Math.Max(testVehicle.Wheels[1].Shape.SteeringAngle - TurnSpeed * dt, 0);
testVehicle.Wheels[1].Shape.SteeringAngle = angle;
testVehicle.Wheels[3].Shape.SteeringAngle = angle;
}
else
{
angle = Math.Min(testVehicle.Wheels[1].Shape.SteeringAngle + TurnSpeed * dt, 0);
testVehicle.Wheels[1].Shape.SteeringAngle = angle;
testVehicle.Wheels[3].Shape.SteeringAngle = angle;
}
}
}
}
