Code: Select all
gravField = new GravitationalField(
localSettings.ForceFieldShape.Load(game, this),
localSettings.Position,
localSettings.GravitationalFieldStrength,
30
);
Code: Select all
gravField.Multiplier = 10;
Code: Select all
space.ForceUpdater.Gravity = new Vector3(0, -10, 0);Code: Select all
Vector3 r = e.Position - Origin;
float length = r.Length();
if (length > Toolbox.BigEpsilon)
{
float force = dt * e.Mass * Math.Min(MaxAcceleration, Multiplier / (length * length));
impulse = -(force / length) * r; //Extra division by length normalizes the direction.
}
else
impulse = new Vector3();Code: Select all
Vector3 r = e.Position - Origin;
r.Normalize();
impulse = r * (GravitationalAcceleration * e.Mass * dt);Code: Select all
protected abstract void CalculateImpulse
Code: Select all
protected override void CalculateImpulse(Entity e, float dt, out Vector3 impulse)
{
switch (AccelerationType)
{
case GravitationalFieldAcceleration.Constant:
{
Vector3 r = e.Position - Origin;
r.Normalize();
impulse = r * (-Multiplier * e.Mass * dt);
break;
}
case GravitationalFieldAcceleration.InverseSquare:
{
// Inverse square dropoff
Vector3 r = e.Position - Origin;
float length = r.Length();
if (length > Toolbox.BigEpsilon)
{
float force = dt * e.Mass * Math.Min(MaxAcceleration, Multiplier / (length * length));
impulse = -(force / length) * r; //Extra division by length normalizes the direction.
}
else
{
impulse = Vector3.Zero;
}
break;
}
case GravitationalFieldAcceleration.Linear:
{
// Could use a linear dropoff for a slightly faster calculation (divide by length^2 instead of length^3).
Vector3 r = e.Position - Origin;
float length = r.Length();
if (length > Toolbox.BigEpsilon)
{
float force = dt * e.Mass * Math.Min(MaxAcceleration, Multiplier / length);
//Extra division by length normalizes the direction
impulse = -(force / length) * r;
}
else
{
impulse = Vector3.Zero;
}
break;
}
default: impulse = Vector3.Zero; break;
}
}
Code: Select all
using BEPUphysics;
using BEPUphysics.Entities;
using BEPUphysics.Entities.Prefabs;
using BEPUphysics.UpdateableSystems.ForceFields;
using BEPUphysicsDemos.SampleCode;
using Microsoft.Xna.Framework;
using System.Collections.Generic;
using BEPUphysics.NarrowPhaseSystems;
namespace BEPUphysicsDemos.Demos
{
/// <summary>
/// Boxes fall on a planetoid.
/// </summary>
public class PlanetDemo : StandardDemo
{
private Space secondSpace;
/// <summary>
/// Constructs a new demo.
/// </summary>
/// <param name="game">Game owning this demo.</param>
public PlanetDemo(DemosGame game)
: base(game)
{
Space.ForceUpdater.Gravity = Vector3.Zero;
//By pre-allocating a bunch of box-box pair handlers, the simulation will avoid having to allocate new ones at runtime.
NarrowPhaseHelper.Factories.BoxBox.EnsureCount(1000);
//Set up the first simulation.
Entity planet = new Box(new Vector3(0, 0, 0), 100, 5, 100);
Space.Add(planet);
//The first simulation uses a gravity field which emulates Space.ForceUpdater.Gravity.
var field = new ConstantLinearGravityField(new InfiniteForceFieldShape(), 9.81f);
Space.Add(field);
//Drop the "meteorites" on the planet.
Entity toAdd;
int numColumns = 10;
int numRows = 10;
int numHigh = 10;
float separation = 5;
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numColumns; j++)
for (int k = 0; k < numHigh; k++)
{
toAdd = new Box(new Vector3(separation * i - numRows * separation / 2, 40 + k * separation, separation * j - numColumns * separation / 2), 1f, 1f, 1f, 5);
//toAdd.LinearVelocity = new Vector3(30, 0, 0);
toAdd.LinearDamping = 0;
toAdd.AngularDamping = 0;
Space.Add(toAdd);
}
//Set up the identical second parallel simulation.
secondSpace = new Space(Space.ThreadManager);
planet = new Box(new Vector3(0, 0, 0), 100, 5, 100);
secondSpace.Add(planet);
//The second simulation uses regular old gravity.
secondSpace.ForceUpdater.Gravity = new Vector3(0, -9.81f, 0);
//Drop the "meteorites" on the planet.
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numColumns; j++)
for (int k = 0; k < numHigh; k++)
{
toAdd = new Box(new Vector3(separation * i - numRows * separation / 2, 40 + k * separation, separation * j - numColumns * separation / 2), 1f, 1f, 1f, 5);
//toAdd.LinearVelocity = new Vector3(30, 0, 0);
toAdd.LinearDamping = 0;
toAdd.AngularDamping = 0;
secondSpace.Add(toAdd);
game.ModelDrawer.Add(toAdd);
}
game.Camera.Position = new Vector3(0, 0, 150);
}
public override void Update(float dt)
{
//Note that we are only moving forward by one time step. This is consistent with the Space.Update() call that the parent implementation will call.
secondSpace.Update();
base.Update(dt);
}
/// <summary>
/// Gets the name of the simulation.
/// </summary>
public override string Name
{
get { return "Planet"; }
}
}
}
Code: Select all
using System;
using BEPUphysics.BroadPhaseSystems;
using BEPUphysics.Entities;
using BEPUphysics.UpdateableSystems.ForceFields;
using Microsoft.Xna.Framework;
using BEPUphysics;
namespace BEPUphysicsDemos.SampleCode
{
/// <summary>
/// Applies a constant vertical linear impulse on all entities.
/// </summary>
public class ConstantLinearGravityField : ForceField
{
/// <summary>
/// Creates a gravitational field.
/// </summary>
/// <param name="shape">Shape representing the volume of the force field.</param>
/// <param name="acceleration">Acceleration the field applies.</param>
public ConstantLinearGravityField(ForceFieldShape shape, float acceleration)
: base(shape)
{
this.Acceleration = acceleration;
}
/// <summary>
/// Gets or sets the gravitational constant of the field times the effective mass at the center of the field.
/// </summary>
public float Acceleration { get; set; }
/// <summary>
/// Calculates the gravitational force to apply to the entity.
/// </summary>
/// <param name="e">Target of the impulse.</param>
/// <param name="dt">Time since the last frame in simulation seconds.</param>
/// <param name="impulse">Force to apply at the given position.</param>
protected override void CalculateImpulse(Entity e, float dt, out Vector3 impulse)
{
impulse = (-dt * e.Mass * Acceleration) * Vector3.Up;
}
}
}