public void Draw(Effect effect, Space space)
{
contactLines.Clear();
int contactCount = 0;
foreach (var pair in space.NarrowPhase.Pairs)
{
var pairHandler = pair as CollidablePairHandler;
if (pairHandler != null)
{
foreach (ContactInformation information in pairHandler.Contacts)
{
contactCount++;
contactLines.Add(new VertexPositionColor(MathConverter.Convert(information.Contact.Position), Color.White));
contactLines.Add(new VertexPositionColor(MathConverter.Convert(information.Contact.Position + information.Contact.Normal * information.Contact.PenetrationDepth), Color.Red));
contactLines.Add(new VertexPositionColor(MathConverter.Convert(information.Contact.Position + information.Contact.Normal * information.Contact.PenetrationDepth), Color.White));
contactLines.Add(new VertexPositionColor(MathConverter.Convert(information.Contact.Position + information.Contact.Normal * (information.Contact.PenetrationDepth + .3f)), Color.White));
}
}
}
if (contactCount > 0)
{
foreach (var pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
game.GraphicsDevice.DrawUserPrimitives(PrimitiveType.LineList, contactLines.Elements, 0, contactLines.Count / 2);
}
}
}
public Scene()
{
SceneInterface = null;
_objs = new List <SceneEntity>();
_space = new Space();
_space.ForceUpdater.Gravity = MathConverter.Convert(new Vector3(0, -9.81f, 0));
}
public override void Draw(GameTime gameTime)
{
//Notice that the entity's worldTransform property is being accessed here.
//This property is returns a rigid transformation representing the orientation
//and translation of the entity combined.
//There are a variety of properties available in the entity, try looking around
//in the list to familiarize yourself with it.
Matrix worldMatrix = Transform * MathConverter.Convert(Entity.WorldTransform);
model.CopyAbsoluteBoneTransformsTo(boneTransforms);
foreach (ModelMesh mesh in model.Meshes)
{
foreach (BasicEffect effect in mesh.Effects)
{
effect.LightingEnabled = true; // turn on the lighting subsystem.
effect.DirectionalLight0.DiffuseColor = new Vector3(0.6f, 0.6f, 0.6f); // a red light
effect.DirectionalLight0.Direction = new Vector3(1f, -1.2f, 0f); // coming along the x-axis
effect.DirectionalLight0.SpecularColor = new Vector3(0.1f, 0.1f, 0.1f); // with green highlights
effect.AmbientLightColor = new Vector3(0.6f, 0.6f, 0.6f);
effect.EmissiveColor = new Vector3(0f, 0f, 0);
effect.World = boneTransforms[mesh.ParentBone.Index] * worldMatrix;
effect.View = Camera.View;
effect.Projection = Camera.Projection;
}
mesh.Draw();
}
base.Draw(gameTime);
}
public override void Draw()
{
base.Draw();
if (!hitAnything)
{
//If we didn't hit anything, just point out into something approximating infinity.
result.HitData.Location = origin + direction * 10000;
}
Game.LineDrawer.LightingEnabled = false;
Game.LineDrawer.VertexColorEnabled = true;
Game.LineDrawer.World = Microsoft.Xna.Framework.Matrix.Identity;
Game.LineDrawer.View = MathConverter.Convert(Game.Camera.ViewMatrix);
Game.LineDrawer.Projection = MathConverter.Convert(Game.Camera.ProjectionMatrix);
Game.GraphicsDevice.BlendState = BlendState.Opaque;
Game.GraphicsDevice.DepthStencilState = DepthStencilState.Default;
foreach (var pass in Game.LineDrawer.CurrentTechnique.Passes)
{
pass.Apply();
Game.GraphicsDevice.DrawUserPrimitives(PrimitiveType.LineList,
new[]
{
new VertexPositionColor(MathConverter.Convert(origin), Color.Blue),
new VertexPositionColor(MathConverter.Convert(result.HitData.Location), Color.Blue),
new VertexPositionColor(MathConverter.Convert(result.HitData.Location), Color.Blue),
new VertexPositionColor(MathConverter.Convert(result.HitData.Normal + result.HitData.Location), Color.Blue)
},
0, 2);
}
}
public override void Initialize()
{
var model = TryAndGetModelFromOwner();
if (model != null)
{
Vector3[] vertices;
int[] indices;
ModelDataExtractor.GetVerticesAndIndicesFromModel(model, out vertices, out indices);
BoundingBox _aabb = BoundingBox.CreateFromPoints(vertices);
Vector3 xsize = _aabb.Max - _aabb.Min;
if (Mass <= 0)
{
//kinematic
Entity = new Cylinder(MathConverter.Convert(Owner.World.Translation),
xsize.Y, xsize.X / 2);
}
else
{
//dynamic
Entity = new Cylinder(MathConverter.Convert(Owner.World.Translation),
xsize.Y, xsize.X / 2, Mass);
}
}
base.Initialize();
}
public bool RayCastAgainstEntity(Vector3 from, Vector3 to, out Vector3 pos, out float distance, out Entity hitEntity)
{
hitEntity = null;
var dir = to - from;
var dist = dir.Length();
var ndir = dir.Normalized();
distance = float.MaxValue;
Ray ray = new Ray(from, ndir);
pos = to;
var rcr = new RayCastResult();
var bRay = MathConverter.Convert(ray);
bool result = PhysSpace.RayCast(bRay, dist, out rcr);
if (!result)
{
return(false);
}
var convex = rcr.HitObject as ConvexCollidable;
pos = MathConverter.Convert(rcr.HitData.Location);
if (convex != null)
{
hitEntity = convex.Entity.Tag as Entity;
}
distance = rcr.HitData.T;
return(true);
}
public TextureMissile(GameModel model, Vector3 target, GameTexture carriedTex, Player p, GameModel targetModel, bool followPlayer = true)
{
FollowPlayer = followPlayer;
player = p;
this.targetModel = targetModel;
Model = model;
Target = target;
CarriedTex = carriedTex;
Vector3 up = Vector3.UnitZ;
Vector3 forward = Target - MathConverter.Convert(model.Entity.Position);
forward.Normalize();
Vector3 left = Vector3.Cross(up, forward);
BEPUutilities.Matrix3x3 m = new BEPUutilities.Matrix3x3();
m.Left = left;
m.Forward = forward;
m.Up = up;
Model.Entity.OrientationMatrix = m;
linearMotor = new SingleEntityLinearMotor(model.Entity, model.Entity.Position);
linearMotor.Settings.Mode = BEPUphysics.Constraints.TwoEntity.Motors.MotorMode.Servomechanism;
linearMotor.Settings.Servo.Goal = Target;
linearMotor.IsActive = true;
}
public static void GetShapeMeshData(EntityCollidable collidable, List <VertexPositionNormalTexture> vertices, List <ushort> indices)
{
var convexHullShape = collidable.Shape as ConvexHullShape;
if (convexHullShape == null)
{
throw new ArgumentException("Wrong shape type.");
}
var hullTriangleVertices = new List <BEPUphysics.MathExtensions.Vector3>();
var hullTriangleIndices = new List <int>();
Toolbox.GetConvexHull(convexHullShape.Vertices, hullTriangleIndices, hullTriangleVertices);
//The hull triangle vertices are used as a dummy to get the unnecessary hull vertices, which are cleared afterwards.
hullTriangleVertices.Clear();
foreach (int i in hullTriangleIndices)
{
hullTriangleVertices.Add(convexHullShape.Vertices[i]);
}
var toReturn = new VertexPositionNormalTexture[hullTriangleVertices.Count];
Vector3 normal;
for (ushort i = 0; i < hullTriangleVertices.Count; i += 3)
{
normal = MathConverter.Convert(BEPUphysics.MathExtensions.Vector3.Normalize(BEPUphysics.MathExtensions.Vector3.Cross(hullTriangleVertices[i + 2] - hullTriangleVertices[i], hullTriangleVertices[i + 1] - hullTriangleVertices[i])));
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(hullTriangleVertices[i]), normal, new Vector2(0, 0)));
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(hullTriangleVertices[i + 1]), normal, new Vector2(1, 0)));
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(hullTriangleVertices[i + 2]), normal, new Vector2(0, 1)));
indices.Add(i);
indices.Add((ushort)(i + 1));
indices.Add((ushort)(i + 2));
}
}
private static void drawMesh(ModelMesh mesh, GameModel model, string tech, Plane?clipPlane, Matrix view)
{
Matrix entityWorld = ConversionHelper.MathConverter.Convert(model.Entity.CollisionInformation.WorldTransform.Matrix);
foreach (Effect currentEffect in mesh.Effects)
{
currentEffect.CurrentTechnique = currentEffect.Techniques[tech];
currentEffect.Parameters["Texture"].SetValue(model.Texture.ActualTexture);
currentEffect.Parameters["xCamerasViewProjection"].SetValue(view * MathConverter.Convert(Camera.ProjectionMatrix));
currentEffect.Parameters["xWorld"].SetValue(mesh.ParentBone.Transform * model.Transform * entityWorld);// * Camera.World);
currentEffect.Parameters["xPassThroughLighting"].SetValue(true);
//currentEffect.Parameters["xLightPos"].SetValue(lights.LightPosition);
//currentEffect.Parameters["xLightPower"].SetValue(0.4f);
//currentEffect.Parameters["xAmbient"].SetValue(lights.AmbientPower);
//currentEffect.Parameters["xLightDir"].SetValue(lights.LightDirection);
if (clipPlane.HasValue)
{
currentEffect.Parameters["xEnableClipping"].SetValue(true);
currentEffect.Parameters["xClipPlane"].SetValue(new Vector4(clipPlane.Value.Normal, clipPlane.Value.D));
}
else
{
currentEffect.Parameters["xEnableClipping"].SetValue(false);
}
}
mesh.Draw();
}
public override void Initialized()
{
var Model = TryAndGetModelFromOwner();
if (Model != null)
{
Vector3[] Vertices;
int[] indices;
ModelDataExtractor.GetVerticesAndIndicesFromModel(Model, out Vertices, out indices);
BoundingBox aabb = BoundingBox.CreateFromPoints(Vertices);
Vector3 size = aabb.Max - aabb.Min;
if (Mass <= 0)
{
Entity = new Box(MathConverter.Convert(Owner.World.Translation), size.X, size.Y, size.Z);
}
else
{
Entity = new Box(MathConverter.Convert(Owner.World.Translation), size.X, size.Y, size.Z, Mass);
}
}
base.Initialized();
}
public StaticMeshColliderComponent(object tag, List <Microsoft.Xna.Framework.Vector3> verts, int[] indices)
{
if (tag != null)
{
Tag = tag;
}
ParentObject = tag as GameObject;
List <BEPUutilities.Vector3> bepuVerts =
MathConverter.Convert(verts.ToArray())
.ToList();
staticMesh = new StaticMesh(bepuVerts.ToArray(), indices, AffineTransform.Identity);
offset = staticMesh.WorldTransform.Translation.ToXNAVector();
staticMesh.Tag = this.Tag;
if (!SystemCore.PhysicsOnBackgroundThread)
{
SystemCore.PhysicsSimulation.Add(staticMesh);
}
else
{
SystemCore.PhysicsSimulation.SpaceObjectBuffer.Add(staticMesh);
}
}
/// <summary>
/// Moves the constraint lines to the proper location relative to the entities involved.
/// </summary>
public override void Update()
{
//Move lines around
axis.PositionA = MathConverter.Convert(LineObject.ConnectionB.Position);
axis.PositionB = MathConverter.Convert(LineObject.ConnectionB.Position + LineObject.TwistAxisB * BEPUutilities.F64.C1p5);
Fix64 angleIncrement = 4 * BEPUutilities.MathHelper.Pi / (Fix64)limitLines.Length; //Each loop iteration moves this many radians forward.
for (int i = 0; i < limitLines.Length / 2; i++)
{
Line pointToPreviousPoint = limitLines[2 * i];
Line centerToPoint = limitLines[2 * i + 1];
Fix64 currentAngle = i * angleIncrement;
//Using the parametric equation for an ellipse, compute the axis of rotation and angle.
Vector3 rotationAxis = MathConverter.Convert(LineObject.Basis.XAxis * LineObject.MaximumAngleX * Fix64.Cos(currentAngle) +
LineObject.Basis.YAxis * LineObject.MaximumAngleY * Fix64.Sin(currentAngle));
float angle = rotationAxis.Length();
rotationAxis /= angle;
pointToPreviousPoint.PositionA = MathConverter.Convert(LineObject.ConnectionB.Position) +
//Rotate the primary axis to the ellipse boundary...
Vector3.TransformNormal(MathConverter.Convert(LineObject.Basis.PrimaryAxis), Matrix.CreateFromAxisAngle(rotationAxis, angle));
centerToPoint.PositionA = pointToPreviousPoint.PositionA;
centerToPoint.PositionB = MathConverter.Convert(LineObject.ConnectionB.Position);
}
for (int i = 0; i < limitLines.Length / 2; i++)
{
//Connect all the pointToPreviousPoint lines to the previous points.
limitLines[2 * i].PositionB = limitLines[2 * ((i + 1) % (limitLines.Length / 2))].PositionA;
}
}
public void Invert()
{
var maxDelta = 0.001m;
var deltas = new List <decimal>();
// Scalability and edge cases
foreach (var m in testCases)
{
Matrix3x3 testCase = m;
FloatMatrix3x3 floatMatrix = MathConverter.Convert(testCase);
FloatMatrix3x3 expected;
FloatMatrix3x3.Invert(ref floatMatrix, out expected);
Matrix3x3 actual;
if (float.IsInfinity(expected.M11) || float.IsNaN(expected.M11))
{
expected = new FloatMatrix3x3();
}
Matrix3x3.Invert(ref testCase, out actual);
bool success = true;
foreach (decimal delta in GetDeltas(expected, actual))
{
deltas.Add(delta);
success &= delta <= maxDelta;
}
Assert.True(success, string.Format("Precision: Matrix3x3Invert({0}): Expected {1} Actual {2}", testCase, expected, actual));
}
output.WriteLine("Max error: {0} ({1} times precision)", deltas.Max(), deltas.Max() / Fix64.Precision);
output.WriteLine("Average precision: {0} ({1} times precision)", deltas.Average(), deltas.Average() / Fix64.Precision);
}
public override void ResetNode(GameWorld world)
{
if (scene == null)
{
return;
}
for (int i = 0; i < scene.Nodes.Count; i++)
{
var collidable = collidables[i];
if (collidable != null)
{
var q = MathConverter.Convert(Rotation);
var p = MathConverter.Convert(Position);
collidable.WorldTransform = new BEPUTransform(q, p);
}
var instance = instances[i];
if (instance != null)
{
instances[i].World = transforms[i] * WorldMatrix;
}
}
}
public static void GetShapeMeshData(EntityCollidable collidable, List <VertexPositionNormalTexture> vertices, List <ushort> indices)
{
var triangleShape = collidable.Shape as TriangleShape;
if (triangleShape == null)
{
throw new ArgumentException("Wrong shape type.");
}
Vector3 normal = MathConverter.Convert(triangleShape.GetLocalNormal());
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(triangleShape.VertexA), -normal, new Vector2(0, 0)));
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(triangleShape.VertexB), -normal, new Vector2(0, 1)));
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(triangleShape.VertexC), -normal, new Vector2(1, 0)));
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(triangleShape.VertexA), normal, new Vector2(0, 0)));
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(triangleShape.VertexB), normal, new Vector2(0, 1)));
vertices.Add(new VertexPositionNormalTexture(MathConverter.Convert(triangleShape.VertexC), normal, new Vector2(1, 0)));
indices.Add(0);
indices.Add(1);
indices.Add(2);
indices.Add(3);
indices.Add(5);
indices.Add(4);
}
public override void Draw(GameTime gameTime)
{
//SpaceSimGame.bloom.BeginDraw();
//Notice that the entity's worldTransform property is being accessed here.
//This property is returns a rigid transformation representing the orientation
//and translation of the entity combined.
//There are a variety of properties available in the entity, try looking around
//in the list to familiarize yourself with it.
Matrix worldMatrix = MathConverter.Convert(Transform * entity.WorldTransform);
model.CopyAbsoluteBoneTransformsTo(boneTransforms);
foreach (ModelMesh mesh in model.Meshes)
{
foreach (BasicEffect effect in mesh.Effects)
{
effect.World = boneTransforms[mesh.ParentBone.Index] * worldMatrix;
effect.View = ((SpaceSimGame)this.Game).camera.View;
effect.Projection = ((SpaceSimGame)this.Game).camera.Projection;
}
mesh.Draw();
}
base.Draw(gameTime);
}
/// <summary>
/// Constructs a new demo.
/// </summary>
/// <param name="game">Game owning this demo.</param>
public BridgeDemo(DemosGame game)
: base(game)
{
//Form a long chain of planks connected by revolute joints.
//The revolute joints control the three linear degrees of freedom and two angular degrees of freedom.
//The third allowed angular degree of freedom allows the bridge to flex like a rope bridge.
Vector3 startPosition = new Vector3(0, 0, 0);
var startPlatform = new Box(startPosition - new Vector3(0, 0, 3.2f), 8, .5f, 8);
Space.Add(startPlatform);
Vector3 offset = new Vector3(0, 0, 1.7f);
Box previousLink = startPlatform;
Vector3 position = new Vector3();
for (int i = 1; i <= 200; i++)
{
position = startPosition + offset * i;
Box link = new Box(position, 4.5f, .3f, 1.5f, 50);
Space.Add(link);
Space.Add(new RevoluteJoint(previousLink, link, position - offset * .5f, Vector3.Right));
previousLink = link;
}
var endPlatform = new Box(position - new Vector3(0, 0, -4.8f), 8, .5f, 8);
Space.Add(endPlatform);
Space.Add(new RevoluteJoint(previousLink, endPlatform, position + offset * .5f, Vector3.Right));
game.Camera.Position = MathConverter.Convert(startPosition + new Vector3(0, 1, offset.Z * 200 + 5));
}
void UpdateFallSFX(Entity e, float elapsedTime)
{
bool newTraction = controller.SupportFinder.HasTraction;
if (oldTraction != newTraction && newTraction)
{
//if (((ShooterServer)World.GameServer).ShowFallings) {
// Log.Verbose("{0} falls : {1}", e.ID, oldVelocity.Y );
//}
if (oldVelocity.Y < -10)
{
// medium landing :
World.SpawnFX("PlayerLanding", e.ID, e.Position, oldVelocity, Quaternion.Identity);
}
else
{
// light landing :
World.SpawnFX("PlayerFootStepL", e.ID, e.Position);
}
}
oldTraction = newTraction;
oldVelocity = MathConverter.Convert(controller.Body.LinearVelocity);
}
/// <summary>
///
/// </summary>
/// <param name="gameTime"></param>
public override void Update(float elapsedTime)
{
var c = controller;
var e = Entity;
UpdateWeaponState(Entity, (short)(elapsedTime * 1000));
Move();
e.Position = MathConverter.Convert(c.Body.Position) - GetPovOffset();
e.LinearVelocity = MathConverter.Convert(c.Body.LinearVelocity);
e.AngularVelocity = MathConverter.Convert(c.Body.AngularVelocity);
if (c.SupportFinder.HasTraction)
{
e.State |= EntityState.HasTraction;
}
else
{
e.State &= ~EntityState.HasTraction;
}
if (c.StanceManager.CurrentStance == Stance.Crouching)
{
e.State |= EntityState.Crouching;
}
else
{
e.State &= ~EntityState.Crouching;
}
UpdateWalkSFX(e, elapsedTime);
UpdateFallSFX(e, elapsedTime);
}
public override void GetMeshData(List <VertexPositionNormalTexture> vertices, List <ushort> indices)
{
var tempVertices = new VertexPositionNormalTexture[DisplayedObject.Shape.TriangleMesh.Data.Vertices.Length];
for (int i = 0; i < DisplayedObject.Shape.TriangleMesh.Data.Vertices.Length; i++)
{
tempVertices[i] = new VertexPositionNormalTexture(
MathConverter.Convert(BEPUphysics.MathExtensions.AffineTransform.Transform(DisplayedObject.Shape.TriangleMesh.Data.Vertices[i], DisplayedObject.WorldTransform)),
Vector3.Zero,
Vector2.Zero);
}
for (int i = 0; i < DisplayedObject.Shape.TriangleMesh.Data.Indices.Length; i++)
{
indices.Add((ushort)DisplayedObject.Shape.TriangleMesh.Data.Indices[i]);
}
for (int i = 0; i < indices.Count; i += 3)
{
int a = indices[i];
int b = indices[i + 1];
int c = indices[i + 2];
Vector3 normal = Vector3.Normalize(Vector3.Cross(
tempVertices[c].Position - tempVertices[a].Position,
tempVertices[b].Position - tempVertices[a].Position));
tempVertices[a].Normal += normal;
tempVertices[b].Normal += normal;
tempVertices[c].Normal += normal;
}
for (int i = 0; i < tempVertices.Length; i++)
{
tempVertices[i].Normal.Normalize();
vertices.Add(tempVertices[i]);
}
}
/// <summary>
/// Moves the constraint lines to the proper location relative to the entities involved.
/// </summary>
public override void Update()
{
//Move lines around
if (LineObject.IsActiveInSolver)
{
toPoint.PositionA = MathConverter.Convert(LineObject.Entity.Position);
toPoint.PositionB = MathConverter.Convert(LineObject.Point);
if (LineObject.Settings.Mode == MotorMode.Servomechanism)
{
error.PositionA = toPoint.PositionB;
error.PositionB = MathConverter.Convert(LineObject.Settings.Servo.Goal);
}
else
{
error.PositionA = toPoint.PositionB;
error.PositionB = toPoint.PositionB;
}
}
else
{
error.PositionA = toPoint.PositionB;
error.PositionB = toPoint.PositionB;
}
}
/// <summary>
///
/// </summary>
/// <param name="game"></param>
/// <param name="space"></param>
public RigidBody(Entity entity, GameWorld world, RigidBodyFactory factory) : base(entity, world)
{
this.space = world.PhysSpace;
var width = factory.Width;
var height = factory.Height;
var depth = factory.Depth;
var mass = factory.Mass;
var model = factory.Model;
var ms = new MotionState();
ms.AngularVelocity = MathConverter.Convert(entity.AngularVelocity);
ms.LinearVelocity = MathConverter.Convert(entity.LinearVelocity);
ms.Orientation = MathConverter.Convert(entity.Rotation);
ms.Position = MathConverter.Convert(entity.Position);
box = new Box(ms, width, height, depth, mass);
box.PositionUpdateMode = PositionUpdateMode.Continuous;
box.Tag = entity;
entity.Model = world.Atoms[model];
space.Add(box);
}
/// <summary>
/// Draws the component.
/// </summary>
/// <param name="viewMatrix">View matrix to use when rendering the lines.</param>
/// <param name="projectionMatrix">Projection matrix to use when rendering the lines.</param>
public void Draw(BEPUutilities.Matrix viewMatrix, BEPUutilities.Matrix projectionMatrix)
{
int numElements = firstOpenIndex / 2;
if (numElements > 0)
{
//Set state
game.GraphicsDevice.BlendState = blendState;
lineDrawer.LightingEnabled = false;
lineDrawer.VertexColorEnabled = true;
lineDrawer.World = Matrix.Identity;
lineDrawer.View = MathConverter.Convert(viewMatrix);
lineDrawer.Projection = MathConverter.Convert(projectionMatrix);
//Draw
for (int i = 0; i < lineDrawer.CurrentTechnique.Passes.Count; i++)
{
lineDrawer.CurrentTechnique.Passes[i].Apply();
game.GraphicsDevice.DrawUserPrimitives(PrimitiveType.LineList, vertices, 0, numElements);
}
}
}
public static void GetMeshData(TriangleMesh mesh, List <VertexPositionNormalTexture> vertices, List <ushort> indices)
{
var tempVertices = new VertexPositionNormalTexture[mesh.Data.Vertices.Length];
for (int i = 0; i < mesh.Data.Vertices.Length; i++)
{
BEPUphysics.MathExtensions.Vector3 v;
mesh.Data.GetVertexPosition(i, out v);
tempVertices[i] = new VertexPositionNormalTexture(MathConverter.Convert(v), Vector3.Zero, Vector2.Zero);
}
for (int i = 0; i < mesh.Data.Indices.Length; i++)
{
indices.Add((ushort)mesh.Data.Indices[i]);
}
for (int i = 0; i < indices.Count; i += 3)
{
int a = indices[i];
int b = indices[i + 1];
int c = indices[i + 2];
Vector3 normal = Vector3.Normalize(Vector3.Cross(
tempVertices[c].Position - tempVertices[a].Position,
tempVertices[b].Position - tempVertices[a].Position));
tempVertices[a].Normal += normal;
tempVertices[b].Normal += normal;
tempVertices[c].Normal += normal;
}
for (int i = 0; i < tempVertices.Length; i++)
{
tempVertices[i].Normal.Normalize();
vertices.Add(tempVertices[i]);
}
}
public override void Initialize()
{
var model = TryAndGetModelFromOwner();
if (model != null)
{
Vector3[] vertices;
int[] indices;
ModelDataExtractor.GetVerticesAndIndicesFromModel(model, out vertices, out indices);
BoundingSphere _aabb = BoundingSphere.CreateFromPoints(vertices);
if (Mass <= 0)
{
//kinematic
Entity = new Sphere(MathConverter.Convert(Owner.World.Translation),
_aabb.Radius);
}
else
{
//dynamic
Entity = new Sphere(MathConverter.Convert(Owner.World.Translation),
_aabb.Radius, Mass);
}
}
base.Initialize();
}
public override void Draw(GameTime gameTime)
{
//Notice that the entity's worldTransform property is being accessed here.
//This property is returns a rigid transformation representing the orientation
//and translation of the entity combined.
//There are a variety of properties available in the entity, try looking around
//in the list to familiarize yourself with it.
var worldMatrix = Transform * MathConverter.Convert(entity.WorldTransform);
model.CopyAbsoluteBoneTransformsTo(boneTransforms);
foreach (ModelMesh mesh in model.Meshes)
{
foreach (BasicEffect effect in mesh.Effects)
{
effect.World = boneTransforms[mesh.ParentBone.Index] * worldMatrix;
effect.View = MathConverter.Convert((Game as BepuFluidGame).Camera.ViewMatrix);
effect.Projection = MathConverter.Convert((Game as BepuFluidGame).Camera.ProjectionMatrix);
if (this.IsOpaque || true)
{
effect.GraphicsDevice.DepthStencilState = DepthStencilState.Default;
effect.GraphicsDevice.BlendState = BlendState.AlphaBlend;
effect.Alpha = 1.0f;
}
}
mesh.Draw();
}
base.Draw(gameTime);
}
public void BenchmarkAdaptiveInvert()
{
var swf = new Stopwatch();
var swd = new Stopwatch();
var deltas = new List <decimal>();
foreach (var m in testCases)
{
Matrix3x3 testCase = m;
for (int i = 0; i < 10000; i++)
{
FloatMatrix3x3 floatMatrix = MathConverter.Convert(testCase);
FloatMatrix3x3 expected;
swf.Start();
FloatMatrix3x3.AdaptiveInvert(ref floatMatrix, out expected);
swf.Stop();
Matrix3x3 actual;
swd.Start();
Matrix3x3.AdaptiveInvert(ref testCase, out actual);
swd.Stop();
foreach (decimal delta in GetDeltas(expected, actual))
{
deltas.Add(delta);
}
}
}
output.WriteLine("Max error: {0} ({1} times precision)", deltas.Max(), deltas.Max() / Fix64.Precision);
output.WriteLine("Average precision: {0} ({1} times precision)", deltas.Average(), deltas.Average() / Fix64.Precision);
output.WriteLine("Fix64.AdaptiveInvert time = {0}ms, float.AdaptiveInvert time = {1}ms", swf.ElapsedMilliseconds, swd.ElapsedMilliseconds);
}
/// <summary>
/// Draws the display object.
/// </summary>
/// <param name="viewMatrix">Current view matrix.</param>
/// <param name="projectionMatrix">Current projection matrix.</param>
public override void Draw(Matrix viewMatrix, Matrix projectionMatrix)
{
//This is not a particularly fast method of drawing.
//It's used very rarely in the demos.
model.CopyAbsoluteBoneTransformsTo(transforms);
for (int i = 0; i < Model.Meshes.Count; i++)
{
for (int j = 0; j < Model.Meshes[i].Effects.Count; j++)
{
var effect = Model.Meshes[i].Effects[j] as BasicEffect;
if (effect != null)
{
effect.World = transforms[Model.Meshes[i].ParentBone.Index] * MathConverter.Convert(WorldTransform);
effect.View = MathConverter.Convert(viewMatrix);
effect.Projection = MathConverter.Convert(projectionMatrix);
effect.AmbientLightColor = Color;
if (Texture != null)
{
effect.TextureEnabled = true;
effect.Texture = Texture;
}
else
{
effect.TextureEnabled = false;
}
}
}
Model.Meshes[i].Draw();
}
}
/// <summary>
/// Constructs a new demo.
/// </summary>
/// <param name="game">Game owning this demo.</param>
public BroadPhaseRemovalTestDemo(DemosGame game)
: base(game)
{
Entity toAdd;
//BoundingBox box = new BoundingBox(new Vector3(-5, 1, 1), new Vector3(5, 7, 7));
BoundingBox box = new BoundingBox(new Vector3(-500, -500, -500), new Vector3(500, 500, 500));
DynamicHierarchy dh = new DynamicHierarchy();
Random rand = new Random(0);
RawList <Entity> entities = new RawList <Entity>();
for (int k = 0; k < 1000; k++)
{
Vector3 position = new Vector3((float)(rand.NextDouble() * (box.Max.X - box.Min.X) + box.Min.X),
(float)(rand.NextDouble() * (box.Max.Y - box.Min.Y) + box.Min.Y),
(float)(rand.NextDouble() * (box.Max.Z - box.Min.Z) + box.Min.Z));
toAdd = new Box(MathConverter.Convert(position), 1, 1, 1, 1);
entities.Add(toAdd);
}
testResults = new double[2];
int runCount = 10;
for (int k = 0; k < runCount; k++)
{
for (int i = 0; i < entities.Count; i++)
{
dh.Add(entities[i].CollisionInformation);
}
long start = Stopwatch.GetTimestamp();
for (int i = 0; i < entities.Count; i++)
{
//dh.RemoveFast(entities[i].CollisionInformation);
}
long end = Stopwatch.GetTimestamp();
testResults[0] += (end - start) / (double)Stopwatch.Frequency;
for (int i = 0; i < entities.Count; i++)
{
dh.Add(entities[i].CollisionInformation);
}
start = Stopwatch.GetTimestamp();
for (int i = 0; i < entities.Count; i++)
{
//dh.RemoveBrute(entities[i].CollisionInformation);
}
end = Stopwatch.GetTimestamp();
testResults[1] += (end - start) / (double)Stopwatch.Frequency;
}
testResults[0] /= runCount;
testResults[1] /= runCount;
}
public override void Draw(GameTime gameTime)
{
//Notice that the entity's worldTransform property is being accessed here.
//This property is returns a rigid transformation representing the orientation
//and translation of the entity combined.
//There are a variety of properties available in the entity, try looking around
//in the list to familiarize yourself with it.
Matrix worldMatrix = MathConverter.Convert(Transform * entity.WorldTransform);
foreach (ModelMesh m in model.Meshes)
{
foreach (Effect e in m.Effects)
{
if (false) //hideClouds)
{
e.CurrentTechnique = e.Techniques["EarthWithoutClouds"];
}
else
{
e.CurrentTechnique = e.Techniques["EarthWithClouds"];
e.Parameters["cloudStrength"].SetValue(cloudStrength);
}
e.Parameters["world"].SetValue(worldMatrix);
e.Parameters["view"].SetValue(((SpaceSimGame)this.Game).camera.View);
e.Parameters["projection"].SetValue(((SpaceSimGame)this.Game).camera.Projection);
e.Parameters["cameraPos"].SetValue(new Vector4(((SpaceSimGame)this.Game).camera.Position, 1.0f));
e.Parameters["globalAmbient"].SetValue(globalAmbient);
e.Parameters["lightDir"].SetValue(sunlight.direction);
e.Parameters["lightColor"].SetValue(sunlight.color);
e.Parameters["materialAmbient"].SetValue(ambient);
e.Parameters["materialDiffuse"].SetValue(diffuse);
e.Parameters["materialSpecular"].SetValue(specular);
e.Parameters["materialShininess"].SetValue(shininess);
e.Parameters["landOceanColorGlossMap"].SetValue(dayTexture);
e.Parameters["cloudColorMap"].SetValue(cloudTexture);
e.Parameters["nightColorMap"].SetValue(nightTexture);
e.Parameters["normalMap"].SetValue(normalMapTexture);
}
m.Draw();
}
/*
* model.CopyAbsoluteBoneTransformsTo(boneTransforms);
* foreach (ModelMesh mesh in model.Meshes)
* {
* foreach (BasicEffect effect in mesh.Effects)
* {
* effect.World = boneTransforms[mesh.ParentBone.Index] * worldMatrix;
* effect.View = SpaceSimGame.camera.View;
* effect.Projection = SpaceSimGame.camera.Projection;
* }
* mesh.Draw();
* }
*/
base.Draw(gameTime);
}
