Solver.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 HoloToolkit.Unity.InputModule;
using UnityEngine;

namespace HoloToolkit.Unity
{
    [RequireComponent(typeof(SolverHandler))]
    public abstract class Solver : MonoBehaviour
    {
        #region public members
        [Tooltip("If true, the position and orientation will be calculated, but not applied, for other components to use")]
        public bool UpdateLinkedTransform = false;

        [Tooltip("Position lerp multiplier")]
        public float MoveLerpTime = 0.1f;
        [Tooltip("Rotation lerp multiplier")]
        public float RotateLerpTime = 0.1f;
        [Tooltip("Scale lerp multiplier")]
        public float ScaleLerpTime = 0;

        [Tooltip("If true, the Solver will respect the object's original scale values")]
        public bool MaintainScale = true;

        // Field that may be used to represent final position to be smoothly attained
        [HideInInspector]
        public Vector3 GoalPosition;
        // Field that may be used to represent final rotation to be smoothly attained
        [HideInInspector]
        public Quaternion GoalRotation;
        // Field that may be used to represent final scale to be smoothly attained
        [HideInInspector]
        public Vector3 GoalScale;

        [Tooltip("Working output is smoothed if true.  Otherwise snapped")]
        public bool Smoothing = true;

        [Tooltip("If > 0, this solver will deactivate after this much time, even if the state is still active")]
        public float Lifetime = 0;
        #endregion

        #region private members
        protected SolverHandler solverHandler;
        private float lifetime;
        #endregion

        protected virtual void Awake()
        {
            solverHandler = GetComponent<SolverHandler>();

            if (UpdateLinkedTransform && solverHandler == null)
            {
                Debug.LogError("No SolverHandler component found on " + name + " when UpdateLinkedTransform was set to true!  Disabling UpdateLinkedTransform");
                UpdateLinkedTransform = false;
            }

            GoalScale = MaintainScale == true ? this.transform.localScale : Vector3.one;
        }

        protected virtual void OnEnable()
        {
            //Ensure the Camera helper component exists
            CameraCache.Main.gameObject.EnsureComponent<CameraMotionInfo>();

            if (solverHandler != null)
            {
                SnapGoalTo(solverHandler.GoalPosition, solverHandler.GoalRotation);
            }

            lifetime = 0;
        }

        // SolverLink will pass transform through
        // Should be implemented in derived classes, but SolverBase can be used to flush shared transform to real transform
        public abstract void SolverUpdate();

        public void SolverUpdateEntry()
        {
            lifetime += solverHandler.DeltaTime;
            if (Lifetime > 0 && lifetime >= Lifetime)
            {
                enabled = false;
                return;
            }

            SolverUpdate();
        }

        public virtual void SnapTo(Vector3 position, Quaternion rotation)
        {
            SnapGoalTo(position, rotation);

            WorkingPos = position;
            WorkingRot = rotation;
        }

        public virtual void SnapGoalTo(Vector3 position, Quaternion rotation)
        {
            GoalPosition = position;
            GoalRotation = rotation;
        }

        public virtual void AddOffset(Vector3 offset)
        {
            GoalPosition += offset;
        }

        public Vector3 WorkingPos
        {
            get
            {
                if (UpdateLinkedTransform)
                {
                    return solverHandler.GoalPosition;
                }
                else
                {
                    return transform.position;
                }
            }

            set
            {
                if (UpdateLinkedTransform)
                {
                    solverHandler.GoalPosition = value;
                }
                else
                {
                    this.transform.position = value;
                }
            }
        }

        public Quaternion WorkingRot
        {
            get
            {
                if (UpdateLinkedTransform)
                {
                    return solverHandler.GoalRotation;
                }
                else
                {
                    return transform.rotation;
                }
            }

            set
            {
                if (UpdateLinkedTransform)
                {
                    solverHandler.GoalRotation = value;
                }
                else
                {
                    this.transform.rotation = value;
                }
            }
        }

        public Vector3 WorkingScale
        {
            get
            {
                if (UpdateLinkedTransform)
                {
                    return solverHandler.GoalScale;
                }
                else
                {
                    return transform.localScale;
                }
            }

            set
            {
                if (UpdateLinkedTransform)
                {
                    solverHandler.GoalScale = value;
                }
                else
                {
                    this.transform.localScale = value;
                }
            }
        }

        public static Vector3 SmoothTo(Vector3 source, Vector3 goal, float deltaTime, float lerpTime)
        {
            return Vector3.Lerp(source, goal, lerpTime == 0 ? 1f : deltaTime / lerpTime);
        }

        public static Quaternion SmoothTo(Quaternion source, Quaternion goal, float deltaTime, float lerpTime)
        {
            return Quaternion.Slerp(source, goal, lerpTime == 0 ? 1f : deltaTime / lerpTime);
        }

        protected void UpdateTransformToGoal()
        {
            if (Smoothing)
            {
                Vector3 pos = this.transform.position;
                Quaternion rot = this.transform.rotation;
                Vector3 scale = this.transform.localScale;

                float dt = solverHandler.DeltaTime;
                pos = SmoothTo(pos, GoalPosition, dt, MoveLerpTime);
                rot = SmoothTo(rot, GoalRotation, dt, RotateLerpTime);
                scale = SmoothTo(scale, GoalScale, dt, ScaleLerpTime);

                this.transform.position = pos;
                this.transform.rotation = rot;
                this.transform.localScale = scale;
            }
            else
            {
                this.transform.position = GoalPosition;
                this.transform.rotation = GoalRotation;
                this.transform.localScale = GoalScale;
            }
        }

        public void UpdateWorkingToGoal()
        {
            if (Smoothing)
            {
                float dt = solverHandler.DeltaTime;
                WorkingPos = SmoothTo(WorkingPos, GoalPosition, dt, MoveLerpTime);
                WorkingRot = SmoothTo(WorkingRot, GoalRotation, dt, RotateLerpTime);
                WorkingScale = SmoothTo(WorkingScale, GoalScale, dt, ScaleLerpTime);
            }
            else
            {
                WorkingPos = GoalPosition;
                WorkingRot = GoalRotation;
                WorkingScale = GoalScale;
            }
        }

        public void UpdateWorkingPosToGoal()
        {
            if (Smoothing)
            {
                WorkingPos = SmoothTo(WorkingPos, GoalPosition, solverHandler.DeltaTime, MoveLerpTime);
            }
            else
            {
                WorkingPos = GoalPosition;
            }
        }

        public void UpdateWorkingRotToGoal()
        {
            if (Smoothing)
            {
                WorkingRot = SmoothTo(WorkingRot, GoalRotation, solverHandler.DeltaTime, RotateLerpTime);
            }
            else
            {
                WorkingRot = GoalRotation;
            }
        }

        public void UpdateWorkingScaleToGoal()
        {
            if (Smoothing)
            {
                WorkingScale = SmoothTo(WorkingScale, GoalScale, solverHandler.DeltaTime, ScaleLerpTime);
            }
            else
            {
                WorkingScale = GoalScale;
            }
        }
    }

}