Beispiel #1
0
        public override void TouchEnded(Touch touch)
        {
            if (currentTouch != touch)
            {
                return;
            }

            currentTouch  = null;
            currentVector = Vector2.zero;

            var touchPosition = TouchManager.ScreenToWorldPoint(touch.position);
            var delta         = beganPosition - touchPosition;

            if (delta.magnitude < sensitivity)
            {
                fireButtonTarget = true;
                nextButtonTarget = tapTarget;
                lastButtonTarget = ButtonTarget.None;
                return;
            }

            fireButtonTarget = false;
            nextButtonTarget = ButtonTarget.None;
            lastButtonTarget = ButtonTarget.None;
        }
Beispiel #2
0
        public override void TouchMoved(Touch touch)
        {
            if (currentTouch != touch)
            {
                return;
            }

            var movedPosition = TouchManager.ScreenToWorldPoint(touch.position);
            var delta         = movedPosition - lastPosition;

            if (delta.magnitude >= sensitivity)
            {
                lastPosition  = movedPosition;
                currentVector = delta.normalized;

                if (fireButtonTarget)
                {
                    var thisButtonTarget = GetButtonTargetForVector(currentVector);
                    if (thisButtonTarget != lastButtonTarget)
                    {
                        nextButtonTarget = thisButtonTarget;
                    }
                }
            }
        }
Beispiel #3
0
 public override void TouchBegan(Touch touch)
 {
     if (!IsActive)
     {
         beganPosition = TouchManager.ScreenToWorldPoint(touch.position);
         bool flag  = worldActiveArea.Contains(beganPosition);
         bool flag2 = ring.Contains(beganPosition);
         if (snapToInitialTouch && (flag || flag2))
         {
             RingPosition = beganPosition;
             KnobPosition = beganPosition;
             currentTouch = touch;
         }
         else if (flag2)
         {
             KnobPosition  = beganPosition;
             beganPosition = RingPosition;
             currentTouch  = touch;
         }
         if (IsActive)
         {
             TouchMoved(touch);
             ring.State = true;
             knob.State = true;
         }
     }
 }
        public override void TouchMoved(Touch touch)
        {
            if (currentTouch != touch)
            {
                return;
            }
            Vector3 a      = TouchManager.ScreenToWorldPoint(touch.position);
            Vector3 vector = a - lastPosition;

            if (!(vector.magnitude >= sensitivity))
            {
                return;
            }
            lastPosition = a;
            if (!oneSwipePerTouch || !currentVectorIsSet)
            {
                currentVector      = vector.normalized;
                currentVectorIsSet = true;
            }
            if (fireButtonTarget)
            {
                ButtonTarget buttonTargetForVector = GetButtonTargetForVector(currentVector);
                if (buttonTargetForVector != lastButtonTarget)
                {
                    nextButtonTarget = buttonTargetForVector;
                }
            }
        }
        public override void TouchBegan(Touch touch)
        {
            if (IsActive)
            {
                return;
            }

            beganPosition = TouchManager.ScreenToWorldPoint(touch.position);

            var insideActiveArea = worldActiveArea.Contains(beganPosition);
            var insideControl    = ring.Contains(beganPosition);

            if (snapToInitialTouch && (insideActiveArea || insideControl))
            {
                RingPosition = beganPosition;
                KnobPosition = beganPosition;
                currentTouch = touch;
            }
            else
            if (insideControl)
            {
                KnobPosition  = beganPosition;
                beganPosition = RingPosition;
                currentTouch  = touch;
            }

            if (IsActive)
            {
                TouchMoved(touch);

                ring.State = true;
                knob.State = true;
            }
        }
 public override void TouchMoved(Touch touch)
 {
     if (currentTouch == touch)
     {
         thisPosition = TouchManager.ScreenToViewPoint(touch.position * 100f);
     }
 }
        public override void TouchMoved(Touch touch)
        {
            if (currentTouch != touch)
            {
                return;
            }

            movedPosition = TouchManager.ScreenToWorldPoint(touch.position);

            var vector = movedPosition - beganPosition;
            var normal = vector.normalized;
            var length = vector.magnitude;

            if (allowDragging)
            {
                var excess = length - worldKnobRange;
                if (excess < 0.0f)
                {
                    excess = 0.0f;
                }
                beganPosition = beganPosition + (excess * normal);
                RingPosition  = beganPosition;
            }

            movedPosition = beganPosition + (Mathf.Clamp(length, 0.0f, worldKnobRange) * normal);

            value   = (movedPosition - beganPosition) / worldKnobRange;
            value.x = inputCurve.Evaluate(Utility.Abs(value.x)) * Mathf.Sign(value.x);
            value.y = inputCurve.Evaluate(Utility.Abs(value.y)) * Mathf.Sign(value.y);

            KnobPosition = movedPosition;
            RingPosition = beganPosition;
        }
        void OnEnable()
        {
            touchManager = target as TouchManager;

            var path = AssetDatabase.GetAssetPath(MonoScript.FromScriptableObject(this));

            headerTexture = Resources.LoadAssetAtPath <Texture>(Path.GetDirectoryName(path) + "/Images/TouchManagerHeader.png");
        }
