Пример #1
0
        /// <summary>
        /// 设置物体被抓取
        /// </summary>
        /// <param name="target"></param>
        /// <param name="zValue"></param>
        public void SetObjectGrab(GameObject target, float zValue)
        {
            //停止手上已经抓取的
            if (OperateObject != null)
            {
                OperateObjectHandler();

                OperateObject = null;
            }

            var feature = target.GetComponent <FeaturesObjectController>();

            if (feature == null)
            {
                throw new Exception("设置被抓取的物体不存在FeatureObjectController脚本");
            }

            operaObject   = feature.Opera;
            OperateObject = HandleGrab(feature.operaType);

            if (OperateObject != null)
            {
                OperateObject.HandStatus = MInputHandStatus.Grabing;
                InputHand.HandStatus     = MInputHandStatus.Grabing;

                //设置物体被抓取
                if (OnSetGrab != null)
                {
                    OnSetGrab(OperateObject, InputHand.HandIndex, zValue);
                }

                EventHandGrabObject.SendListener(OperateObject.GrabObject, InputHand.HandIndex);
                EventHandGrabObjectKey.SendListener(OperateObject.GrabObject, InputHand.HandIndex);
            }
        }
Пример #2
0
 /// <summary>
 /// 抓取设置
 /// </summary>
 /// <param name="operate">Operate.</param>
 /// <param name="handIndex">Hand index.</param>
 public void OnGrabObject(IOperateObject operate, int handIndex)
 {
     if (HandIndex != handIndex)
     {
         return;
     }
     Offset        = MUtility.GetOffsetPosition(Operate.InputHand.ScreenPoint, operate.GrabObject);
     OperateObject = operate;
 }
Пример #3
0
        /// <summary>
        /// 移动设置
        /// </summary>
        /// <param name="operate"></param>
        /// <param name="handIndex"></param>
        void OnLeftGrabObject(IOperateObject operate, int handIndex)
        {
            if (handIndex != InputHands[1].HandIndex)
            {
                return;
            }

            leftOffset             = GetOffsetPosition(InputHands[1].ScreenPoint, operate.GrabObject);
            this.leftOperateObject = operate;
        }
Пример #4
0
        /// <summary>
        /// 移动设置
        /// </summary>
        /// <param name="operate"></param>
        /// <param name="handIndex"></param>
        void OnGrabObject(IOperateObject operate, int handIndex)
        {
            if (handIndex != InputHands[0].HandIndex)
            {
                return;
            }

            offset = MUtility.GetOffsetPosition(InputHands[0].ScreenPoint, operate.GrabObject);

            this.operateObject = operate;
        }
Пример #5
0
        // 单手操作处理
        void KinectHandOne()
        {
            if (MInputKinect.IsHandActive(0))
            {
                handIndex = 0;
            }
            else if (MInputKinect.IsHandActive(1))
            {
                handIndex = 1;
            }

            //将他的屏幕坐标传递出去
            InputHands[0].OnUpdate(MInputKinect.ScreenHandPostion(handIndex));

            if (MInputKinect.HandGrip(handIndex))
            {
                InputHands[0].SetGrip();
            }

            if (MInputKinect.HandRelease(handIndex))
            {
                InputHands[0].SetIdle();
            }

            if (rightOperateObject != null)
            {
                switch (InputHands[0].HandStatus)
                {
                case MInputHandStatus.Grabing:

                    var screenDevice = MUtility.MainWorldToScreenPoint(rightOperateObject.GrabObject.transform.position);

                    Vector3 screenMouse = InputHands[0].ScreenPoint;
                    Vector3 vPos        = MUtility.MainScreenToWorldPoint(new Vector3(screenMouse.x, screenMouse.y, screenDevice.z));

                    rightOperateObject.GrabObject.transform.position = vPos - rightOffset;

                    //需要处理偏移量

                    break;

                case MInputHandStatus.Idle:

                    this.rightOperateObject = null;
                    break;

                default:
                    break;
                }
            }
        }
