Mercurial > hg > Game > Games
diff Orchestland/Assets/LeapMotion/Widgets/Scripts/Scroll/ScrollBase.cs @ 3:0030a1b971fb default tip
merge
author | Yuta ANSE <e135745@ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2015 23:23:43 +0900 |
parents | f7675884f2a1 |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Orchestland/Assets/LeapMotion/Widgets/Scripts/Scroll/ScrollBase.cs Fri Jul 17 23:23:43 2015 +0900 @@ -0,0 +1,119 @@ +using UnityEngine; +using System.Collections; +using LMWidgets; + +public class ScrollBase : LeapPhysicsBase { + public float InteractionScale = 1.0f; + + // How strong is the snapping spring. + public float SnapSpringForce = 100.0f; + + // How much drag should be applied ( as a percentage of velocity/second ) + public float Drag = 5.0f; + + // The transform of the root game object of the content to be scrolled. + public Transform ContentTransform; + + // Used to define and top and bottom of the scroll content + public Transform ContentTopBound; + public Transform ContentBottomBound; + + // Used to define the top and bottom of the scroll container + public Transform ContainerTopBound; + public Transform ContainerBottomBound; + + // The current velocity of the content. + protected float m_velocity = 0.0f; + + // The dampening force for the edge spring. + protected float m_dampingForce = 0.0f; + + // The location of the scrollable content + // when interaction began. + protected Vector3 m_contentPivot; + + + protected virtual void Start () { + // Set critical dampening force to avoid oscillation. + m_dampingForce = Mathf.Sqrt(4.0f * SnapSpringForce); + } + + protected override void ResetPivots() { + base.ResetPivots(); + m_contentPivot = ContentTransform.localPosition; + } + + protected override void ApplyPhysics() { + applyOverrunSpringForces(); + applyDrag(); + applyVelocity(); + } + + protected void applyDrag() { + m_velocity -= m_velocity * Mathf.Max(0, Drag * Time.deltaTime); + } + + protected void applyVelocity() { + Vector3 currentPosition = ContentTransform.localPosition; + currentPosition.y += m_velocity * Time.deltaTime; + ContentTransform.localPosition = currentPosition; + } + + /// <summary> + /// Applies a spring force to velocity to return content to scroller bounds. + /// </summary> + protected void applyOverrunSpringForces() { + float overrunDistance = calculateOverrunMagnitude() * InteractionScale; + + if (overrunDistance != 0.0f) { + float springForce = calculate1DSpringForce(overrunDistance); + m_velocity += springForce * Time.deltaTime; + } + } + + // offsetVector is the vector by which the object is offset from the goal + protected float calculate1DSpringForce(float offsetVector) { + float springForce = offsetVector * SnapSpringForce; + float dampingForce = m_dampingForce * (m_velocity); + return springForce - dampingForce; + } + + // calc the amount and direction (if any) the content has overrun the scroll container. + protected float calculateOverrunMagnitude() { + float overrunDistance = 0.0f; + + // Put all positions in object space. + Vector3 localContentTop = transform.InverseTransformPoint(ContentTopBound.position); + Vector3 localContentBottom = transform.InverseTransformPoint(ContentBottomBound.position); + Vector3 localContainerTop = transform.InverseTransformPoint(ContainerTopBound.position); + Vector3 localContainerBottom = transform.InverseTransformPoint(ContainerBottomBound.position); + + if (localContentTop.y < localContainerTop.y) { + overrunDistance = localContainerTop.y - localContentTop.y; + } + else if (localContentBottom.y > localContainerBottom.y) { + overrunDistance = localContainerBottom.y - localContentBottom.y; + } + + return overrunDistance; + } + + protected override void ApplyInteractions() { + + Vector3 targetInteractorPositionChange = transform.parent.InverseTransformPoint(m_target.transform.position) - m_targetPivot; + targetInteractorPositionChange *= InteractionScale; + targetInteractorPositionChange.x = 0.0f; + targetInteractorPositionChange.z = 0.0f; + Vector3 contentCurrentPosition = ContentTransform.localPosition; + Vector3 newContentPosition = m_contentPivot + targetInteractorPositionChange; + Vector3 velocity = (newContentPosition - contentCurrentPosition) / Time.deltaTime; + m_velocity = velocity.y; + + ContentTransform.localPosition = newContentPosition; + } + + protected override void ApplyConstraints() { + return; + } + +}