Beispiel #9
0
        public override void TouchMoved(Touch touch)
        {
            if (currentTouch != touch)
            {
                return;
            }

            movedPosition = TouchManager.ScreenToWorldPoint(touch.position);

            var vector = movedPosition - beganPosition;
            var normal = vector.normalized;
            var length = vector.magnitude;

            if (allowDragging)
            {
                var excess = length - worldKnobRange;
                if (excess < 0.0f)
                {
                    excess = 0.0f;
                }
                beganPosition = beganPosition + (excess * normal);
                RingPosition  = beganPosition;
            }

            movedPosition = beganPosition + (Mathf.Clamp(length, 0.0f, worldKnobRange) * normal);

            value   = (movedPosition - beganPosition) / worldKnobRange;
            value.x = inputCurve.Evaluate(Utility.Abs(value.x)) * Mathf.Sign(value.x);
            value.y = inputCurve.Evaluate(Utility.Abs(value.y)) * Mathf.Sign(value.y);

            if (snapAngles == SnapAngles.None)
            {
                snappedValue = value;

                if (lockToAxis == LockAxis.Horizontal)
                {
                    snappedValue.y = 0.0f;
                    KnobPosition   = beganPosition + (snappedValue * worldKnobRange);
                }
                else
                if (lockToAxis == LockAxis.Vertical)
                {
                    snappedValue.x = 0.0f;
                    KnobPosition   = beganPosition + (snappedValue * worldKnobRange);
                }
                else
                {
                    KnobPosition = movedPosition;
                }
            }
            else
            {
                snappedValue = SnapTo(value, snapAngles);
                KnobPosition = beganPosition + (snappedValue * worldKnobRange);
            }

            RingPosition = beganPosition;
        }
Beispiel #10
0
        public override void TouchMoved(Touch touch)
        {
            if (currentTouch != touch)
            {
                return;
            }

            thisPosition = TouchManager.ScreenToWorldPoint(touch.position);
        }