Пример #6
0
            /// <summary>
            /// 设置物体被抓取
            /// </summary>
            /// <param name="operate">Operate.</param>
            /// <param name="handIndex">Hand index.</param>
            public void SetGrabObject(IOperateObject operate, int handIndex, float cameraRelativeDistance)
            {
                if (HandIndex != handIndex)
                {
                    return;
                }
                Vector3 screenPoint = Operate.InputHand.ScreenPoint;

                OperateObject = operate;

                Vector3 screenMainCamera = MUtility.MainWorldToScreenPoint(MUtility.MainCamera.transform.position
                                                                           + MUtility.MainCamera.transform.forward * cameraRelativeDistance);

                Vector3 position = MUtility.MainScreenToWorldPoint(new Vector3(screenPoint.x, screenPoint.y, screenMainCamera.z));

                Offset = Vector3.zero;

                OperateObject.GrabObject.transform.position = position;
            }
Пример #7
0
        /// <summary>
        /// 设置物体被抓取
        /// </summary>
        /// <param name="operate"></param>
        /// <param name="handIndex"></param>
        /// <param name="cameraRelativeDistance"></param>
        void SetGrabObject(IOperateObject operate, int handIndex, float cameraRelativeDistance)
        {
            if (handIndex != InputHands[0].HandIndex)
            {
                return;
            }

            //Vector3 screenDevice = MUtility.MainWorldToScreenPoint(operate.GrabObject.transform.position);
            Vector3 screenpoint = InputHands[0].ScreenPoint;

            rightOperateObject = operate;

            Vector3 screenMainCamera = MUtility.MainWorldToScreenPoint(MUtility.MainCamera.transform.position
                                                                       + MUtility.MainCamera.transform.forward * cameraRelativeDistance);

            Vector3 position = MUtility.MainScreenToWorldPoint(new Vector3(screenpoint.x, screenpoint.y, screenMainCamera.z));

            rightOperateObject.GrabObject.transform.position = position;
        }
Пример #8
0
        /// <summary>
        /// 没有照射到物体时的处理
        /// </summary>
        void OnNoRayTarget()
        {
            HideHighLight();
            HideLabel();

            if (InputHand.HandStatus == MInputHandStatus.Idle)
            {
                if (operaObject != null)
                {
                    EventHandRayTargetExit.SendListener(operaObject.FeaturesObject.gameObject, InputHand.HandIndex);
                }

                //OperateObject与operaObject对象是一样的,都指定的是同一个物体
                if (OperateObject != null)
                {
                    OperateObject.HandStatus = MInputHandStatus.Idle;
                }

                operaObject   = null;
                OperateObject = null;
            }
        }
Пример #9
0
        /// <summary>
        /// 照射物体处理
        /// </summary>
        /// <param name="hit"></param>
        void OnRayTarget(RaycastHit hit)
        {
            EventHandRayTarget.SendListener(hit, InputHand.HandIndex);

            switch (InputHand.HandStatus)
            {
            case MInputHandStatus.Idle:

                if (hit.collider == null)
                {
                    OnNoRayTarget();
                    return;
                }

                if (operaObject != null && operaObject.gameObject == hit.collider.gameObject)
                {
                    return;
                }

                if (operaObject != null)
                {
                    //处理之前的
                    OnNoRayTarget();
                }

                operaObject = hit.collider.GetComponent <OperaObject>();
                EventHandRayTargetEnter.SendListener(operaObject.FeaturesObject.gameObject, InputHand.HandIndex);

                if (operaObject == null)
                {
                    return;
                }
                ShowLabel();

                //显示高亮
                ShowHightLight(false);

                break;

            case MInputHandStatus.Grip:

                if (operaObject != null && operaObject.gameObject != hit.collider.gameObject)
                {
                    return;
                }
                HideLabel();

                InputHand.HandStatus = MInputHandStatus.Grab;    //将该手状态设置为抓取状态

                break;

            case MInputHandStatus.Grab:
                if (operaObject == null)
                {
                    InputHand.HandStatus = MInputHandStatus.Idle;
                    return;
                }

                ShowHightLight(true);
                HideLabel();

                OperateObject = HandleGrab(operaObject.FeaturesObject.operaType);

                if (OperateObject != null)
                {
                    OperateObject.HandStatus = MInputHandStatus.Grabing;

                    EventHandGrabObject.SendListener(OperateObject.GrabObject, InputHand.HandIndex);
                    EventHandGrabObjectKey.SendListener(OperateObject.GrabObject, InputHand.HandIndex);
                }

                InputHand.HandStatus = MInputHandStatus.Grabing;

                break;

            case MInputHandStatus.Invalid:
                if (OnInvalid != null)
                {
                    OnInvalid(OperateObject, InputHand.HandIndex);
                }
                break;

            case MInputHandStatus.Error:

                if (OnError != null)
                {
                    OnError(OperateObject, InputHand.HandIndex);
                }

                break;

            case MInputHandStatus.Grabing:
                //不可操作中,表示正在有物体进行操作,不可进行其他操作
                if (OnGrabing != null)
                {
                    OnGrabing(OperateObject, InputHand.HandIndex);
                }

                break;

            default:
                break;
            }
        }
