protected Demo(DemosGame game)
{
Game = game;
parallelLooper = new ParallelLooper();
//This section lets the engine know that it can make use of multithreaded systems
//by adding threads to its thread pool.
#if XBOX360
parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 1 }); });
parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 3 }); });
parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 4 }); });
parallelLooper.AddThread(delegate { Thread.CurrentThread.SetProcessorAffinity(new[] { 5 }); });
#else
if (Environment.ProcessorCount > 1)
{
for (int i = 0; i < Environment.ProcessorCount; i++)
{
parallelLooper.AddThread();
}
}
#endif
Space = new Space(parallelLooper);
game.Camera.LockedUp = Vector3.Up;
game.Camera.ViewDirection = new Vector3(0, 0, -1);
}
public FixedOffsetCameraControlScheme(Entity entity, Camera camera, DemosGame game)
: base(camera, game)
{
Entity = entity;
UseCameraSmoothing = true;
CameraOffset = new Vector3(0, 0.7f, 0);
}
/// <summary>
/// Constructs the character and internal physics character controller.
/// </summary>
/// <param name="owningSpace">Space to add the character to.</param>
/// <param name="camera">Camera to attach to the character.</param>
/// <param name="game">The running game.</param>
public SphereCharacterControllerInput(Space owningSpace, Camera camera, DemosGame game)
{
CharacterController = new SphereCharacterController();
Camera = camera;
CameraControlScheme = new FixedOffsetCameraControlScheme(CharacterController.Body, camera, game);
Space = owningSpace;
}
/// <summary>
/// Constructs the character and internal physics character controller.
/// </summary>
/// <param name="owningSpace">Space to add the character to.</param>
/// <param name="camera">Camera to attach to the character.</param>
/// <param name="game">The running game.</param>
public CharacterControllerInput(Space owningSpace, Camera camera, DemosGame game)
{
CharacterController = new CharacterController();
Camera = camera;
CameraControlScheme = new CharacterCameraControlScheme(CharacterController, camera, game);
Space = owningSpace;
}
public StandardDemo(DemosGame game)
: base(game)
{
freeCameraControlScheme = new FreeCameraControlScheme(10, game.Camera, game);
//Creates the player character (C).
character = new CharacterControllerInput(Space, game.Camera, game);
//Creates the drivable vehicle (V).
var wheelModel = game.Content.Load <Model>("carWheel");
var wheelTexture = game.Content.Load <Texture2D>("wheel");
whitePixel = game.Content.Load <Texture2D>("whitePixel");
vehicle = new VehicleInput(new Vector3(10000, 0, 0), Space, game.Camera, game, game.ModelDrawer, wheelModel, wheelTexture);
Space.ForceUpdater.Gravity = new Vector3(0, -9.81f, 0f); //If left unset, the default value is (0,0,0).
//Create the tossable ball.
kapow = new Sphere(new Vector3(11000, 0, 0), .6f, 20);
kapowMaker = new Explosion(Vector3.Zero, 400, 15, Space);
//Create the right-click grab spring.
grabber = new MotorizedGrabSpring();
grabberGraphic = game.ConstraintDrawer.Add(grabber);
grabberGraphic.IsDrawing = false;
Space.Add(grabber);
Space.Add(kapow);
//IMPORTANT PERFORMANCE NOTE:
// BEPUphysics uses an iterative system to solve constraints. You can tell it to do more or less iterations.
// Less iterations is faster; more iterations makes the result more accurate.
//
// The amount of iterations needed for a simulation varies. The "Wall" and "Pyramid" simulations are each fairly
// solver intensive, but as few as 4 iterations can be used with acceptable results.
// The "Jenga" simulation usually needs a few more iterations for stability; 7-9 is a good minimum.
//
// The Dogbot demo shows how accuracy can smoothly increase with more iterations.
// With very few iterations (1-3), it has slightly jaggier movement, as if the parts used to construct it were a little cheap.
// As you give it a few more iterations, the motors and constraints get more and more robust.
//
// Many simulations can work perfectly fine with very few iterations,
// and using a low number of iterations can substantially improve performance.
//
// To change the number of iterations used, uncomment and change the following line (10 iterations is the default):
//Space.Solver.IterationLimit = 10;
rayCastFilter = RayCastFilter;
}
/// <summary>
/// Constructs the front end and the internal physics representation of the Vehicle.
/// </summary>
/// <param name="position">Position of the Vehicle.</param>
/// <param name="space">Space to add the Vehicle to.</param>
/// <param name="camera">Camera to attach to the Vehicle.</param>
/// <param name="game">The running game.</param>
/// <param name="drawer">Drawer used to draw the Vehicle.</param>
/// <param name="wheelModel">Model of the wheels.</param>
/// <param name="wheelTexture">Texture to use for the wheels.</param>
public VehicleInput(Vector3 position, Space space, Camera camera, DemosGame game, ModelDrawer drawer, Microsoft.Xna.Framework.Graphics.Model wheelModel, Microsoft.Xna.Framework.Graphics.Texture2D wheelTexture)
{
var bodies = new List <CompoundShapeEntry>
{
new CompoundShapeEntry(new BoxShape(2.5f, .75f, 4.5f), new Vector3(0, 0, 0), 60),
new CompoundShapeEntry(new BoxShape(2.5f, .3f, 2f), new Vector3(0, .75f / 2 + .3f / 2, .5f), 1)
};
var body = new CompoundBody(bodies, 61);
body.CollisionInformation.LocalPosition = new Vector3(0, .5f, 0);
body.Position = position; //At first, just keep it out of the way.
Vehicle = new Vehicle(body);
var localWheelRotation = Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2);
//The wheel model used is not aligned initially with how a wheel would normally look, so rotate them.
Matrix wheelGraphicRotation = Matrix.CreateFromAxisAngle(Vector3.Forward, MathHelper.PiOver2);
Vehicle.AddWheel(new Wheel(
new CylinderCastWheelShape(.375f, 0.2f, localWheelRotation, wheelGraphicRotation, false),
new WheelSuspension(2000, 100f, Vector3.Down, 0.325f, new Vector3(-1.1f, -0.1f, 1.8f)),
new WheelDrivingMotor(2.5f, 30000, 10000),
new WheelBrake(1.5f, 2, .02f),
new WheelSlidingFriction(4, 5)));
Vehicle.AddWheel(new Wheel(
new CylinderCastWheelShape(.375f, 0.2f, localWheelRotation, wheelGraphicRotation, false),
new WheelSuspension(2000, 100f, Vector3.Down, 0.325f, new Vector3(-1.1f, -0.1f, -1.8f)),
new WheelDrivingMotor(2.5f, 30000, 10000),
new WheelBrake(1.5f, 2, .02f),
new WheelSlidingFriction(4, 5)));
Vehicle.AddWheel(new Wheel(
new CylinderCastWheelShape(.375f, 0.2f, localWheelRotation, wheelGraphicRotation, false),
new WheelSuspension(2000, 100f, Vector3.Down, 0.325f, new Vector3(1.1f, -0.1f, 1.8f)),
new WheelDrivingMotor(2.5f, 30000, 10000),
new WheelBrake(1.5f, 2, .02f),
new WheelSlidingFriction(4, 5)));
Vehicle.AddWheel(new Wheel(
new CylinderCastWheelShape(.375f, 0.2f, localWheelRotation, wheelGraphicRotation, false),
new WheelSuspension(2000, 100f, Vector3.Down, 0.325f, new Vector3(1.1f, -0.1f, -1.8f)),
new WheelDrivingMotor(2.5f, 30000, 10000),
new WheelBrake(1.5f, 2, .02f),
new WheelSlidingFriction(4, 5)));
foreach (Wheel wheel in Vehicle.Wheels)
{
//This is a cosmetic setting that makes it looks like the car doesn't have antilock brakes.
wheel.Shape.FreezeWheelsWhileBraking = true;
//By default, wheels use as many iterations as the space. By lowering it,
//performance can be improved at the cost of a little accuracy.
//However, because the suspension and friction are not really rigid,
//the lowered accuracy is not so much of a problem.
wheel.Suspension.SolverSettings.MaximumIterationCount = 1;
wheel.Brake.SolverSettings.MaximumIterationCount = 1;
wheel.SlidingFriction.SolverSettings.MaximumIterationCount = 1;
wheel.DrivingMotor.SolverSettings.MaximumIterationCount = 1;
}
Space = space;
Space.Add(Vehicle);
ModelDrawer = drawer;
DisplayModel model;
WheelModels = new List <DisplayModel>();
for (int k = 0; k < 4; k++)
{
Vehicle.Wheels[k].Shape.Detector.Tag = "noDisplayObject";
model = new DisplayModel(wheelModel, ModelDrawer);
ModelDrawer.Add(model);
WheelModels.Add(model);
model.Texture = wheelTexture;
}
CameraControlScheme = new ChaseCameraControlScheme(Vehicle.Body, new Vector3(0, 0.6f, 0), true, 10, camera, game);
}
public FreeCameraControlScheme(float speed, Camera camera, DemosGame game)
: base(camera, game)
{
Speed = speed;
}
/// <summary>
/// Sets up all the information required by the chase camera.
/// </summary>
/// <param name="chasedEntity">Target to follow.</param>
/// <param name="offsetFromChaseTarget">Offset from the center of the entity target to point at.</param>
/// <param name="transformOffset">Whether or not to transform the offset with the target entity's rotation.</param>
/// <param name="distanceToTarget">Distance from the target position to try to maintain.</param>
/// <param name="camera">Camera controlled by the scheme.</param>
/// <param name="game">Running game.</param>
public ChaseCameraControlScheme(Entity chasedEntity, Vector3 offsetFromChaseTarget, bool transformOffset, float distanceToTarget, Camera camera, DemosGame game)
: base(camera, game)
{
ChasedEntity = chasedEntity;
OffsetFromChaseTarget = offsetFromChaseTarget;
TransformOffset = transformOffset;
DistanceToTarget = distanceToTarget;
ChaseCameraMargin = 1;
rayCastFilter = RayCastFilter;
}
/// <summary>
/// Constructs the front end and the internal physics representation of the vehicle.
/// </summary>
/// <param name="position">Position of the tank.</param>
/// <param name="owningSpace">Space to add the vehicle to.</param>
/// <param name="camera">Camera to attach to the vehicle.</param>
/// <param name="game">Running game.</param>
/// <param name="drawer">Drawer used to draw the tank.</param>
/// <param name="wheelModel">Model to use for the 'wheels' of the tank.</param>
/// <param name="wheelTexture">Texture of the wheels on the tank.</param>
public TankInput(Vector3 position, Space owningSpace, Camera camera, DemosGame game, ModelDrawer drawer, Model wheelModel, Texture2D wheelTexture)
{
var bodies = new List <CompoundShapeEntry>()
{
new CompoundShapeEntry(new BoxShape(4f, 1, 8), new Vector3(0, 0, 0), 500),
new CompoundShapeEntry(new BoxShape(3, .7f, 4f), new Vector3(0, .5f + .35f, .5f), 1)
};
var body = new CompoundBody(bodies, 501);
body.CollisionInformation.LocalPosition = new Vector3(0, .5f, 0);
body.Position = (position); //At first, just keep it out of the way.
Vehicle = new Vehicle(body);
#region RaycastWheelShapes
//The wheel model used is not aligned initially with how a wheel would normally look, so rotate them.
MaximumDriveForce = 1800;
BaseSlidingFriction = 3;
Matrix wheelGraphicRotation = Matrix.CreateFromAxisAngle(Vector3.Forward, MathHelper.PiOver2);
for (int i = 0; i < 6; i++)
{
var toAdd = new Wheel(
new RaycastWheelShape(.375f, wheelGraphicRotation),
new WheelSuspension(2000, 300f, Vector3.Down, 1.3f, new Vector3(-1.9f, 0, -2.9f + i * 1.15f)),
new WheelDrivingMotor(10, MaximumDriveForce, MaximumDriveForce),
new WheelBrake(7, 7, 1.0f),
new WheelSlidingFriction(BaseSlidingFriction, BaseSlidingFriction));
toAdd.DrivingMotor.GripFrictionBlender = FrictionBlender;
toAdd.Brake.FrictionBlender = FrictionBlender;
toAdd.SlidingFriction.FrictionBlender = FrictionBlender;
Vehicle.AddWheel(toAdd);
leftTrack.Add(toAdd);
}
for (int i = 0; i < 6; i++)
{
var toAdd = new Wheel(
new RaycastWheelShape(.375f, wheelGraphicRotation),
new WheelSuspension(2000, 300f, Vector3.Down, 1.3f, new Vector3(1.9f, 0, -2.9f + i * 1.15f)),
new WheelDrivingMotor(10, 2000, 1000),
new WheelBrake(7, 7, 1.0f),
new WheelSlidingFriction(BaseSlidingFriction, BaseSlidingFriction));
toAdd.DrivingMotor.GripFrictionBlender = FrictionBlender;
toAdd.Brake.FrictionBlender = FrictionBlender;
toAdd.SlidingFriction.FrictionBlender = FrictionBlender;
Vehicle.AddWheel(toAdd);
rightTrack.Add(toAdd);
}
#endregion
foreach (Wheel wheel in Vehicle.Wheels)
{
//This is a cosmetic setting that makes it looks like the car doesn't have antilock brakes.
wheel.Shape.FreezeWheelsWhileBraking = true;
//By default, wheels use as many iterations as the space. By lowering it,
//performance can be improved at the cost of a little accuracy.
wheel.Suspension.SolverSettings.MaximumIterationCount = 1;
wheel.Brake.SolverSettings.MaximumIterationCount = 1;
wheel.SlidingFriction.SolverSettings.MaximumIterationCount = 1;
wheel.DrivingMotor.SolverSettings.MaximumIterationCount = 1;
}
Space = owningSpace;
Space.Add(Vehicle);
ModelDrawer = drawer;
DisplayModel model;
WheelModels = new List <DisplayModel>();
for (int k = 0; k < Vehicle.Wheels.Count; k++)
{
Vehicle.Wheels[k].Shape.Detector.Tag = "noDisplayObject";
model = new DisplayModel(wheelModel, ModelDrawer);
ModelDrawer.Add(model);
WheelModels.Add(model);
model.Texture = wheelTexture;
}
CameraControlScheme = new ChaseCameraControlScheme(Vehicle.Body, new Vector3(0, 0.6f, 0), true, 10, camera, game);
}
protected CameraControlScheme(Camera camera, DemosGame game)
{
Camera = camera;
Game = game;
}
public CharacterCameraControlScheme(CharacterController character, Camera camera, DemosGame game)
: base(camera, game)
{
Character = character;
UseCameraSmoothing = true;
StandingCameraOffset = 0.7f;
CrouchingCameraOffset = 0.4f;
ProneCameraOffset = 0.1f;
}