Beispiel #11
0
        public override void TouchMoved(Touch touch)
        {
            if (currentTouch != touch)
            {
                return;
            }
            movedPosition = TouchManager.ScreenToWorldPoint(touch.position);
            if (lockToAxis == LockAxis.Horizontal && allowDraggingAxis == DragAxis.Horizontal)
            {
                movedPosition.y = beganPosition.y;
            }
            else if (lockToAxis == LockAxis.Vertical && allowDraggingAxis == DragAxis.Vertical)
            {
                movedPosition.x = beganPosition.x;
            }
            Vector3 vector     = movedPosition - beganPosition;
            Vector3 normalized = vector.normalized;
            float   magnitude  = vector.magnitude;

            if (allowDragging)
            {
                float num = magnitude - worldKnobRange;
                if (num < 0f)
                {
                    num = 0f;
                }
                Vector3 vector2 = num * normalized;
                if (allowDraggingAxis == DragAxis.Horizontal)
                {
                    vector2.y = 0f;
                }
                else if (allowDraggingAxis == DragAxis.Vertical)
                {
                    vector2.x = 0f;
                }
                beganPosition += vector2;
                RingPosition   = beganPosition;
            }
            movedPosition = beganPosition + Mathf.Clamp(magnitude, 0f, worldKnobRange) * normalized;
            if (lockToAxis == LockAxis.Horizontal)
            {
                movedPosition.y = beganPosition.y;
            }
            else if (lockToAxis == LockAxis.Vertical)
            {
                movedPosition.x = beganPosition.x;
            }
            if (snapAngles != 0)
            {
                movedPosition = TouchControl.SnapTo(movedPosition - beganPosition, snapAngles) + beganPosition;
            }
            RingPosition = beganPosition;
            KnobPosition = movedPosition;
            value        = (movedPosition - beganPosition) / worldKnobRange;
            value.x      = inputCurve.Evaluate(Utility.Abs(value.x)) * Mathf.Sign(value.x);
            value.y      = inputCurve.Evaluate(Utility.Abs(value.y)) * Mathf.Sign(value.y);
        }
Beispiel #12
0
 public override void ConfigureControl()
 {
     resetPosition           = OffsetToWorldPosition(anchor, offset, offsetUnitType, lockAspectRatio: true);
     base.transform.position = resetPosition;
     ring.Update(forceUpdate: true);
     knob.Update(forceUpdate: true);
     worldActiveArea = TouchManager.ConvertToWorld(activeArea, areaUnitType);
     worldKnobRange  = TouchManager.ConvertToWorld(knobRange, knob.SizeUnitType);
 }
        public override void ConfigureControl()
        {
            var worldOffset = (Vector3)offset * TouchManager.UnitToWorld;

            transform.position = TouchManager.ViewToWorldPoint(TouchUtility.AnchorToViewPoint(anchor)) + worldOffset;

            ScaleSprite(buttonGameObject, buttonRenderer, buttonSize);

            worldButtonSize = buttonSize * TouchManager.HalfUnitToWorld;
        }
        public override void TouchBegan(Touch touch)
        {
            if (currentTouch != null)
            {
                return;
            }

            if (Contains(TouchManager.ScreenToWorldPoint(touch.position)))
            {
                state        = true;
                currentTouch = touch;
            }
        }
Beispiel #15
0
        public override void SubmitControlState(ulong updateTick, float deltaTime)
        {
            if (currentTouch == null && allowSlideToggle)
            {
                ButtonState = false;
                var touchCount = TouchManager.TouchCount;
                for (var i = 0; i < touchCount; i++)
                {
                    ButtonState = ButtonState || button.Contains(TouchManager.GetTouch(i));
                }
            }

            SubmitButtonState(target, ButtonState, updateTick, deltaTime);
        }
Beispiel #16
0
        static void UpdateScreenSize()
        {
            knownScreenSize = ScreenSize;
            ViewSize        = TouchManager.ViewToWorldPoint(Vector2.one) * 2.0f;
            UnitToWorld     = Mathf.Min(ViewSize.x, ViewSize.y);
            HalfUnitToWorld = UnitToWorld * 0.5f;

            var touchControlCount = touchControls.Count;

            for (int i = 0; i < touchControlCount; i++)
            {
                touchControls[i].ConfigureControl();
            }
        }