Пример #10
0
        /// <summary>
        /// 鼠标控制端的妹帧执行
        /// </summary>
        void OnMouseUpdate()
        {
            if (!IsEnable)
            {
                return;
            }

            //将他的屏幕坐标传递出去
            InputHands[0].OnUpdate(Input.mousePosition);

            #region  标/触摸检测

            //触摸
            if (!IsMousing && Input.touchCount >= 1)
            {
                InputHands[0].SetGrip();
                IsTouching = true;

                observedMode.OnDown();
            }

            if (Input.GetMouseButtonDown(0))
            {
                //鼠标
                if (!IsTouching && InputHands[0].IsIdleStatus)
                {
                    InputHands[0].SetGrip();
                    IsMousing = true;

                    observedMode.OnDown();
                }
            }

            if (IsTouching && Input.touchCount == 0)
            {
                InputHands[0].SetIdle();
                IsTouching = false;

                ObservedModeUpHandler();
            }

            if (Input.GetMouseButtonUp(0))
            {
                if (IsMousing && !InputHands[0].IsErrorStatus)
                {
                    InputHands[0].SetIdle();
                    IsMousing = false;

                    ObservedModeUpHandler();
                }
            }



            #endregion

            //不同模式中的不同操作
            switch (MSwitchManager.CurrentMode)
            {
            case OperateModeType.Rotate:

                observedMode.OnAchieve(InputHands[0], true);
                break;

            case OperateModeType.Zoom:

                //observedMode.OnAchieve(InputHands[0], false);
                observedMode.OnZoom();
                break;

            case OperateModeType.Tool:
                break;

            default:
                break;
            }

            if (operateObject != null)
            {
                switch (InputHands[0].HandStatus)
                {
                case MInputHandStatus.Grabing:

                    //需要处理偏移量
                    var     screenDevice = MUtility.MainWorldToScreenPoint(operateObject.GrabObject.transform.position);
                    Vector3 screenMouse  = InputHands[0].ScreenPoint;
                    Vector3 vPos         = MUtility.MainScreenToWorldPoint(new Vector3(screenMouse.x, screenMouse.y, screenDevice.z));

                    Vector3 position = vPos - offset;

                    EventUpdateObject.SendListener(operateObject.GrabObject, position, operateObject.GrabObject.transform.rotation, InputHands[0].HandIndex);

                    break;

                case MInputHandStatus.Idle:

                    this.operateObject = null;
                    break;

                default:
                    break;
                }
            }
        }
