Hololens开发笔记之Gesture手势识别（Manipulation手势控制物体平移）

Manipulation gesture：保持点击手势，在3D世界中绝对运动

当你想要全息图像1：1响应用户手部移动时，操纵手势能被用于移动、缩放或旋转全息图像。如此的一个用处是使得用户可以在世界中绘制图像或作画。使用所有的手势时，操纵手势的初始目标应该通过凝视来选中。一旦点击手势开始，通过手部移动的任何对对象的操作都能够被处理，在用户操作全息图像时，从而使得用户得以自由地四处张望。

1、修改HandsManager.cs，添加InteractionManager.SourcePressed，InteractionManager.SourceReleased处理函数，用于识别物体被点击和被释放的事件

HandsManager.cs完整代码如下：

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.  

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.VR.WSA.Input;  

namespace HoloToolkit.Unity
{
    /// <summary>
    /// HandsManager determines if the hand is currently detected or not.
    /// </summary>
    public partial class HandsManager : Singleton<HandsManager>
    {
        /// <summary>
        /// HandDetected tracks the hand detected state.
        /// Returns true if the list of tracked hands is not empty.
        /// </summary>
        public bool HandDetected
        {
            get { return trackedHands.Count > ; }
        }  

        private HashSet<uint> trackedHands = new HashSet<uint>();  

        public GameObject FocusedGameObject { get; private set; }  

        void Awake()
        {
            //识别到来源
            InteractionManager.SourceDetected += InteractionManager_SourceDetected;
            //来源丢失
            InteractionManager.SourceLost += InteractionManager_SourceLost;
            //来源被按下
            InteractionManager.SourcePressed += InteractionManager_SourcePressed;
            //被释放
            InteractionManager.SourceReleased += InteractionManager_SourceReleased;
            FocusedGameObject = null;
        }  

        private void InteractionManager_SourceDetected(InteractionSourceState state)
        {
            // Check to see that the source is a hand.
            if (state.source.kind != InteractionSourceKind.Hand)
            {
                return;
            }  

            trackedHands.Add(state.source.id);
        }  

        private void InteractionManager_SourceLost(InteractionSourceState state)
        {
            // Check to see that the source is a hand.
            if (state.source.kind != InteractionSourceKind.Hand)
            {
                return;
            }  

            if (trackedHands.Contains(state.source.id))
            {
                trackedHands.Remove(state.source.id);
            }
            FocusedGameObject = null;
        }  

        //手势释放时，将被关注的物体置空
        private void InteractionManager_SourceReleased(InteractionSourceState state)
        {
            FocusedGameObject = null;
        }  

        //识别到手指按下时，将凝视射线关注的物体置为当前手势操作的对象
        private void InteractionManager_SourcePressed(InteractionSourceState state)
        {
            if (GazeManager.Instance.FocusedObject != null)
            {
                FocusedGameObject = GazeManager.Instance.FocusedObject;
            }
        }  

        void OnDestroy()
        {
            InteractionManager.SourceDetected -= InteractionManager_SourceDetected;
            InteractionManager.SourceLost -= InteractionManager_SourceLost;
            InteractionManager.SourceReleased -= InteractionManager_SourceReleased;
            InteractionManager.SourcePressed -= InteractionManager_SourcePressed;
        }
    }
}  

2、修改GestureManager.cs，订阅Manipulation gesture事件

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.  

using System;
using UnityEngine;
using UnityEngine.VR.WSA.Input;  

namespace HoloToolkit.Unity
{
    /// <summary>
    /// GestureManager creates a gesture recognizer and signs up for a tap gesture.
    /// When a tap gesture is detected, GestureManager uses GazeManager to find the game object.
    /// GestureManager then sends a message to that game object.
    /// </summary>
    [RequireComponent(typeof(GazeManager))]
    public partial class GestureManager : Singleton<GestureManager>
    {
        /// <summary>
        /// Key to press in the editor to select the currently gazed hologram
        /// </summary>
        public KeyCode EditorSelectKey = KeyCode.Space;  

        /// <summary>
        /// To select even when a hologram is not being gazed at,
        /// set the override focused object.
        /// If its null, then the gazed at object will be selected.
        /// </summary>
        public GameObject OverrideFocusedObject
        {
            get; set;
        }  

        public bool IsManipulating { get; private set; }
        public Vector3 ManipulationPosition { get; private set; }  

        /// <summary>
        /// Gets the currently focused object, or null if none.
        /// </summary>
        public GameObject FocusedObject
        {
            get { return focusedObject; }
        }  

        private GestureRecognizer gestureRecognizer;
        private GameObject focusedObject;  

