Exemple #1
0
 protected virtual void Dispose(bool disposing)
 {
     if (disposing)
     {
         PhysicsContext.ExitPhysics();
     }
 }
Exemple #2
0
 /// <summary>
 /// Implements logic to update any relevant sample state.
 /// </summary>
 protected virtual void OnUpdate()
 {
     if (Freelook.Update(FrameDelta))
     {
         Device.SetTransform(TransformState.View, Freelook.View);
     }
     PhysicsContext.Update(FrameDelta);
 }
Exemple #3
0
 /// <summary>
 /// Disposes of object resources.
 /// </summary>
 /// <param name="disposeManagedResources">If true, managed resources should be
 /// disposed of in addition to unmanaged resources.</param>
 protected virtual void Dispose(bool disposeManagedResources)
 {
     if (disposeManagedResources)
     {
         apiContext.Dispose();
         if (Form.IsDisposed == false)
         {
             Form.Dispose();
         }
         Fps.Dispose();
         MeshFactory.Dispose();
         PhysicsContext.Dispose();
     }
 }
Exemple #4
0
        public void Run()
        {
            Input    = new Input(Form);
            Freelook = new FreeLook(Input);

            Initialize();
            CullingEnabled = isCullingEnabled;
            OnInitialize();
            if (PhysicsContext.World == null)
            {
                PhysicsContext.InitPhysics();
            }

            /*
             * if (_isDebugDrawEnabled)
             * {
             *  if (_debugDrawer == null)
             *  {
             *      _debugDrawer = new PhysicsDebugDraw(this);
             *      _debugDrawer.DebugMode = DebugDrawMode;
             *  }
             *  if (PhysicsContext.World != null)
             *  {
             *      PhysicsContext.World.DebugDrawer = _debugDrawer;
             *  }
             * }
             */
            UpdateView();
            SetInfoText();

            RenderLoop.Run(Form, () =>
            {
                OnHandleInput();
                OnUpdate();
                if (Form.WindowState != FormWindowState.Minimized)
                {
                    clock.StartRender();
                    Render();
                    clock.StopRender();
                }
            });
        }