Пример #11
0
        /// <summary>
        /// 照射物体处理
        /// </summary>
        /// <param name="hit"></param>
        void OnRayTarget(RaycastHit hit, Ray ray)
        {
            switch (InputHand.HandStatus)
            {
            case MInputHandStatus.Idle:

                EventHandRayTarget.SendListener(hit, InputHand.HandIndex);
                ShowHightLight(false);          //现在是每帧检测
                if (operaObject == null)
                {
                    operaObject = hit.collider.GetComponent <OperaObject>();
                    if (operaObject == null)
                    {
                        return;
                    }
                    IdleOperateEnter();
                }
                else if (operaObject.gameObject == hit.collider.gameObject)
                {
                    //operaObject.BoxCollider.IsShake = false;

                    //RaycastHit detectionHit;
                    //if (Physics.Raycast(ray,out detectionHit,10000,1 << MOperateManager.layerRay | 1 << MOperateManager.layerObject))
                    //{
                    //    if (operaObject.gameObject != detectionHit.collider.gameObject)
                    //    {
                    //        OnNoRayTarget();
                    //        return;
                    //    }
                    //    else
                    //    {
                    //        operaObject.BoxCollider.IsShake = true;
                    //        return;
                    //    }
                    //}
                    //else
                    //{
                    //    OnNoRayTarget();
                    //    return;
                    //}
                }
                else
                {
                    OnNoRayTarget();
                    operaObject = hit.collider.GetComponent <OperaObject>();
                    if (operaObject == null)
                    {
                        return;
                    }
                    IdleOperateEnter();
                }


                break;

            case MInputHandStatus.Grip:
                if (operaObject == null || operaObject != null && operaObject.gameObject != hit.collider.gameObject)
                {
                    return;
                }

                HideLabel();

                InputHand.HandStatus = MInputHandStatus.Grab;    //将该手状态设置为抓取状态

                break;

            case MInputHandStatus.Grab:

                if (operaObject == null)
                {
                    return;
                }


                HideLabel();

                OperateObject = HandleGrab(operaObject.FeaturesObject.operaType);

                if (OperateObject != null)
                {
                    OperateObject.HandStatus = MInputHandStatus.Grabing;

                    EventHandGrabObject.SendListener(OperateObject.GrabObject, InputHand.HandIndex);
                    EventHandGrabObjectKey.SendListener(OperateObject.GrabObject, InputHand.HandIndex);
                }

                InputHand.HandStatus = MInputHandStatus.Grabing;

                break;

            case MInputHandStatus.Invalid:
                if (OnInvalid != null)
                {
                    OnInvalid(OperateObject, InputHand.HandIndex);
                }
                break;

            case MInputHandStatus.Error:

                if (OnError != null)
                {
                    OnError(OperateObject, InputHand.HandIndex);
                }

                break;

            case MInputHandStatus.Grabing:
                ShowHightLight(true);
                //不可操作中,表示正在有物体进行操作,不可进行其他操作
                if (OnGrabing != null)
                {
                    OnGrabing(OperateObject, InputHand.HandIndex);
                }

                break;

            default:
                break;
            }
        }
Пример #12
0
        /// <summary>
        /// 鼠标控制端的妹帧执行
        /// </summary>
        void OnMouseUpdate()
        {
            if (!IsEnable)
            {
                return;
            }

            //将他的屏幕坐标传递出去
            InputHands[0].OnUpdate(Input.mousePosition);

            if (Input.GetMouseButtonDown(0) && InputHands[0].IsIdleStatus)
            {
                InputHands[0].SetGrip();
            }

            if (Input.GetMouseButtonUp(0) && !(InputHands[0].IsRotateZoomStatus || InputHands[0].IsErrorStatus))
            {
                InputHands[0].SetIdle();
            }

            #region 旋转

            //如果按下右键
            if (Input.GetMouseButtonDown(1))
            {
                IsRotateDown = true;
                IsRotate     = false;
            }

            if (Input.GetMouseButtonUp(1))
            {
                IsRotateDown = false;

                //已经存在旋转,并且在集合中记录
                if (IsRotate)
                {
                    EventCameraRotate.SendListener(Vector3.zero);
                }

                IsRotate = false;
                InputHands[0].HandStatus = MInputHandStatus.Idle;
            }

            //按住右键旋转
            if (IsRotateDown)
            {
                //向量的模大于2.0时
                if (!IsRotate && InputHands[0].IsIdleStatus && InputHands[0].ScreenVector.magnitude > 2.0f)
                {
                    //将动作记录到集合中
                    InputHands[0].HandStatus = MInputHandStatus.Rotate;

                    IsRotate = true;
                }

                //已经存在旋转,并且在集合中记录
                if (IsRotate)
                {
                    EventCameraRotate.SendListener(InputHands[0].ScreenVector);
                }
            }
            #endregion

            #region 缩放

            //缩放
            if (Input.GetAxis("Mouse ScrollWheel") != 0)
            {
                float result = Input.GetAxis("Mouse ScrollWheel");

                if (!IsZoom && InputHands[0].IsIdleStatus)
                {
                    InputHands[0].HandStatus = MInputHandStatus.Zoom;
                    IsZoom = true;
                }

                //进行缩放
                if (IsZoom)
                {
                    EventCameraZoom.SendListener(result);
                }
            }
            else
            {
                //进行缩放
                if (IsZoom)
                {
                    EventCameraZoom.SendListener(0);
                    IsZoom = false;
                    InputHands[0].HandStatus = MInputHandStatus.Idle;
                }
            }
            #endregion

            if (operateObject != null)
            {
                switch (InputHands[0].HandStatus)
                {
                case MInputHandStatus.Grabing:

                    //需要处理偏移量
                    var     screenDevice = MUtility.MainWorldToScreenPoint(operateObject.GrabObject.transform.position);
                    Vector3 screenMouse  = InputHands[0].ScreenPoint;
                    Vector3 vPos         = MUtility.MainScreenToWorldPoint(new Vector3(screenMouse.x, screenMouse.y, screenDevice.z));

                    Vector3 position = vPos - offset;

                    EventUpdateObject.SendListener(operateObject.GrabObject, position, operateObject.GrabObject.transform.rotation, InputHands[0].HandIndex);

                    break;

                case MInputHandStatus.Idle:

                    this.operateObject = null;
                    break;

                default:
                    break;
                }
            }
        }