Beispiel #17
0
        protected Vector3 OffsetToWorldPosition(TouchControlAnchor anchor, Vector2 offset, TouchUnitType offsetUnitType)
        {
            Vector3 worldOffset;

            if (offsetUnitType == TouchUnitType.Pixels)
            {
                worldOffset = TouchUtility.RoundVector(offset) * TouchManager.PixelToWorld;
            }
            else
            {
                worldOffset = (Vector3)offset * TouchManager.PercentToWorld;
            }
            return(TouchManager.ViewToWorldPoint(TouchUtility.AnchorToViewPoint(anchor)) + worldOffset);
        }
 public override void TouchBegan(Touch touch)
 {
     if (currentTouch == null)
     {
         beganPosition = TouchManager.ScreenToWorldPoint(touch.position);
         if (worldActiveArea.Contains(beganPosition))
         {
             thisPosition = TouchManager.ScreenToViewPoint(touch.position * 100f);
             lastPosition = thisPosition;
             currentTouch = touch;
             beganTime    = Time.realtimeSinceStartup;
         }
     }
 }
        public override void SubmitControlState(ulong updateTick)
        {
            if (currentTouch == null && allowSlideToggle)
            {
                state = false;
                var touchCount = TouchManager.TouchCount;
                for (int i = 0; i < touchCount; i++)
                {
                    state = state || Contains(TouchManager.ScreenToWorldPoint(TouchManager.GetTouch(i).position));
                }
            }

            SubmitButtonState(target, state, updateTick);
        }
        public override void ConfigureControl()
        {
            var worldOffset = (Vector3)offset * TouchManager.UnitToWorld;

            resetPosition      = TouchManager.ViewToWorldPoint(TouchUtility.AnchorToViewPoint(anchor)) + worldOffset;
            transform.position = resetPosition;

            ScaleSprite(ringGameObject, ringRenderer, ringSize);
            ScaleSprite(knobGameObject, knobRenderer, knobSize);

            worldActiveArea = TouchManager.ViewToWorldRect(activeArea);
            worldRingSize   = ringSize * TouchManager.HalfUnitToWorld;
            worldKnobSize   = knobSize * TouchManager.HalfUnitToWorld;
            worldKnobRange  = knobRange * TouchManager.HalfUnitToWorld;
        }
 public override void TouchEnded(Touch touch)
 {
     if (currentTouch == touch)
     {
         Vector3 a      = TouchManager.ScreenToWorldPoint(touch.position);
         Vector3 vector = a - beganPosition;
         float   num    = Time.realtimeSinceStartup - beganTime;
         if (vector.magnitude <= maxTapMovement && num <= maxTapDuration && tapTarget != 0)
         {
             fireButtonTarget = true;
         }
         thisPosition = Vector3.zero;
         lastPosition = Vector3.zero;
         currentTouch = null;
     }
 }
Beispiel #22
0
        public override void TouchBegan(Touch touch)
        {
            if (currentTouch != null)
            {
                return;
            }

            var beganPosition = TouchManager.ScreenToWorldPoint(touch.position);

            if (worldActiveArea.Contains(beganPosition))
            {
                thisPosition = beganPosition;
                lastPosition = beganPosition;
                currentTouch = touch;
            }
        }
 public override void TouchBegan(Touch touch)
 {
     if (currentTouch == null)
     {
         beganPosition = TouchManager.ScreenToWorldPoint(touch.position);
         if (worldActiveArea.Contains(beganPosition))
         {
             lastPosition       = beganPosition;
             currentTouch       = touch;
             currentVector      = Vector2.zero;
             currentVectorIsSet = false;
             fireButtonTarget   = true;
             nextButtonTarget   = ButtonTarget.None;
             lastButtonTarget   = ButtonTarget.None;
         }
     }
 }