Exemple #5
0
        protected virtual void OnHandleInput()
        {
            if (Input.KeysPressed.Count != 0)
            {
                Keys key = Input.KeysPressed[0];
                switch (key)
                {
                case Keys.Escape:
                case Keys.Q:
                    Quit();
                    return;

                case Keys.F3:
                    IsDebugDrawEnabled = !IsDebugDrawEnabled;
                    break;

                case Keys.F11:
                    ToggleFullScreen();
                    break;

                case Keys.Space:
                    PhysicsContext.ShootBox(Freelook.Eye, GetRayTo(Input.MousePoint, Freelook.Eye, Freelook.Target, FieldOfView));
                    break;
                }
            }

            if (Input.MousePressed != MouseButtonFlags.None)
            {
                Vector3 rayTo = GetRayTo(Input.MousePoint, Freelook.Eye, Freelook.Target, FieldOfView);

                if (Input.MousePressed == MouseButtonFlags.RightDown)
                {
                    if (PhysicsContext.World != null)
                    {
                        Vector3 rayFrom = Freelook.Eye;

                        ClosestRayResultCallback rayCallback = new ClosestRayResultCallback(ref rayFrom, ref rayTo);
                        PhysicsContext.World.RayTest(rayFrom, rayTo, rayCallback);
                        if (rayCallback.HasHit)
                        {
                            RigidBody body = rayCallback.CollisionObject as RigidBody;
                            if (body != null)
                            {
                                if (!(body.IsStaticObject || body.IsKinematicObject))
                                {
                                    pickedBody = body;
                                    pickedBody.ActivationState = ActivationState.DisableDeactivation;

                                    Vector3 pickPos    = rayCallback.HitPointWorld;
                                    Vector3 localPivot = Vector3.TransformCoordinate(pickPos, Matrix.Invert(body.CenterOfMassTransform));

                                    if (use6Dof)
                                    {
                                        Generic6DofConstraint dof6 = new Generic6DofConstraint(body, Matrix.Translation(localPivot), false);
                                        dof6.LinearLowerLimit  = Vector3.Zero;
                                        dof6.LinearUpperLimit  = Vector3.Zero;
                                        dof6.AngularLowerLimit = Vector3.Zero;
                                        dof6.AngularUpperLimit = Vector3.Zero;

                                        PhysicsContext.World.AddConstraint(dof6);
                                        pickConstraint = dof6;

                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 0);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 1);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 2);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 3);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 4);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 5);

                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 0);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 1);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 2);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 3);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 4);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 5);
                                    }
                                    else
                                    {
                                        Point2PointConstraint p2p = new Point2PointConstraint(body, localPivot);
                                        PhysicsContext.World.AddConstraint(p2p);
                                        pickConstraint           = p2p;
                                        p2p.Setting.ImpulseClamp = 30;
                                        //very weak constraint for picking
                                        p2p.Setting.Tau = 0.001f;

                                        /*
                                         * p2p.SetParam(ConstraintParams.Cfm, 0.8f, 0);
                                         * p2p.SetParam(ConstraintParams.Cfm, 0.8f, 1);
                                         * p2p.SetParam(ConstraintParams.Cfm, 0.8f, 2);
                                         * p2p.SetParam(ConstraintParams.Erp, 0.1f, 0);
                                         * p2p.SetParam(ConstraintParams.Erp, 0.1f, 1);
                                         * p2p.SetParam(ConstraintParams.Erp, 0.1f, 2);
                                         */
                                    }
                                    use6Dof = !use6Dof;

                                    oldPickingDist = (pickPos - rayFrom).Length();
                                }
                            }
                        }
                    }
                }
                else if (Input.MousePressed == MouseButtonFlags.RightUp)
                {
                    if (pickConstraint != null && PhysicsContext.World != null)
                    {
                        PhysicsContext.World.RemoveConstraint(pickConstraint);
                        pickConstraint.Dispose();
                        pickConstraint = null;
                        pickedBody.ForceActivationState(ActivationState.ActiveTag);
                        pickedBody.DeactivationTime = 0;
                        pickedBody = null;
                    }
                }
            }

            // Mouse movement
            if (Input.MouseDown == MouseButtonFlags.RightDown)
            {
                if (pickConstraint != null)
                {
                    Vector3 newRayTo = GetRayTo(Input.MousePoint, Freelook.Eye, Freelook.Target, FieldOfView);

                    if (pickConstraint.ConstraintType == TypedConstraintType.D6)
                    {
                        Generic6DofConstraint pickCon = pickConstraint as Generic6DofConstraint;

                        //keep it at the same picking distance
                        Vector3 rayFrom = Freelook.Eye;
                        Vector3 dir     = newRayTo - rayFrom;
                        dir.Normalize();
                        dir *= oldPickingDist;
                        Vector3 newPivotB = rayFrom + dir;

                        Matrix tempFrameOffsetA = pickCon.FrameOffsetA;
                        tempFrameOffsetA.M41 = newPivotB.X;
                        tempFrameOffsetA.M42 = newPivotB.Y;
                        tempFrameOffsetA.M43 = newPivotB.Z;
                        pickCon.FrameOffsetA = tempFrameOffsetA;
                    }
                    else
                    {
                        Point2PointConstraint pickCon = pickConstraint as Point2PointConstraint;

                        //keep it at the same picking distance
                        Vector3 rayFrom = Freelook.Eye;
                        Vector3 dir     = newRayTo - rayFrom;
                        dir.Normalize();
                        dir *= oldPickingDist;
                        pickCon.PivotInB = rayFrom + dir;
                    }
                }
            }
        }
