private void PickMultiBody(MultiBodyLinkCollider collider, ref Vector3 pickPosition)
        {
            MultiBody multiBody = collider.MultiBody;

            if (multiBody == null)
            {
                return;
            }

            _prevCanSleep      = multiBody.CanSleep;
            multiBody.CanSleep = false;
            Vector3 pivotInA = multiBody.WorldPosToLocal(collider.Link, pickPosition);

            var p2p = new MultiBodyPoint2Point(multiBody, collider.Link, null, pivotInA, pickPosition)
            {
                MaxAppliedImpulse = 2
            };

            var world = _demo.Simulation.World as MultiBodyDynamicsWorld;

            world.AddMultiBodyConstraint(p2p);
            _multiBodyPickConstraint = p2p;
        }
Exemple #2
0
        private void HandleMouseInput()
        {
            if (Input.MousePressed != MouseButtons.None)
            {
                Vector3 rayTo = GetRayTo(Input.MousePoint, FreeLook.Eye, FreeLook.Target, Graphics.FieldOfView);

                if (Input.MousePressed == MouseButtons.Right)
                {
                    Vector3 rayFrom = FreeLook.Eye;

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

                                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
                                    };

                                    Simulation.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);
                                    Simulation.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);
                                     */
                                }
                            }
                        }
                        else
                        {
                            var multiCol = rayCallback.CollisionObject as MultiBodyLinkCollider;
                            if (multiCol != null && multiCol.MultiBody != null)
                            {
                                MultiBody mb = multiCol.MultiBody;

                                prevCanSleep = mb.CanSleep;
                                mb.CanSleep  = false;
                                Vector3 pivotInA = mb.WorldPosToLocal(multiCol.Link, pickPos);

                                var p2p = new MultiBodyPoint2Point(mb, multiCol.Link, null, pivotInA, pickPos);
                                p2p.MaxAppliedImpulse = 2;

                                (Simulation.World as MultiBodyDynamicsWorld).AddMultiBodyConstraint(p2p);
                                pickingMultiBodyPoint2Point = p2p;
                            }
                        }
                        oldPickingDist = (pickPos - rayFrom).Length;
                    }
                    rayCallback.Dispose();
                }
            }
            else if (Input.MouseReleased == MouseButtons.Right)
            {
                RemovePickingConstraint();
            }

            // Mouse movement
            if (Input.MouseDown == MouseButtons.Right)
            {
                MovePickedBody();
            }
        }
Exemple #3
0
        public virtual void OnHandleInput()
        {
            if (Input.KeysPressed.Count != 0)
            {
                switch (Input.KeysPressed[0])
                {
                case Keys.Escape:
                case Keys.Q:
                    Graphics.Form.Close();
                    return;

                case Keys.F1:
                    MessageBox.Show(
                        "Move using WASD + shift\n" +
                        "Left click - point camera\n" +
                        "Right click - pick up an object using a Point2PointConstraint\n" +
                        "Right click + shift - pick up an object using a fixed Generic6DofConstraint\n" +
                        "Space - shoot box\n" +
                        "Q - quit\n" +
                        Graphics.InfoText,
                        "Help");
                    // Key release won't be captured
                    Input.KeysDown.Remove(Keys.F1);
                    break;

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

                case Keys.F8:
                    Input.ClearKeyCache();
                    GraphicsLibraryManager.ExitWithReload = true;
                    Graphics.Form.Close();
                    break;

                case Keys.F11:
                    Graphics.IsFullScreen = !Graphics.IsFullScreen;
                    break;

                case (Keys.Control | Keys.F):
                    const int maxSerializeBufferSize = 1024 * 1024 * 5;
                    using (var serializer = new DefaultSerializer(maxSerializeBufferSize))
                    {
                        World.Serialize(serializer);
                        byte[] dataBytes = new byte[serializer.CurrentBufferSize];
                        System.Runtime.InteropServices.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.Space:
                    ShootBox(Freelook.Eye, GetRayTo(Input.MousePoint, Freelook.Eye, Freelook.Target, Graphics.FieldOfView));
                    break;

                case Keys.Return:
                    ClientResetScene();
                    break;
                }
            }

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

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

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

                                    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
                                        };

                                        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);
                                        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);
                                         */
                                    }
                                }
                            }
                            else
                            {
                                MultiBodyLinkCollider multiCol = rayCallback.CollisionObject as MultiBodyLinkCollider;
                                if (multiCol != null && multiCol.MultiBody != null)
                                {
                                    MultiBody mb = multiCol.MultiBody;

                                    prevCanSleep = mb.CanSleep;
                                    mb.CanSleep  = false;
                                    Vector3 pivotInA = mb.WorldPosToLocal(multiCol.Link, pickPos);

                                    MultiBodyPoint2Point p2p = new MultiBodyPoint2Point(mb, multiCol.Link, null, pivotInA, pickPos);
                                    p2p.MaxAppliedImpulse = 2;

                                    (World as MultiBodyDynamicsWorld).AddMultiBodyConstraint(p2p);
                                    pickingMultiBodyPoint2Point = p2p;
                                }
                            }
                            oldPickingDist = (pickPos - rayFrom).Length;
                        }
                        rayCallback.Dispose();
                    }
                }
            }
            else if (Input.MouseReleased == MouseButtons.Right)
            {
                RemovePickingConstraint();
            }

            // Mouse movement
            if (Input.MouseDown == MouseButtons.Right)
            {
                MovePickedBody();
            }
        }
Exemple #4
0
        public virtual void OnHandleInput()
        {
            if (Input.KeysPressed.Count != 0)
            {
                switch (Input.KeysPressed[0])
                {
                case Keys.Escape:
                case Keys.Q:
                    Graphics.Form.Close();
                    return;

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

                case Keys.F8:
                    Input.ClearKeyCache();
                    GraphicsLibraryManager.ExitWithReload = true;
                    Graphics.Form.Close();
                    break;

                case Keys.F11:
                    Graphics.IsFullScreen = !Graphics.IsFullScreen;
                    break;

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

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

                case Keys.Return:
                    ClientResetScene();
                    break;
                }
            }

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

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

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

                                    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
                                        };

                                        _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);
                                        _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);
                                         */
                                    }
                                }
                            }
                            else
                            {
                                MultiBodyLinkCollider multiCol = rayCallback.CollisionObject as MultiBodyLinkCollider;
                                if (multiCol != null && multiCol.MultiBody != null)
                                {
                                    MultiBody mb = multiCol.MultiBody;

                                    prevCanSleep = mb.CanSleep;
                                    mb.CanSleep  = false;
                                    Vector3 pivotInA = mb.WorldPosToLocal(multiCol.Link, pickPos);

                                    MultiBodyPoint2Point p2p = new MultiBodyPoint2Point(mb, multiCol.Link, null, pivotInA, pickPos);
                                    p2p.MaxAppliedImpulse = 2;

                                    (World as MultiBodyDynamicsWorld).AddMultiBodyConstraint(p2p);
                                    pickingMultiBodyPoint2Point = p2p;
                                }
                            }
                            oldPickingDist = (pickPos - rayFrom).Length;
                        }
                        rayCallback.Dispose();
                    }
                }
            }
            else if (Input.MouseReleased == MouseButtons.Right)
            {
                RemovePickingConstraint();
            }

            // Mouse movement
            if (Input.MouseDown == MouseButtons.Right)
            {
                MovePickedBody();
            }
        }