Пример #13
0
        /// <summary>
        /// 鼠标控制端的妹帧执行
        /// </summary>
        void OnMouseUpdate()
        {
            //将他的屏幕坐标传递出去
            InputHands[0].OnUpdate(Input.mousePosition);

            if (Input.GetMouseButtonDown(0))
            {
                InputHands[0].SetGrip();
            }

            if (Input.GetMouseButtonUp(0))
            {
                InputHands[0].SetIdle();
            }

            //如果按下右键
            if (Input.GetMouseButtonDown(1))
            {
                IsRotateDown = true;
                IsRotate     = false;
            }

            if (Input.GetMouseButtonUp(1))
            {
                IsRotateDown = false;

                //已经存在旋转,并且在集合中记录
                if (IsRotate && ActionConstraint.IsBind(ActionConstraint.Camera_Rotate_Action))
                {
                    EventCameraRotate.SendListener(Vector3.zero);
                }

                IsRotate = false;

                ActionConstraint.RemoveBind(ActionConstraint.Camera_Rotate_Action);
            }

            //按住右键旋转
            if (IsRotateDown)
            {
                //向量的模大于2.0时
                if (!IsRotate && ActionConstraint.BindCount == 0 && InputHands[0].ScreenVector.magnitude > 2.0f)
                {
                    //将动作记录到集合中
                    ActionConstraint.AddBind(ActionConstraint.Camera_Rotate_Action);

                    IsRotate = true;
                }

                //已经存在旋转,并且在集合中记录
                if (IsRotate && ActionConstraint.IsBind(ActionConstraint.Camera_Rotate_Action))
                {
                    EventCameraRotate.SendListener(InputHands[0].ScreenVector);
                }
            }

            //缩放
            if (Input.GetAxis("Mouse ScrollWheel") != 0)
            {
                float result = Input.GetAxis("Mouse ScrollWheel");

                if (!IsZoom && ActionConstraint.BindCount == 0)
                {
                    ActionConstraint.AddBind(ActionConstraint.Camera_Zoom_Action);

                    IsZoom = true;
                }

                //进行缩放
                if (IsZoom && ActionConstraint.IsBind(ActionConstraint.Camera_Zoom_Action))
                {
                    EventCameraZoom.SendListener(result);
                }
            }
            else
            {
                //进行缩放
                if (IsZoom && ActionConstraint.IsBind(ActionConstraint.Camera_Zoom_Action))
                {
                    EventCameraZoom.SendListener(0);
                }

                IsZoom = false;

                if (ActionConstraint.BindCount > 0)
                {
                    ActionConstraint.RemoveBind(ActionConstraint.Camera_Zoom_Action);
                }
            }

            if (operateObject != null)
            {
                switch (InputHands[0].HandStatus)
                {
                case MInputHandStatus.Grabing:

                    //需要处理偏移量
                    var     screenDevice = MUtility.MainWorldToScreenPoint(operateObject.GrabObject.transform.position);
                    Vector3 screenMouse  = InputHands[0].ScreenPoint;
                    Vector3 vPos         = MUtility.MainScreenToWorldPoint(new Vector3(screenMouse.x, screenMouse.y, screenDevice.z));

                    Vector3 position = vPos - offset;

                    EventUpdateObject.SendListener(operateObject.GrabObject, position, operateObject.GrabObject.transform.rotation, InputHands[0].HandIndex);

                    break;

                case MInputHandStatus.Idle:

                    this.operateObject = null;
                    break;

                default:
                    break;
                }
            }
        }
