GestureInteractiveControl.cs

Go to the documentation of this file.

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

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

namespace HoloToolkit.Examples.InteractiveElements
{
    public struct GestureInteractiveData
    {
        public Vector3 AlignmentVector;
        public Vector3 Direction;
        public float Distance;
        public float Percentage;
        public float MaxDistance;
        public bool FlipDirecationOnCameraForward;

        public GestureInteractiveData(Vector3 alignmentVector, float maxDistance, bool flipDirectionOnCameraForward)
        {
            AlignmentVector = alignmentVector;
            MaxDistance = maxDistance;
            FlipDirecationOnCameraForward = flipDirectionOnCameraForward;
            Direction = new Vector3();
            Distance = 0;
            Percentage = 0;
        }
    }
    
    public class GestureInteractiveControl : MonoBehaviour
    {
        public enum GestureDataType { Raw, Camera, Aligned }

        [Tooltip("What type of data processing should be used ? Raw, Camera aligned or vector aligned")]
        public GestureDataType GestureData;

        [Tooltip("The distance in world space to compare the gesture's delta to")]
        public float MaxGestureDistance = 0.15f;
        
        [Tooltip("The vector to align the gesture to, only used when the Aligned GestureDataType is selected.")]
        public Vector3 AlignmentVector = new Vector3(1,1,1);

        [Tooltip("Should we care if the Camera's forward is not Vector3.forward?")]
        public bool FlipDirectionOnCameraForward = false;
        
        protected GestureInteractive.GestureManipulationState GestureState;

        protected Camera MainCamera { get { return CameraCache.Main; } }

        protected Matrix4x4 CameraMatrix;

        protected Vector3 StartGesturePosition;

        protected Vector3 CurrentGesturePosition;

        protected Vector3 DirectionVector;

        protected Vector3 StartHeadPosition;

        protected Vector3 StartHeadRay;

        protected bool GestureStarted = false;

        protected float CurrentDistance;

        protected float CurrentPercentage;

        protected float KeywordGestureTime = 0.5f;

        protected float KeywordGestureTimeCounter = 0.5f;

        protected Vector3 KeywordGestureVector;

        // set the default gesture state
        virtual protected void Awake()
        {
            GestureState = GestureInteractive.GestureManipulationState.None;
           
        }

        public virtual void ManipulationUpdate(Vector3 startGesturePosition, Vector3 currentGesturePosition, Vector3 startHeadOrigin, Vector3 startHeadRay, GestureInteractive.GestureManipulationState gestureState)
        {
            if (gestureState == GestureInteractive.GestureManipulationState.Start || (!GestureStarted && gestureState != GestureInteractive.GestureManipulationState.Start))
            {
                CameraMatrix = GetCameraMatrix();
                StartGesturePosition = startGesturePosition;
                CurrentGesturePosition = startGesturePosition;
                StartHeadPosition = startHeadOrigin;
                StartHeadRay = startHeadRay;
                GestureStarted = true;
            }
            else
            {
                CurrentGesturePosition = currentGesturePosition;
            }

            UpdateGesture();

            if (gestureState == GestureInteractive.GestureManipulationState.None)
            {
                GestureStarted = false;
            }
        }

        public GestureInteractiveData GetGestureData(Vector3 alignmentVector, float maxDistance, bool flipDirecationOnCameraForward)
        {
            GestureInteractiveData data = new GestureInteractiveData(alignmentVector, maxDistance, flipDirecationOnCameraForward);

            data.Direction = DirectionVector;
            bool flipDirection = Vector3.Dot(Vector3.forward, StartHeadRay) < 0 && flipDirecationOnCameraForward;

            if (flipDirection)
            {
                data.Direction = -data.Direction;
            }
            data.Distance = Vector3.Dot(data.Direction, alignmentVector);

            data.Percentage = Mathf.Min(Mathf.Abs(data.Distance) / maxDistance, 1);

            return data;
        }
        
        public Matrix4x4 GetCameraMatrix()
        {
            // get the preferred body direction
            Vector3 up = Vector3.up;
            Vector3 forward = MainCamera.transform.forward;
            // protecting from a weird cross value
            if (Vector3.Angle(up, forward) < 10)
            {
                up = MainCamera.transform.up;
            }
            Vector3 right = Vector3.Cross(up, forward);
            right.Normalize();

            // build a matrix based on body/camera direction
            Matrix4x4 cameraWorld = new Matrix4x4();
            cameraWorld.SetColumn(0, right);
            cameraWorld.SetColumn(1, up);
            cameraWorld.SetColumn(2, forward);
            cameraWorld.SetColumn(3, new Vector4(0, 0, 0, 1));

            return cameraWorld;
        }

        public Vector3 WorldForwardVector(Vector3 direction, Vector3 orientation, bool flipY = false, bool flipZ = false)
        {
            Matrix4x4 cameraWorld = GetCameraMatrix(); //CameraMatrix

            // create a new vector from the raw gesture data
            Vector3 rawVector = direction - orientation;

            // flip z index?
            if (flipZ)
            {
                rawVector.z = -rawVector.z;
            }

            if (flipY)
            {
                rawVector.y = -rawVector.y;
            }
            
            Vector3 newDirection = cameraWorld.MultiplyVector(rawVector);

            // replace the y
            newDirection.y = rawVector.y;

            return newDirection;
        }