        void Start()
        {
            // Create a new GestureRecognizer. Sign up for tapped events.
            gestureRecognizer = new GestureRecognizer();
            gestureRecognizer.SetRecognizableGestures(GestureSettings.Tap
                | GestureSettings.DoubleTap
                | GestureSettings.ManipulationTranslate);  

            gestureRecognizer.TappedEvent += GestureRecognizer_TappedEvent;
            //订阅Manipulation gesture事件
            gestureRecognizer.ManipulationStartedEvent += GestureRecognizer_ManipulationStartedEvent;
            gestureRecognizer.ManipulationUpdatedEvent += GestureRecognizer_ManipulationUpdatedEvent;
            gestureRecognizer.ManipulationCompletedEvent += GestureRecognizer_ManipulationCompletedEvent;
            gestureRecognizer.ManipulationCanceledEvent += GestureRecognizer_ManipulationCanceledEvent;  

            // Start looking for gestures.
            gestureRecognizer.StartCapturingGestures();
        }  

        private void GestureRecognizer_ManipulationStartedEvent(InteractionSourceKind source, Vector3 cumulativeDelta, Ray headRay)
        {
            //当被关注的对象非空时，设置初始位置
            if (HandsManager.Instance.FocusedGameObject != null)
            {
                IsManipulating = true;  

                ManipulationPosition = cumulativeDelta;  

                HandsManager.Instance.FocusedGameObject.SendMessageUpwards("PerformManipulationStart", cumulativeDelta);
            }
        }  

        private void GestureRecognizer_ManipulationUpdatedEvent(InteractionSourceKind source, Vector3 cumulativeDelta, Ray headRay)
        {
            //当被关注的对象非空时，更新新的位置
            if (HandsManager.Instance.FocusedGameObject != null)
            {
                IsManipulating = true;  

                ManipulationPosition = cumulativeDelta;  

                HandsManager.Instance.FocusedGameObject.SendMessageUpwards("PerformManipulationUpdate", cumulativeDelta);
            }
        }  

        private void GestureRecognizer_ManipulationCompletedEvent(InteractionSourceKind source, Vector3 cumulativeDelta, Ray headRay)
        {
            IsManipulating = false;
        }  

        private void GestureRecognizer_ManipulationCanceledEvent(InteractionSourceKind source, Vector3 cumulativeDelta, Ray headRay)
        {
            IsManipulating = false;
        }  

        private void OnTap()
        {
            if (focusedObject != null)
            {
                focusedObject.SendMessage("OnTap");
            }
        }  

        private void OnDoubleTap()
        {
            if (focusedObject != null)
            {
                focusedObject.SendMessage("OnDoubleTap");
            }
        }  

        private void GestureRecognizer_TappedEvent(InteractionSourceKind source, int tapCount, Ray headRay)
        {
            if (tapCount == )
            {
                OnTap();
            }
            else
            {
                OnDoubleTap();
            }
        }  

        void LateUpdate()
        {
            GameObject oldFocusedObject = focusedObject;  

            if (GazeManager.Instance.Hit &&
                OverrideFocusedObject == null &&
                GazeManager.Instance.HitInfo.collider != null)
            {
                // If gaze hits a hologram, set the focused object to that game object.
                // Also if the caller has not decided to override the focused object.
                focusedObject = GazeManager.Instance.HitInfo.collider.gameObject;
            }
            else
            {
                // If our gaze doesn't hit a hologram, set the focused object to null or override focused object.
                focusedObject = OverrideFocusedObject;
            }  

            //if (focusedObject != oldFocusedObject)
            //{
            //    // If the currently focused object doesn't match the old focused object, cancel the current gesture.
            //    // Start looking for new gestures.  This is to prevent applying gestures from one hologram to another.
            //    gestureRecognizer.CancelGestures();
            //    gestureRecognizer.StartCapturingGestures();
            //}
        }  

        void OnDestroy()
        {
            gestureRecognizer.StopCapturingGestures();
            //取消订阅
            gestureRecognizer.TappedEvent -= GestureRecognizer_TappedEvent;
            gestureRecognizer.ManipulationStartedEvent -= GestureRecognizer_ManipulationStartedEvent;
            gestureRecognizer.ManipulationUpdatedEvent -= GestureRecognizer_ManipulationUpdatedEvent;
            gestureRecognizer.ManipulationCompletedEvent -= GestureRecognizer_ManipulationCompletedEvent;
            gestureRecognizer.ManipulationCanceledEvent -= GestureRecognizer_ManipulationCanceledEvent;
        }
    }
}  

3、添加ManipulationTranslate脚本，计算相对位移，然后进行更新物体的新的位置。

using UnityEngine;
using System.Collections;
using HoloToolkit.Unity;  

public class ManipulationTranslate: MonoBehaviour {  

    private Vector3 manipulationPreviousPosition;  

    // Use this for initialization
    void Start () {  

    }  

    // Update is called once per frame
    void Update () {  

    }  

    void PerformManipulationStart(Vector3 position)
    {
        //设置初始位置
        manipulationPreviousPosition = position;
    }  

    void PerformManipulationUpdate(Vector3 position)
    {
        if (GestureManager.Instance.IsManipulating)
        {
            //计算相对位移，然后更新物体的位置
            Vector3 moveVector = Vector3.zero;
            moveVector = position - manipulationPreviousPosition;
            manipulationPreviousPosition = position;
            transform.position += 2f * moveVector;
        }
    }  

4、运行测试

将凝视射线投射到对象上，举起右手使食指和拇指碰触在一起，然后进行左右移动，可以看到物体的位置将移动。