Пример #14
0
        // 双手操作处理
        void KinectHandTwo()
        {
            //将他的屏幕坐标传递出去
            InputHands[0].OnUpdate(MInputKinect.ScreenHandPostion(0));

            if (MInputKinect.HandGrip(0))
            {
                InputHands[0].SetGrip();
            }

            if (MInputKinect.HandRelease(0))
            {
                InputHands[0].SetIdle();
            }

            //将他的屏幕坐标传递出去
            InputHands[1].OnUpdate(MInputKinect.ScreenHandPostion(1));

            if (MInputKinect.HandGrip(1))
            {
                InputHands[1].SetGrip();
            }

            if (MInputKinect.HandRelease(1))
            {
                InputHands[1].SetIdle();
            }



            KinectRotateZoom();



            if (rightOperateObject != null)
            {
                switch (InputHands[0].HandStatus)
                {
                case MInputHandStatus.Grabing:

                    var screenDevice = MUtility.MainWorldToScreenPoint(rightOperateObject.GrabObject.transform.position);

                    Vector3 screenMouse = InputHands[0].ScreenPoint;
                    Vector3 vPos        = MUtility.MainScreenToWorldPoint(new Vector3(screenMouse.x, screenMouse.y, screenDevice.z));

                    //rightOperateObject.GrabObject.transform.position = vPos - rightOffset;

                    Vector3 position = vPos - rightOffset;

                    EventUpdateObject.SendListener(rightOperateObject.GrabObject, position, rightOperateObject.GrabObject.transform.rotation, InputHands[0].HandIndex);

                    //需要处理偏移量

                    break;

                case MInputHandStatus.Idle:

                    this.rightOperateObject = null;
                    break;

                default:
                    break;
                }
            }

            if (leftOperateObject != null)
            {
                switch (InputHands[1].HandStatus)
                {
                case MInputHandStatus.Grabing:

                    var screenDevice = MUtility.MainWorldToScreenPoint(leftOperateObject.GrabObject.transform.position);

                    Vector3 screenMouse = InputHands[1].ScreenPoint;
                    Vector3 vPos        = MUtility.MainScreenToWorldPoint(new Vector3(screenMouse.x, screenMouse.y, screenDevice.z));

                    //leftOperateObject.GrabObject.transform.position = vPos - leftOffset;

                    Vector3 position = vPos - leftOffset;

                    EventUpdateObject.SendListener(leftOperateObject.GrabObject, position, leftOperateObject.GrabObject.transform.rotation, InputHands[0].HandIndex);

                    //需要处理偏移量

                    break;

                case MInputHandStatus.Idle:

                    this.leftOperateObject = null;
                    break;

                default:
                    break;
                }
            }

            if (kinectHandStartStatus == KinectActiveHandStadus.One)
            {
                if (MInputKinect.IsHandActive(0) && !MInputKinect.IsHandActive(1) && isRight == false)
                {
                    MOperateManager.GetOperateHand(0, OperatePlatform.Kinect).OnEnable();
                    MOperateManager.GetOperateHand(1, OperatePlatform.Kinect).OnDisable();
                    isRight = true;
                    isLeft  = false;
                }
                else if (MInputKinect.IsHandActive(1) && !MInputKinect.IsHandActive(0) && isLeft == false)
                {
                    MOperateManager.GetOperateHand(1, OperatePlatform.Kinect).OnEnable();
                    MOperateManager.GetOperateHand(0, OperatePlatform.Kinect).OnDisable();
                    isLeft  = true;
                    isRight = false;
                }
            }
        }