Beispiel #24
0
        public override void SubmitControlState(ulong updateTick, float deltaTime)
        {
#if !(UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2)
            if (pressureSensitive)
            {
                var buttonValue = 0.0f;
                if (currentTouch == null)
                {
                    if (allowSlideToggle)
                    {
                        var touchCount = TouchManager.TouchCount;
                        for (var i = 0; i < touchCount; i++)
                        {
                            var touch = TouchManager.GetTouch(i);
                            if (button.Contains(touch))
                            {
                                buttonValue = Utility.Max(buttonValue, touch.NormalizedPressure);
                            }
                        }
                    }
                }
                else
                {
                    buttonValue = currentTouch.NormalizedPressure;
                }

                ButtonState = buttonValue > 0.0f;
                SubmitButtonValue(target, buttonValue, updateTick, deltaTime);
                return;
            }
#endif

            if (currentTouch == null && allowSlideToggle)
            {
                ButtonState = false;
                var touchCount = TouchManager.TouchCount;
                for (var i = 0; i < touchCount; i++)
                {
                    ButtonState = ButtonState || button.Contains(TouchManager.GetTouch(i));
                }
            }

            SubmitButtonState(target, ButtonState, updateTick, deltaTime);
        }
Beispiel #25
0
 public override void SubmitControlState(ulong updateTick, float deltaTime)
 {
     if (pressureSensitive)
     {
         float num = 0f;
         if (currentTouch == null)
         {
             if (allowSlideToggle)
             {
                 int touchCount = TouchManager.TouchCount;
                 for (int i = 0; i < touchCount; i++)
                 {
                     Touch touch = TouchManager.GetTouch(i);
                     if (button.Contains(touch))
                     {
                         num = Utility.Max(num, touch.normalizedPressure);
                     }
                 }
             }
         }
         else
         {
             num = currentTouch.normalizedPressure;
         }
         ButtonState = (num > 0f);
         SubmitButtonValue(target, num, updateTick, deltaTime);
         return;
     }
     if (currentTouch == null && allowSlideToggle)
     {
         ButtonState = false;
         int touchCount2 = TouchManager.TouchCount;
         for (int j = 0; j < touchCount2; j++)
         {
             ButtonState = (ButtonState || button.Contains(TouchManager.GetTouch(j)));
         }
     }
     SubmitButtonState(target, ButtonState, updateTick, deltaTime);
 }
 public override void TouchEnded(Touch touch)
 {
     if (currentTouch == touch)
     {
         currentTouch       = null;
         currentVector      = Vector2.zero;
         currentVectorIsSet = false;
         Vector3 b = TouchManager.ScreenToWorldPoint(touch.position);
         if ((beganPosition - b).magnitude < sensitivity)
         {
             fireButtonTarget = true;
             nextButtonTarget = tapTarget;
             lastButtonTarget = ButtonTarget.None;
         }
         else
         {
             fireButtonTarget = false;
             nextButtonTarget = ButtonTarget.None;
             lastButtonTarget = ButtonTarget.None;
         }
     }
 }
Beispiel #27
0
        public override void TouchEnded(Touch touch)
        {
            if (currentTouch != touch)
            {
                return;
            }

            var endedPosition = TouchManager.ScreenToWorldPoint(touch.position);
            var deltaPosition = endedPosition - beganPosition;

            var deltaTime = Time.realtimeSinceStartup - beganTime;

            if (deltaPosition.magnitude <= maxTapMovement && deltaTime <= maxTapDuration)
            {
                if (tapTarget != ButtonTarget.None)
                {
                    fireButtonTarget = true;
                }
            }

            thisPosition = Vector3.zero;
            lastPosition = Vector3.zero;
            currentTouch = null;
        }
 void OnEnable()
 {
     touchManager  = target as TouchManager;
     headerTexture = Internal.EditorTextures.TouchManagerHeader;
 }
Beispiel #29
0
 public override void ConfigureControl()
 {
     worldActiveArea = TouchManager.ConvertToWorld(activeArea, areaUnitType);
 }
Beispiel #30
0
 public bool Contains(Touch touch)
 {
     return(Contains(TouchManager.ScreenToWorldPoint(touch.position)));
 }