physicSystem.CollisionSystem.SegmentIntersect(out frac, out skin, out pos, out normal, new Segment(cam.Position, ray * 1000.0f), pred); if (skin != null) { if (!skin.Owner.Immovable) { Vector3 delta = pos - skin.Owner.Position; delta = Vector3.Transform(delta, Matrix.Transpose(skin.Owner.Orientation)); camPickDistance = (cam.Position - pos).Length(); oldWheel = mouse.State.ScrollWheelValue; skin.Owner.SetActive(); objectController.Destroy(); damperController.Destroy(); objectController.Initialise(skin.Owner, delta, pos); damperController.Initialise(skin.Owner, ConstraintVelocity.ReferenceFrame.Body, Vector3.Zero, Vector3.Zero); objectController.EnableConstraint(); damperController.EnableConstraint(); } } middleButton = true; } if (objectController.IsConstraintEnabled && (objectController.Body != null)) { Vector3 delta = objectController.Body.Position - cam.Position; Vector3 ray = RayTo((int)mouse.Position.X,(int)mouse.Position.Y); ray.Normalize(); float deltaWheel = mouse.State.ScrollWheelValue - oldWheel; camPickDistance += deltaWheel * 0.01f; Vector3 result = cam.Position + camPickDistance * ray; oldWheel = mouse.State.ScrollWheelValue; objectController.WorldPosition = result; objectController.Body.SetActive(); } } else { objectController.DisableConstraint(); damperController.DisableConstraint(); middleButton = false; } #endregion 

  // for picking float camPickDistance = 0.0f; bool middleButton = false; int oldWheel = 0; public override void Update() { //physics.UpdatePhysics = true; mouseState = Mouse.GetState(); //mouseState = Mouse.GetState(); position.X = mouseState.X; position.Y = mouseState.Y; Viewport vp = Engine.GraphicsDevice.Viewport; if ((vp.X <= position.X) && (position.X <= (vp.X + vp.Width)) && (vp.Y <= position.Y) && (position.Y <= (vp.Y + vp.Height))) { //position += mouse.Delta * 5* // (float)Engine.GameTime.ElapsedGameTime.TotalSeconds; position.X = MathHelper.Clamp(position.X, vp.X, vp.X + vp.Width); position.Y = MathHelper.Clamp(position.Y, vp.Y, vp.Y + vp.Height); } else if (mouse.Delta.LengthSquared() > 0f) { position.X = vp.X + vp.Width / 2; position.Y = vp.Y + vp.Height / 2; } mouse.Position= new Vector2((int)position.X, (int)position.Y); //mouse.Update(); _pointer.Update(); Vector3 inputModifier = new Vector3( (keyboard.IsKeyDown(Keys.A) ? -1 : 0) + (keyboard.IsKeyDown(Keys.D) ? 1 : 0), (keyboard.IsKeyDown(Keys.Q) ? -1 : 0) + (keyboard.IsKeyDown(Keys.E) ? 1 : 0), (keyboard.IsKeyDown(Keys.W) ? -1 : 0) + (keyboard.IsKeyDown(Keys.S) ? 1 : 0) ); if (keyboard.IsKeyDown(Keys.M) && keyboard.IsKeyUp(Keys.M)) { } #region Picking Objects with the mouse if (mouse.IsButtonDown(MouseButtons.Middle)) { if (middleButton == false) { Vector3 ray = RayTo((int)mouse.Position.X, (int)mouse.Position.Y); float frac; CollisionSkin skin; Vector3 pos, normal; ImmovableSkinPredicate pred = new ImmovableSkinPredicate(); physicSystem.CollisionSystem.SegmentIntersect(out frac, out skin, out pos, out normal, new Segment(cam.Position, ray * 1000.0f), pred); if (skin != null) { if (!skin.Owner.Immovable) { Vector3 delta = pos - skin.Owner.Position; delta = Vector3.Transform(delta, Matrix.Transpose(skin.Owner.Orientation)); camPickDistance = (cam.Position - pos).Length(); oldWheel = mouse.State.ScrollWheelValue; skin.Owner.SetActive(); objectController.Destroy(); damperController.Destroy(); objectController.Initialise(skin.Owner, delta, pos); damperController.Initialise(skin.Owner, ConstraintVelocity.ReferenceFrame.Body, Vector3.Zero, Vector3.Zero); objectController.EnableConstraint(); damperController.EnableConstraint(); } } middleButton = true; } if (objectController.IsConstraintEnabled && (objectController.Body != null)) { Vector3 delta = objectController.Body.Position - cam.Position; Vector3 ray = RayTo((int)mouse.Position.X,(int)mouse.Position.Y); ray.Normalize(); float deltaWheel = mouse.State.ScrollWheelValue - oldWheel; camPickDistance += deltaWheel * 0.01f; Vector3 result = cam.Position + camPickDistance * ray; oldWheel = mouse.State.ScrollWheelValue; objectController.WorldPosition = result; objectController.Body.SetActive(); } } else { objectController.DisableConstraint(); damperController.DisableConstraint(); middleButton = false; } #endregion 

  private Vector3 RayTo(int x, int y) { FPSCamera cam = (FPSCamera)Engine.Services.GetService<Camera>(); Vector3 nearSource = new Vector3(x, y, 0); Vector3 farSource = new Vector3(x, y, 1); Matrix world = Matrix.CreateTranslation(0, 0, 0); Vector3 nearPoint = Engine.GraphicsDevice.Viewport.Unproject(nearSource, cam.Projection, cam.View, world); Vector3 farPoint = Engine.GraphicsDevice.Viewport.Unproject(farSource, cam.Projection, cam.View, world); Vector3 direction = farPoint - nearPoint; // direction.Normalize(); return direction; } and my physics system is currently set up like: physicSystem = new PhysicsSystem(); physicSystem.CollisionSystem = new CollisionSystemGrid(32, 32, 32, 30, 30, 30); // physicSystem.CollisionSystem = new CollisionSystemSAP(); physicSystem.EnableFreezing = true; physicSystem.SolverType = PhysicsSystem.Solver.Normal; physicSystem.CollisionSystem.UseSweepTests = true; physicSystem.NumCollisionIterations = 8; physicSystem.NumContactIterations = 8; physicSystem.NumPenetrationRelaxtionTimesteps = 15; can anyone see any reason why this shouldnt work in the same way it does in the jigglegame, or is there a even better way of picking up objects. Thanks in advance. 

 using System; using System.Collections.Generic; using JigLibX.Collision; using JigLibX.Geometry; using JigLibX.Math; using JigLibX.Physics; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Graphics; namespace qkGames { // A physics object that simulates all the individual polygons in a model public class TriangleMeshObject : PhysicsObject { // The generated mesh TriangleMesh triangleMesh; //string modelName; public List<Vector3> vertexList; // Constructors public List<TriangleVertexIndices> indexList; public TriangleMeshObject() : base() { Setup(null, Vector3.Zero, Vector3.Zero); } public TriangleMeshObject(string ModelName, Vector3 Position, Vector3 Rotation) : base() { Setup(ModelName, Position, Rotation); } public TriangleMeshObject(string ModelName, Vector3 Position, Vector3 Rotation, GameScreen Parent) : base(Parent) { Setup(ModelName, Position, Rotation); } // Sets up the object void Setup(string ModelName, Vector3 Position, Vector3 Rotation) { Model Model = Engine.Content.Load<Model>(ModelName); Body = new Body(); CollisionSkin = new CollisionSkin(null); //Body.CollisionSkin = CollisionSkin; //this.modelName = ModelName; //CollisionSkin.RemoveAllPrimitives(); triangleMesh = new TriangleMesh(); vertexList = new List<Vector3>(); indexList = new List<TriangleVertexIndices>(); ExtractData(vertexList, indexList, Model); //triangleMesh.CreateMesh( triangleMesh.CreateMesh(vertexList, indexList, 4, 1.0f); CollisionSkin.AddPrimitive(triangleMesh, new MaterialProperties(0.8f, 0.7f, 0.6f)); PhysicsSystem.CurrentPhysicsSystem.CollisionSystem.AddCollisionSkin(CollisionSkin); //Mass = Mass; this.Position = Position; CollisionSkin.ApplyLocalTransform(new Transform(-Position, Matrix.Identity)); // CollisionSkin. //this.EulerRotation = Rotation; } // Sets the model being simulated, extracts vertices, etc. public void SetModel(string ModelName) { } // Extracts the neccesary information from a model to // simulate physics on it public void ExtractData(List<Vector3> vertices, List<TriangleVertexIndices> indices,Model model) { Matrix[] bones_ = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(bones_); foreach (ModelMesh mm in model.Meshes) { Matrix xform = bones_[mm.ParentBone.Index]; foreach (ModelMeshPart mmp in mm.MeshParts) { int offset = vertices.Count; Vector3[] a = new Vector3[mmp.NumVertices]; mm.VertexBuffer.GetData<Vector3>(mmp.StreamOffset + mmp.BaseVertex * mmp.VertexStride, a, 0, mmp.NumVertices, mmp.VertexStride); for (int i = 0; i != a.Length; ++i) Vector3.Transform(ref a[i], ref xform, out a[i]); vertices.AddRange(a); if (mm.IndexBuffer.IndexElementSize != IndexElementSize.SixteenBits) throw new Exception( String.Format("Model uses 32-bit indices, which are not supported.")); short[] s = new short[mmp.PrimitiveCount * 3]; mm.IndexBuffer.GetData<short>(mmp.StartIndex * 2, s, 0, mmp.PrimitiveCount * 3); JigLibX.Geometry.TriangleVertexIndices[] tvi = new JigLibX.Geometry.TriangleVertexIndices[mmp.PrimitiveCount]; for (int i = 0; i != tvi.Length; ++i) { tvi[i].I0 = s[i * 3 + 2] + offset; tvi[i].I1 = s[i * 3 + 1] + offset; tvi[i].I2 = s[i * 3 + 0] + offset; } indices.AddRange(tvi); } } } } } 

  if (skin1.Owner == null || skin1.Owner.ExternalData == null) return true; 

  if (skin1.Owner == null) return true; 

 using JigLibX.Collision; using JigLibX.Geometry; using JigLibX.Physics; using Microsoft.Xna.Framework; namespace qkGames { // Provides a base object type for physics simulation public abstract class PhysicsObject : Component { // Local copy of the mass of the object float mass = 1; // The Body managed by the PhysicsObject public Body Body; // The CollisionSkin managed by the PhysicsObject public CollisionSkin CollisionSkin; // The mass of the PhysicsObject public float Mass { get { return mass; } set { // Set the new value mass = value; // Fix transforms Vector3 com = SetMass(value); if (CollisionSkin != null) CollisionSkin.ApplyLocalTransform( new JigLibX.Math.Transform(-com, Matrix.Identity)); } } // The PhysicsObject's position public Vector3 Position { get { return Body.Position; } set { Body.MoveTo(value, Body.Orientation); } } // The PhysicsObject's orientation public Matrix Rotation { get { return Body.Orientation; } set { Body.MoveTo(Body.Position, value); } } // The PhysicsObject's rotation as a Euler Vector public Vector3 EulerRotation { get { return MathUtil.MatrixToVector3(Rotation); } set { Rotation = MathUtil.Vector3ToMatrix(value); } } // Whether or not the physics object is locked in place public bool Immovable { get { return Body.Immovable; } set { Body.Immovable = value; } } // Returns the PhysicsObject's BoundingBox public BoundingBox BoundingBox { get { if (Body.CollisionSkin != null) return Body.CollisionSkin.WorldBoundingBox; else return new BoundingBox(Position - Vector3.One, Position + Vector3.One); } } // The body's velocity public Vector3 Velocity { get { return Body.Velocity; } set { Body.Velocity = value; } } // Constructors public PhysicsObject() : base() { //Body.CollisionSkin.callbackFn += new CollisionCallbackFn(CollisionCallBack); } public PhysicsObject(GameScreen Parent) : base(Parent) { } // Sets up the body and collision skin protected void InitializeBody() { Body = new Body(); CollisionSkin = new CollisionSkin(Body); Body.CollisionSkin = this.CollisionSkin; Body.EnableBody(); } // Sets the mass of the PhysicsObject public Vector3 SetMass(float mass) { PrimitiveProperties primitiveProperties = new PrimitiveProperties( PrimitiveProperties.MassDistributionEnum.Solid, PrimitiveProperties.MassTypeEnum.Density, mass); float junk; Vector3 com; Matrix it, itCoM; CollisionSkin.GetMassProperties(primitiveProperties, out junk, out com, out it, out itCoM); Body.BodyInertia = itCoM; Body.Mass = junk; return com; } // Rotates and moves the model relative to the physics object to // better align the model with the object public void OffsetModel(Vector3 PositionOffset, Matrix RotationOffset) { CollisionSkin.ApplyLocalTransform( new JigLibX.Math.Transform(PositionOffset, RotationOffset)); } // Disables physics body and component public override void DisableComponent() { Body.DisableBody(); base.DisableComponent(); } } } 

 //**************************CharacterObject*********************************** using JigLibX.Collision; using JigLibX.Geometry; using JigLibX.Physics; using Microsoft.Xna.Framework; using JigLibX.Math; namespace qkGames { public class CharacterObject : PhysicsObject { public virtual bool CollisionCallBack(CollisionSkin skin0, CollisionSkin skin1) { if (skin1.Owner == null || skin1.Owner.ExternalData == null) return true; // if you wanted to know the position of the box you collided with.... Vector3 otherBoxesPosition = skin1.Owner.Position; // xxxxxxxxxxxxxxxxxxxxxxxx // Using a little reflection, we can see exactly what kind of object we collided with. // WARNING: No Guarantee that the members 'ExternalData' or even 'Owner' won't be null if (skin1.Owner.ExternalData is BoxObject) { // i collided with another instance of my type of object PauseScreen pause = new PauseScreen("Pause"); return false; // allow this object to pass through } // if you inherit from this class, and set the 'body.ExternalData' to the gameComponent instance // you can kill that instance when you collide with it.... if (skin1.Owner.ExternalData is GameComponent) ((GameComponent)skin1.Owner.ExternalData).Enabled = false; if (skin1.Owner.ExternalData is DrawableGameComponent) ((DrawableGameComponent)skin1.Owner.ExternalData).Visible = false; // for everything else, we still want the collision handled by the physics engine after our logic // so we return true return false; } public Character CharacterBody { get; set; } CollisionCallbackFn col; public CharacterObject(Vector3 position) : base() { InitializeBody(); Body = new Character(); Vector3 Posi = position; //collision = new CollisionSkin(Body); Body.ExternalData = this; CollisionSkin = new CollisionSkin(Body); Body.CollisionSkin = this.CollisionSkin; //col = new CollisionCallbackFn(CollisionCheck); //Body.CollisionSkin.callbackFn += col; Capsule capsule = new Capsule(Vector3.Zero, Matrix.CreateRotationX(MathHelper.PiOver2), 1.0f, 1.0f); //Body.CollisionSkin.callbackFn += new CollisionCallbackFn(CollisionCallBack); CollisionSkin.AddPrimitive(capsule, new MaterialProperties(0.0f, 0.5f, 0.3f)); //body.CollisionSkin = this.collision; Vector3 com = SetMass(1.0f); Body.MoveTo(position + com, Matrix.Identity); CollisionSkin.ApplyLocalTransform(new Transform(-com, Matrix.Identity)); Body.SetBodyInvInertia(0.0f, 0.0f, 0.0f); CharacterBody = Body as Character; Body.AllowFreezing = false; Body.EnableBody(); Body.CollisionSkin.callbackFn += new CollisionCallbackFn(CollisionCallBack); } } class ASkinPredicate : CollisionSkinPredicate1 { public override bool ConsiderSkin(CollisionSkin skin0) { if (!(skin0.Owner is Character)) return true; else return false; } } public class Character : Body { public Character() : base() { } public Vector3 DesiredVelocity { get; set; } private bool doJump = false; public void DoJump() { doJump = true; } public override void AddExternalForces(float dt) { ClearForces(); if (doJump) { foreach (CollisionInfo info in CollisionSkin.Collisions) { Vector3 N = info.DirToBody0; if (this == info.SkinInfo.Skin1.Owner) Vector3.Negate(ref N, out N); if (Vector3.Dot(N, Orientation.Up) > 0.7f) { Vector3 vel = Velocity; vel.Y = 5.0f; Velocity = vel; break; } } } Vector3 deltaVel = DesiredVelocity - Velocity; bool running = true; if (DesiredVelocity.LengthSquared() < JiggleMath.Epsilon) running = false; else deltaVel.Normalize(); deltaVel.Y = 0.0f; // start fast, slow down slower if (running) deltaVel *= 10.0f; else deltaVel *= 2.0f; float forceFactor = 1000.0f; AddBodyForce(deltaVel * Mass * dt * forceFactor); doJump = false; AddGravityToExternalForce(); } //bool CollisionCheck(CollisionSkin skin0, CollisionSkin skin1) // { // return true; //} } } 

 using JigLibX.Collision; using JigLibX.Geometry; using JigLibX.Physics; using Microsoft.Xna.Framework; namespace qkGames { public class BoxObject : PhysicsObject { Vector3 sideLengths; // teh length of the sides of the box public Vector3 SideLengths { get { return sideLengths; } set { // Set the new value sideLengths = value; // Update the collision skin CollisionSkin.RemoveAllPrimitives(); CollisionSkin.AddPrimitive( new Box(-0.5f * value, Body.Orientation, value), new MaterialProperties(0.8f, 0.8f, 0.7f)); // Set the mass to itself to fix the local transform // on the CollisionSkin in the set accessor this.Mass = this.Mass; } } //contructors public BoxObject() : base() { InitializeBody(); SideLengths = Vector3.One; } public BoxObject(Vector3 SideLengths) :base() { SetupSkin(SideLengths, Vector3.Zero, Vector3.Zero); } public BoxObject(Vector3 SideLengths, Vector3 Position, Vector3 Rotation) : base() { SetupSkin(SideLengths, Position, Rotation); } public BoxObject(Vector3 SideLengths, Vector3 Position, Vector3 Rotation, GameScreen Parent) : base(Parent) { SetupSkin(SideLengths, Position, Rotation); } //setup object with parameters void SetupSkin(Vector3 SideLengths, Vector3 Position, Vector3 Rotation) { //setup body InitializeBody(); //Set Properties this.SideLengths = SideLengths; this.Position = Position; this.EulerRotation = Rotation; } } } 

  // this class inherits from CollidableObject and simply builds a flat floor plane, 100 X 100, and only 3 units high. // also, i had to add the 'protected' modifier to the 'body' member, so i could get to it in this class public class Floor : CollidableObject { public Floor(Game game) : base(game, Vector3.Zero, Quaternion.Identity, new Vector3(100, 3, 100)) { this.body.Immovable = true; } } // this class inherits from CollidableObject and overrides the CollisionCallBack public class GoodGuyBox : CollidableObject { public GoodGuyBox(Game game, Vector3 pos, Quaternion rot, Vector3 scl) : base(game, pos, rot, scl) { } public override bool CollisionCallBack(CollisionSkin skin0, CollisionSkin skin1) { if (skin1.Owner.ExternalData is GoodGuyBox) { // it's ok to collide with other good guys, return true; } return base.CollisionCallBack(skin0, skin1); } } // this class inherits from CollidableObject and overrides the CollisionCallBack public class BadGuyBox : CollidableObject { public BadGuyBox(Game game, Vector3 pos, Quaternion rot, Vector3 scl) : base(game, pos, rot, scl) { } public override bool CollisionCallBack(CollisionSkin skin0, CollisionSkin skin1) { if (skin1.Owner.ExternalData is GoodGuyBox) { // since this instance is a 'bad guy' he deactivates 'Good Guys' when it collides with them ((GoodGuyBox)skin1.Owner.ExternalData).Destroy(); return true; } return base.CollisionCallBack(skin0, skin1); } } 

  public class CollidableObject : DrawableGameComponent { #region Constructor / Init / Load public CollidableObject(Game game, Vector3 pos, Quaternion rot, Vector3 scl) : base(game) { body = new Body(); // this makes it possible to get back up to this object, when you detect a collision from an event body.ExternalData = this; _materialProperties = new MaterialProperties(0.0001f, 0.5f, 0.5f); this.position = pos; this.scale = scl; this.rotation = Matrix.CreateFromQuaternion(rot); this._skin = new CollisionSkin(body); body.CollisionSkin = _skin; RebuildSkinPrimitive(scl); com = SetMass(200); body.MoveTo(position, rotation); this._skin.ApplyLocalTransform(new Transform(-com, rotation)); body.EnableBody(); body.CollisionSkin.callbackFn += new CollisionCallbackFn(CollisionCallBack); } protected override void LoadContent() { base.LoadContent(); model = Game.Content.Load<Model>("model/monkeyhead123"); bones = new Matrix[model.Bones.Count]; } #endregion #region Propeties Model model; Vector3 com; Body body; private Matrix[] bones; private Vector3 position; private Vector3 scale; private Matrix rotation; private bool isDestroyed = false; private bool isCleanedUp = false; private CollisionSkin _skin; public CollisionSkin Skin { get { return _skin; } } private MaterialProperties _materialProperties; #endregion #region XNA Overrides public override void Update(GameTime gameTime) { this.position = body.Position; this.rotation = body.Orientation; if (isDestroyed && !isCleanedUp) Release(); } public override void Draw(GameTime gameTime) { model.CopyAbsoluteBoneTransformsTo(bones); // Render the skinned mesh. foreach (ModelMesh mesh in model.Meshes) { foreach (BasicEffect effect in mesh.Effects) { effect.View = Global3dGame.CurrentCamera.View; effect.Projection = Global3dGame.CurrentCamera.Projection; effect.World = bones[mesh.ParentBone.Index] * GetWorldMatrix(); effect.EnableDefaultLighting(); effect.GraphicsDevice.RenderState.AlphaBlendEnable = false; effect.GraphicsDevice.RenderState.DepthBufferEnable = true; } mesh.Draw(); } } #endregion #region Methods public virtual bool CollisionCallBack(CollisionSkin skin0, CollisionSkin skin1) { if (skin1.Owner == null || skin1.Owner.ExternalData == null) return true; // if you wanted to know the position of the box you collided with.... Vector3 otherBoxesPosition = skin1.Owner.Position; // xxxxxxxxxxxxxxxxxxxxxxxx // Using a little reflection, we can see exactly what kind of object we collided with. // WARNING: No Guarantee that the members 'ExternalData' or even 'Owner' won't be null if (skin1.Owner.ExternalData is CollidableObject) { // i collided with another instance of my type of object return false; // allow this object to pass through } // if you inherit from this class, and set the 'body.ExternalData' to the gameComponent instance // you can kill that instance when you collide with it.... if (skin1.Owner.ExternalData is GameComponent) ((GameComponent)skin1.Owner.ExternalData).Enabled = false; if (skin1.Owner.ExternalData is DrawableGameComponent) ((DrawableGameComponent)skin1.Owner.ExternalData).Visible = false; // for everything else, we still want the collision handled by the physics engine after our logic // so we return true return true; } public void MoveTo(Vector3 pos, Quaternion rot) { body.MoveTo(pos, Matrix.CreateFromQuaternion(rot)); _skin.ApplyLocalTransform(new Transform(-com, Matrix.CreateFromQuaternion(rot))); } private Vector3 SetMass(float mass) { PrimitiveProperties primitiveProperties = new PrimitiveProperties( PrimitiveProperties.MassDistributionEnum.Solid, PrimitiveProperties.MassTypeEnum.Mass, mass); float junk; Vector3 com; Matrix it; Matrix itCoM; Skin.GetMassProperties(primitiveProperties, out junk, out com, out it, out itCoM); body.BodyInertia = itCoM; body.Mass = junk; return com; } private void RebuildSkinPrimitive(Vector3 newScale) { this._skin.RemoveAllPrimitives(); Box box = new Box(-(newScale * 0.5f), Matrix.Identity, newScale); _skin.AddPrimitive(box, _materialProperties); } public void SetScale(Vector3 newScale) { this.scale = newScale; RebuildSkinPrimitive(scale); } private Matrix GetWorldMatrix() { return Matrix.CreateScale(scale) * rotation * Matrix.CreateTranslation(position); } public void Destroy() { isDestroyed = true; } private void Release() { this.body.DisableBody(); isCleanedUp = true; this.Enabled = false; this.Visible = false; } #endregion } 

 float clamped = MathHelper.Clamp(rotationAngle, MathHelper.Pi, MathHelper.TwoPi); runPlayer.CharacterBody.SetOrientation(Matrix.CreateRotationY(clamped)); 

 public class DesiredVelocityBody : Body { public Vector3 desiredVelocity; public override void AddExternalForces(float dt) { ClearForces(); Vector3 deltaVel = desiredVelocity - Velocity; bool running = true; if (desiredVelocity.LengthSquared() < JigLibX.Math.JiggleMath.Epsilon) running = false; else deltaVel.Normalize(); deltaVel.Y = 0.0f; // start fast, slow down slower if (running) deltaVel *= 10.0f; else deltaVel *= 2.0f; float forceFactor = 1000.0f; AddBodyForce(deltaVel * Mass * dt * forceFactor); AddGravityToExternalForce(); } } 

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using qkGames; using JigLibX.Physics; using Microsoft.Xna.Framework; using JigLibX.Collision; using Microsoft.Xna.Framework.Graphics; using JigLibX.Geometry; using JigLibX.Math; using Microsoft.Xna.Framework.Input; namespace qkGames { class CharacterObject : PhysicsObject { public Character CharacterBody {get; set;} public CharacterObject(Vector3 position) : base() { Body = new Character(); CollisionSkin = new CollisionSkin(Body); //public Vector3 DesiredVelocity { get; set; } Capsule capsule = new Capsule(Vector3.Zero, Matrix.CreateRotationX(MathHelper.PiOver2), 1.0f, 1.0f); CollisionSkin.AddPrimitive(capsule, (int)MaterialTable.MaterialID.NotBouncyNormal, new MaterialProperties(0.0f, 0.0f, 0.0f)); Body.CollisionSkin = this.CollisionSkin; Vector3 com = SetMass(1.0f); Body.MoveTo(position + com, Matrix.Identity); CollisionSkin.ApplyLocalTransform(new Transform(-com, Matrix.Identity)); //Body.BodyInertia(0.0f, 0.0f, 0.0f); //Body.SetBodyInvInertia(0.0f, 0.0f, 0.0f); CharacterBody = Body as Character; Body.AllowFreezing = false; Body.EnableBody(); } // public override void ApplyEffects(BasicEffect effect) //{ //throw new NotImplementedException(); //} } class ASkinPredicate : CollisionSkinPredicate1 { public override bool ConsiderSkin(CollisionSkin skin0) { if (!(skin0.Owner is Character)) return true; else return false; } } class Character : Body { public Character() : base() { } public Vector3 DesiredVelocity { get; set; } private bool doJump = false; public void DoJump() { doJump = true; } public override void AddExternalForces(float dt) { ClearForces(); if (doJump) { foreach (CollisionInfo info in CollisionSkin.Collisions) { Vector3 N = info.DirToBody0; if (this == info.SkinInfo.Skin1.Owner) Vector3.Negate(ref N, out N); if (Vector3.Dot(N, Orientation.Up) > 0.7f) { Vector3 vel = Velocity; vel.Y = 5.0f; Velocity = vel; break; } } } Vector3 deltaVel = DesiredVelocity - Velocity; bool running = true; if (DesiredVelocity.LengthSquared() < JiggleMath.Epsilon) running = false; else deltaVel.Normalize(); deltaVel.Y = 0.0f; // start fast, slow down slower if (running) deltaVel *= 10.0f; else deltaVel *= 2.0f; float forceFactor = 1000.0f; AddBodyForce(deltaVel * Mass * dt * forceFactor); doJump = false; AddGravityToExternalForce(); } } } 

 using System; using JigLibX.Geometry; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Graphics; namespace qkGames { public class Terrain : Component, I3DComponent { // Height representation public float[,] heightData; // Physics height representation HeightMapInfo heightMapInfo; // Physics object HeightMapObject heightMapObject; // Terrain texture // Texture2D texture; public TerrainMaterial Material; // Vertex and index buffers VertexDeclaration myVertexDeclaration; VertexBuffer terrainVertexBuffer; IndexBuffer terrainIndexBuffer; // Effect BasicEffect basicEffect; // I3DComponent values Vector3 position = Vector3.Zero; Matrix rotation = Matrix.Identity; Vector3 scale = new Vector3(1, 1, -1); BoundingBox boundingBox = new BoundingBox(new Vector3(-1), new Vector3(1)); public Vector3 Position { get { return position; } set { position = value; } } public Vector3 EulerRotation { get { return MathUtil.MatrixToVector3(Rotation); } set { this.Rotation = MathUtil.Vector3ToMatrix(value); } } public Matrix Rotation { get { return rotation; } set { rotation = value; } } public Vector3 Scale { get { return scale; } set { scale = value; } } public BoundingBox BoundingBox { get { return boundingBox; } } // Constructors public Terrain(Texture2D HeightMap, Texture2D Texture) : base() { Setup(HeightMap, Texture); } public Terrain(Texture2D HeightMap, Texture2D Texture, GameScreen Parent) : base(Parent) { Setup(HeightMap, Texture); } void Setup(Texture2D Heightmap, Texture2D Texture) { // Load height data heightData = CreateTerrain(Heightmap); // Create vertex and index buffers myVertexDeclaration = new VertexDeclaration(Engine.GraphicsDevice, VertexPositionNormalTexture.VertexElements); VertexPositionNormalTexture[] terrainVertices = CreateVertices(); int[] terrainIndices = CreateIndices(); terrainVertices = GenerateNormalsForTriangleStrip(terrainVertices, terrainIndices); CreateBuffers(terrainVertices, terrainIndices); // Setup effect Material = new TerrainMaterial(Texture); } // Sets up terrain, texture, etc private float[,] CreateTerrain(Texture2D heightMap) { // Minimum and maximum heights for terrain float minimumHeight = 0; float maximumHeight = 255; // Width and height of terrain (from heightmap) int width = heightMap.Width; int height = heightMap.Height; // Setup bounding box with width and height boundingBox = new BoundingBox( new Vector3(-width / 2, maximumHeight - minimumHeight, -height / 2), new Vector3(width / 2, maximumHeight - minimumHeight, height / 2)); // Get data from heightmap Color[] heightMapColors = new Color[width * height]; heightMap.GetData<Color>(heightMapColors); // Setup height data from heightmap data float[,] heightData = new float[width, height]; for (int x = 0; x < width; x++) for (int y = 0; y < height; y++) { heightData[x, y] = heightMapColors[x + y * width].R; if (heightData[x, y] < minimumHeight) minimumHeight = heightData[x, y]; if (heightData[x, y] > maximumHeight) maximumHeight = heightData[x, y]; } for (int x = 0; x < width; x++) for (int y = 0; y < height; y++) heightData[x, y] = (heightData[x, y] - minimumHeight) / (maximumHeight - minimumHeight) * 30.0f; // Setup physics heightMapInfo = new HeightMapInfo(heightData, 1); if (heightMapObject != null) { heightMapObject.DisableComponent(); heightMapObject = null; } heightMapObject = new HeightMapObject(heightMapInfo, new Vector2( heightMapInfo.Width / 2, -heightMapInfo.Height / 2 + heightMapInfo.Height)); return heightData; } // Set up vertices private VertexPositionNormalTexture[] CreateVertices() { // Get width and height and create new vertex array int width = heightData.GetLength(0); int height = heightData.GetLength(1); VertexPositionNormalTexture[] terrainVertices = new VertexPositionNormalTexture[width * height]; // Calculate position, normal, and texcoords for vertices int i = 0; for (int z = 0; z < height; z++) for (int x = 0; x < width; x++) { Vector3 position = new Vector3(x, heightData[x, z], -z); Vector3 normal = new Vector3(0, 0, 1); Vector2 texCoord = new Vector2((float)x / 30.0f, (float)z / 30.0f); terrainVertices[i++] = new VertexPositionNormalTexture( position, normal, texCoord); } return terrainVertices; } // Set up indices private int[] CreateIndices() { // Get width and height and create new index array int width = heightData.GetLength(0); int height = heightData.GetLength(1); int[] terrainIndices = new int[(width) * 2 * (height - 1)]; // Calculate indices for triangle int i = 0; int z = 0; while (z < height - 1) { for (int x = 0; x < width; x++) { terrainIndices[i++] = x + z * width; terrainIndices[i++] = x + (z + 1) * width; } z++; if (z < height - 1) { for (int x = width - 1; x >= 0; x--) { terrainIndices[i++] = x + (z + 1) * width; terrainIndices[i++] = x + z * width; } } z++; } return terrainIndices; } // Generates normals for a group of triangles private VertexPositionNormalTexture[] GenerateNormalsForTriangleStrip( VertexPositionNormalTexture[] vertices, int[] indices) { for (int i = 0; i < vertices.Length; i++) vertices[i].Normal = new Vector3(0, 0, 0); bool swappedWinding = false; for (int i = 2; i < indices.Length; i++) { Vector3 firstVec = vertices[indices[i - 1]].Position - vertices[indices[i]].Position; Vector3 secondVec = vertices[indices[i - 2]].Position - vertices[indices[i]].Position; Vector3 normal = Vector3.Cross(firstVec, secondVec); normal.Normalize(); if (swappedWinding) normal *= -1; if (!float.IsNaN(normal.X)) { vertices[indices[i]].Normal += normal; vertices[indices[i - 1]].Normal += normal; vertices[indices[i - 2]].Normal += normal; } swappedWinding = !swappedWinding; } for (int i = 0; i < vertices.Length; i++) vertices[i].Normal.Normalize(); return vertices; } // Sets up vertex and index buffers used for drawing private void CreateBuffers(VertexPositionNormalTexture[] vertices, int[] indices) { terrainVertexBuffer = new VertexBuffer(Engine.GraphicsDevice, VertexPositionNormalTexture.SizeInBytes * vertices.Length, BufferUsage.WriteOnly); terrainVertexBuffer.SetData(vertices); terrainIndexBuffer = new IndexBuffer(Engine.GraphicsDevice, typeof(int), indices.Length, BufferUsage.WriteOnly); terrainIndexBuffer.SetData(indices); } // Draw the terrain public override void Draw() { // Require the camera Camera camera = Engine.Services.GetService<Camera>(); if (camera == null) throw new Exception("The engine services does not contain a " + "camera service. The terrain requires a camera to draw."); // Set effect values Material.Prepare3DDraw(MathUtil.CreateWorldMatrix(position, rotation, scale)); // Get width and height int width = heightData.GetLength(0); int height = heightData.GetLength(1); // Terrain uses different vertex winding than normal models, //so set the new one Engine.GraphicsDevice.RenderState.CullMode = CullMode.CullClockwiseFace; // Start the effect Material.Effect.Begin(); // For each pass.. foreach (EffectPass pass in Material.Effect.CurrentTechnique.Passes) { // Begin the pass pass.Begin(); // Draw the terrain vertices and indices Engine.GraphicsDevice.Vertices[0].SetSource(terrainVertexBuffer, 0, VertexPositionNormalTexture.SizeInBytes); Engine.GraphicsDevice.Indices = terrainIndexBuffer; Engine.GraphicsDevice.VertexDeclaration = myVertexDeclaration; Engine.GraphicsDevice.DrawIndexedPrimitives( Microsoft.Xna.Framework.Graphics.PrimitiveType.TriangleStrip, 0, 0, width * height, 0, width * 2 * (height - 1) - 2); // End the pass pass.End(); } // End the effect Material.Effect.End(); // Set the vertex winding back Engine.GraphicsDevice.RenderState.CullMode = CullMode.CullCounterClockwiseFace; } } } 

 public override void Update() { //physics.UpdatePhysics = true; KeyboardDevice keyboard = Engine.Services.GetService<KeyboardDevice>(); MouseDevice mouse = Engine.Services.GetService<MouseDevice>(); Camera cam = (Camera)Engine.Services.GetService<Camera>(); Physics physics = Engine.Services.GetService<Physics>(); // Vector3 inputModifier = new Vector3( // (keyboard.IsKeyDown(Keys.A) ? -1 : 0) + (keyboard.IsKeyDown(Keys.D) ? 1 : 0), // (keyboard.IsKeyDown(Keys.Q) ? -1 : 0) + (keyboard.IsKeyDown(Keys.E) ? 1 : 0), // (keyboard.IsKeyDown(Keys.W) ? -1 : 0) + (keyboard.IsKeyDown(Keys.S) ? 1 : 0) // ); //cam.IsMousePinned = true; //cam.EnableKeyboardInput = false; cam.Position = character.Body.Position + Vector3.Up; //this.IsMouseVisible = false; Vector3 moveVector = new Vector3(); float amountOfMovement = 0.5f; if (keyboard.IsKeyDown(Keys.D)) moveVector += Vector3.Right; //character.Body.MoveTo(moveVector, cameraRotation); if (keyboard.IsKeyDown(Keys.A)) moveVector += Vector3.Left; if (keyboard.IsKeyDown(Keys.S)) moveVector += Vector3.Backward; if (keyboard.IsKeyDown(Keys.W)) moveVector += Vector3.Forward; Matrix cameraRotation = Matrix.CreateRotationX(cam.Angles.X) * Matrix.CreateRotationY(cam.Angles.Y); moveVector = Vector3.Transform(moveVector, cameraRotation); JiggleMath.NormalizeSafe(ref moveVector); moveVector *= amountOfMovement; //character.Body.MoveTo(moveVector, Matrix.Identity); character.CharacterBody.DesiredVelocity = moveVector; if (keyboard.IsKeyDown(Keys.Space)) character.CharacterBody.DoJump(); cam.RotateTranslate(new Vector3(mouse.Delta.Y * -.002f, mouse.Delta.X * -.002f, 0), Vector3.Zero * .05f); 

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using Microsoft.Xna.Framework; namespace qkGames { public class Camera : Component, I3DComponent { //basic camera class Vector3 rotation; Vector3 translation; //internal values Vector3 position = Vector3.Zero; Matrix rotationMatrix = Matrix.Identity; Vector3 target = new Vector3(0, 0, -1); Vector3 up = Vector3.Up; Matrix view; Matrix projection; private Vector2 angles = Vector2.Zero; //camera look at public Vector2 Angles { get { return angles; } } public virtual Vector3 Target { get { return target; } set { Vector3 forward = Vector3.Normalize(position - value); Vector3 right = Vector3.Normalize(Vector3.Cross(forward, Vector3.Up)); Vector3 up = Vector3.Normalize(Vector3.Cross(right, forward)); Matrix test = Matrix.Identity; test.Forward = forward; test.Right = right; test.Up = up; angles.X = -(float)Math.Asin(test.M32); angles.Y = -(float)Math.Asin(test.M13); target = value; } } // the view and proj matrixes commonly used for renderin public virtual Matrix View { get { return view; } set { view = value; } } public virtual Matrix Projection { get { return projection; } set { projection = value; } } public virtual Vector3 Up { get { return up; } set { up = value; } } public virtual Vector3 Position { get { return position; } set { position = value; } } public virtual Vector3 Scale { get { return Vector3.One; } set { } } public Vector3 EulerRotation { get { return MathUtil.MatrixToVector3(rotationMatrix); } set { rotationMatrix = MathUtil.Vector3ToMatrix(value); } } //the rotation matrix used by camera an up public virtual Matrix Rotation { get { return rotationMatrix; } set { rotationMatrix = value; } } public virtual BoundingBox BoundingBox { get { return new BoundingBox(position - Vector3.One, position + Vector3.One); } } //Constructors public Camera(GameScreen Parent) : base(Parent) { } public Camera() : base() { } //update camera public void RotateTranslate(Vector3 Rotation, Vector3 Trans) { translation += Trans; rotation += Rotation; } public override void Update() { //calc the direction from the postition to the target and normalise Vector3 newForward = Target - position; newForward.Normalize(); //set the rotation matrix and forward to this vector Matrix rotationMatrixCopy = this.Rotation; rotationMatrixCopy.Forward = newForward; //save a copy of up Vector3 referenceVector = Vector3.Up; //incase camera is pointed perfectly on y axis if (rotationMatrixCopy.Forward.Y == referenceVector.Y || rotationMatrixCopy.Forward.Y == -referenceVector.Y) referenceVector = Vector3.Backward; //calc the parts of rotation matrix rotationMatrixCopy.Right = Vector3.Cross(this.Rotation.Forward, referenceVector); rotationMatrixCopy.Up = Vector3.Cross(this.Rotation.Right, this.Rotation.Forward); this.Rotation = rotationMatrixCopy; //use rotation to find new up up = rotationMatrixCopy.Up; //recalc view and proj View = Matrix.CreateLookAt(position, Target, Up); Projection = MathUtil.CreateProjectionMatrix(); } } } 

 CharacterObject.CharacterBody.DesiredVelocity = Direction * movement * (float)e.Time.ElapsedGameTime.TotalMilliseconds * 3.0f; 

 CharacterObject.CharacterBody.DesiredVelocity = (Direction * movement); 

 CharacterObject.CharacterBody.DesiredVelocity = (Direction * movement) / (float)e.Time.ElapsedGameTime.TotalSeconds; 

  float frac; CollisionSkin skin; Vector3 pos, normal; ImmovableSkinPredicate pred = new ImmovableSkinPredicate(); PhysicsSys.CollisionSystem.SegmentIntersect(out frac, out skin, out pos, out normal, new Segment(Camera.Position, Character.Position), pred); if ((skin != null )&& (skin.Owner != null)&&(skin.Owner != Character.collisionBody)) { // problem } else { // no problem } 

 YourObject.Skin.callbackFn += new CollisionCallbackFn(handleCollisionDetection);