Exemple #6
0
        protected virtual void OnHandleInput()
        {
            if (Input.KeysPressed.Count != 0)
            {
                switch (Input.KeysPressed[0])
                {
                case Keys.Escape:
                case Keys.Q:
                    Form.Close();
                    return;

                case Keys.F1:
                    MessageBox.Show(
                        "Move using mouse and WASD + shift\n" +
                        "Space - Shoot box\n" +
                        "Q - Quit\n\n" +
                        "G - Toggle shadows\n" +
                        "L - Toggle deferred lighting\n",
                        "Help");
                    return;

                case Keys.F3:
                    //IsDebugDrawEnabled = !IsDebugDrawEnabled;
                    break;

                case Keys.F11:
                    //ToggleFullScreen();
                    break;

                case (Keys.Control | Keys.F):
                    const int maxSerializeBufferSize = 1024 * 1024 * 5;
                    using (var serializer = new DefaultSerializer(maxSerializeBufferSize))
                    {
                        PhysicsContext.World.Serialize(serializer);

                        byte[] dataBytes = new byte[serializer.CurrentBufferSize];
                        Marshal.Copy(serializer.BufferPointer, dataBytes, 0, dataBytes.Length);
                        using (var file = new System.IO.FileStream("world.bullet", System.IO.FileMode.Create))
                        {
                            file.Write(dataBytes, 0, dataBytes.Length);
                        }
                    }
                    break;

                case Keys.G:
                    shadowsEnabled = !shadowsEnabled;
                    break;

                case Keys.L:
                    deferredLightingEnabled = !deferredLightingEnabled;
                    break;

                case Keys.Space:
                    PhysicsContext.ShootBox(Freelook.Eye, GetRayTo(Input.MousePoint, Freelook.Eye, Freelook.Target, FieldOfView));
                    break;
                }
            }

            if (Input.MousePressed != MouseButtons.None)
            {
                Vector3 rayTo = GetRayTo(Input.MousePoint, Freelook.Eye, Freelook.Target, FieldOfView);

                if (Input.MousePressed == MouseButtons.Right)
                {
                    if (PhysicsContext.World != null)
                    {
                        Vector3 rayFrom = Freelook.Eye;

                        var rayCallback = new ClosestRayResultCallback(ref rayFrom, ref rayTo);
                        PhysicsContext.World.RayTest(rayFrom, rayTo, rayCallback);
                        if (rayCallback.HasHit)
                        {
                            RigidBody body = rayCallback.CollisionObject as RigidBody;
                            if (body != null)
                            {
                                if (!(body.IsStaticObject || body.IsKinematicObject))
                                {
                                    pickedBody = body;
                                    pickedBody.ActivationState = ActivationState.DisableDeactivation;

                                    Vector3 pickPos    = rayCallback.HitPointWorld;
                                    Vector3 localPivot = Vector3.TransformCoordinate(pickPos, Matrix.Invert(body.CenterOfMassTransform));

                                    if (Input.KeysDown.Contains(Keys.ShiftKey))
                                    {
                                        Generic6DofConstraint dof6 = new Generic6DofConstraint(body, Matrix.Translation(localPivot), false)
                                        {
                                            LinearLowerLimit  = Vector3.Zero,
                                            LinearUpperLimit  = Vector3.Zero,
                                            AngularLowerLimit = Vector3.Zero,
                                            AngularUpperLimit = Vector3.Zero
                                        };
                                        pickConstraint = dof6;

                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 0);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 1);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 2);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 3);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 4);
                                        dof6.SetParam(ConstraintParam.StopCfm, 0.8f, 5);

                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 0);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 1);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 2);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 3);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 4);
                                        dof6.SetParam(ConstraintParam.StopErp, 0.1f, 5);
                                    }
                                    else
                                    {
                                        var p2p = new Point2PointConstraint(body, localPivot);
                                        pickConstraint           = p2p;
                                        p2p.Setting.ImpulseClamp = 30;
                                        //very weak constraint for picking
                                        p2p.Setting.Tau = 0.001f;

                                        /*
                                         * p2p.SetParam(ConstraintParams.Cfm, 0.8f, 0);
                                         * p2p.SetParam(ConstraintParams.Cfm, 0.8f, 1);
                                         * p2p.SetParam(ConstraintParams.Cfm, 0.8f, 2);
                                         * p2p.SetParam(ConstraintParams.Erp, 0.1f, 0);
                                         * p2p.SetParam(ConstraintParams.Erp, 0.1f, 1);
                                         * p2p.SetParam(ConstraintParams.Erp, 0.1f, 2);
                                         */
                                    }
                                    PhysicsContext.World.AddConstraint(pickConstraint);

                                    oldPickingDist = (pickPos - rayFrom).Length();
                                }
                            }
                        }
                        rayCallback.Dispose();
                    }
                }
            }
            else if (Input.MouseReleased == MouseButtons.Right)
            {
                RemovePickingConstraint();
            }

            // Mouse movement
            if (Input.MouseDown == MouseButtons.Right)
            {
                if (pickConstraint != null)
                {
                    Vector3 newRayTo = GetRayTo(Input.MousePoint, Freelook.Eye, Freelook.Target, FieldOfView);

                    if (pickConstraint.ConstraintType == TypedConstraintType.D6)
                    {
                        Generic6DofConstraint pickCon = pickConstraint as Generic6DofConstraint;

                        //keep it at the same picking distance
                        Vector3 rayFrom = Freelook.Eye;
                        Vector3 dir     = newRayTo - rayFrom;
                        dir.Normalize();
                        dir *= oldPickingDist;
                        Vector3 newPivotB = rayFrom + dir;

                        Matrix tempFrameOffsetA = pickCon.FrameOffsetA;
                        tempFrameOffsetA.M41 = newPivotB.X;
                        tempFrameOffsetA.M42 = newPivotB.Y;
                        tempFrameOffsetA.M43 = newPivotB.Z;
                        pickCon.SetFrames(tempFrameOffsetA, pickCon.FrameOffsetB);
                    }
                    else
                    {
                        Point2PointConstraint pickCon = pickConstraint as Point2PointConstraint;

                        //keep it at the same picking distance
                        Vector3 rayFrom = Freelook.Eye;
                        Vector3 dir     = newRayTo - rayFrom;
                        dir.Normalize();
                        dir *= oldPickingDist;
                        pickCon.PivotInB = rayFrom + dir;
                    }
                }
            }
        }
Exemple #7
0
 public BspToBulletConverter(PhysicsContext context)
 {
     this.context = context;
 }