        public void SetGestureVector(Vector3 gestureVector)
        {
            if (GestureStarted)
            {
                return;
            }

            KeywordGestureVector = gestureVector;
            KeywordGestureTimeCounter = 0;
            CameraMatrix = GetCameraMatrix();
            StartGesturePosition = gestureVector * MaxGestureDistance * (KeywordGestureTimeCounter / KeywordGestureTime);
            StartHeadPosition = new Vector3();
            StartHeadRay = Vector3.forward;

            CurrentGesturePosition = gestureVector * MaxGestureDistance * (KeywordGestureTimeCounter/KeywordGestureTime);

            ManipulationUpdate(StartGesturePosition, Vector3.up, StartHeadPosition, StartHeadRay, GestureInteractive.GestureManipulationState.Start);
        }

        public virtual void setGestureValue(int gestureValue)
        {
            // override to convert keyword index to vectors.
            switch (gestureValue)
            {
                case 0:
                    SetGestureVector(Vector3.left);
                    break;
                case 1:
                    SetGestureVector(Vector3.right);
                    break;
                case 2:
                    SetGestureVector(Vector3.up);
                    break;
                case 3:
                    SetGestureVector(Vector3.down);
                    break;
            }
        }

        protected Vector3 DirectionVectorToZPlane(Vector3 directionVector, bool flipX, bool flipY)
        {
            // set the direction based on camera and gesture updates
            float cameraDirectionX = flipX ? -directionVector.x : directionVector.x;
            float cameraDirectionY = flipY ? -directionVector.y : directionVector.y;
            return MainCamera.transform.forward * cameraDirectionY + MainCamera.transform.right * cameraDirectionX;
        }

        public Vector3 GesturePosition(Vector3 gesturePosition)
        {
            // rotate the screen space mouse position to world space, based on the camera direction and compress pixels to world 
            // get current angle from forward - returns an absolute value of 0 - 180
            float angleDiff = Vector3.Angle(Vector3.forward, MainCamera.transform.forward);
            // make sure angle works 360 degrees, find the left or right side
            float dot = Vector3.Dot(Vector3.right, MainCamera.transform.forward);
            // if dot is positive, camera is pointing right of Vector3.forward or rotating clockwise
            if (dot < 0)
                angleDiff = -angleDiff;
            // rotate the world space converted mouse vector on the Y axis
            return RotateVectorOnY(gesturePosition, MainCamera.transform.position, angleDiff);
        }

        private Vector3 RotateVectorOnY(Vector3 vector, Vector3 pivot, float angle)
        {
            return Quaternion.Euler(0, angle, 0) * (vector - pivot) + pivot;
        }

        protected float FlipDistanceOnFacingControl(float toFlip, Vector3 controlPosition, Vector3 controlForward)
        {
            Vector3 cameraRay = StartHeadPosition - controlPosition;
            bool facingForward = Vector3.Dot(MainCamera.transform.forward, StartHeadRay) >= 0;
            bool facingControl = Vector3.Dot(cameraRay, controlForward) >= 0;

            if (!facingForward)
            {
                // then the direction was flipped
                // facing back
                if (facingControl)
                {
                    toFlip = -toFlip;
                }
            }
            else
            {
                if (!facingControl)
                {
                    toFlip = -toFlip;
                }
            }

            return toFlip;
        }
        
        protected void UpdateGesture()
        {
            DirectionVector = CurrentGesturePosition - StartGesturePosition;
            CurrentDistance = DirectionVector.magnitude;
            bool flipDirection = Vector3.Dot(Vector3.forward, StartHeadRay) < 0 && FlipDirectionOnCameraForward;
            switch (GestureData)
            {
                case GestureDataType.Raw:
                    CurrentDistance = DirectionVector.magnitude;
                    break;
                case GestureDataType.Camera:
                    if (flipDirection)
                    {
                        DirectionVector = -DirectionVector;
                    }
                    CurrentDistance = Vector3.Dot(DirectionVector, MainCamera.transform.right);
                    break;
                case GestureDataType.Aligned:
                    CurrentDistance = Vector3.Dot(DirectionVector, AlignmentVector);
                    break;
                default:
                    break;
            }

            CurrentPercentage = Mathf.Min(Mathf.Abs(CurrentDistance) / MaxGestureDistance, 1);
        }

        protected virtual void Update()
        {
            if (KeywordGestureTimeCounter < 0)
            {
                if (GestureStarted)
                {
                    KeywordGestureTimeCounter = KeywordGestureTime;
                    return;
                }

                GestureInteractive.GestureManipulationState state = GestureInteractive.GestureManipulationState.Update;
                KeywordGestureTimeCounter += Time.deltaTime;
                if (KeywordGestureTimeCounter > KeywordGestureTime)
                {
                    KeywordGestureTimeCounter = KeywordGestureTime;
                    state = GestureInteractive.GestureManipulationState.None;
                }

                CurrentGesturePosition = KeywordGestureVector * MaxGestureDistance * (KeywordGestureTimeCounter / KeywordGestureTime);
                
                ManipulationUpdate(StartGesturePosition, Vector3.up, StartHeadPosition, StartHeadRay, state);
            }
        }
    }
}