BaseScalable.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 System.Collections;
using UnityEngine;

namespace HoloToolkit.Unity.InputModule.Examples.Grabbables
{
    public abstract class BaseScalable : MonoBehaviour
    {
        [SerializeField]
        private bool scaleByDistance = true;

        [SerializeField]
        private BaseGrabbable grabbable;

        private bool readyToScale;
        private float snapShotOfScale;
        private int minScalarNumForScale = 2;
        private bool currentlyScaling;
        private float snapShotDistance;

        protected virtual void Awake()
        {
            if (grabbable == null)
            {
                grabbable = gameObject.GetComponent<BaseGrabbable>();
            }
        }

        protected virtual void OnEnable()
        {
            grabbable.OnGrabbed += OnGrabbed;
        }

        protected virtual void OnDisable()
        {
            grabbable.OnGrabbed -= OnGrabbed;
        }

        public void AttemptScale()
        {
            Debug.Log("Attempt scale");
            BaseGrabber[] activeGrabbers = GetComponent<BaseGrabbable>().ActiveGrabbers;

            if (GetComponent<BaseGrabbable>().ActiveGrabbers.Length >= minScalarNumForScale)
            {
                // Distance
                // snapshot a standard distance that the controls are when the scalable object is engaged
                // That standard distance between controllers corresponds to the localScale * scaleMultiplier
                if (scaleByDistance)
                {
                    if (activeGrabbers.Length >= minScalarNumForScale)
                    {
                        //later this should be average distance between all controllers attached.
                        float dist = Vector3.Distance(activeGrabbers[0].GrabHandle.position, activeGrabbers[1].GrabHandle.position);
                        snapShotDistance = dist;
                        //TODO: scale should not be recorded from x axis alone
                        snapShotOfScale = transform.localScale.x;
                        currentlyScaling = true;
                        StartCoroutine(PerformScaling());
                    }
                }
            }
        }

        public void OnGrabbed(BaseGrabbable baseGrab)
        {
            if (!currentlyScaling)
            {
                AttemptScale();
            }
        }

        public virtual IEnumerator PerformScaling()
        {
            currentlyScaling = true;

            while (currentlyScaling)
            {
                //  let go
                if (grabbable.GrabState == GrabStateEnum.Inactive)
                {
                    currentlyScaling = false;
                    yield break;
                }

                BaseGrabber[] activeGrabbers = grabbable.ActiveGrabbers;

                // If enough grabbers have grabbed
                if (activeGrabbers.Length >= minScalarNumForScale)
                {
                    float currDistance = Vector3.Distance(activeGrabbers[0].GrabHandle.position, activeGrabbers[1].GrabHandle.position);
                    transform.localScale = Vector3.one * ((currDistance / snapShotDistance) * snapShotOfScale)  /*scaleMultiplier */ /* distFromUser*/;

                }

                yield return 0;
            }

            currentlyScaling = false;
        }
    }
}