コード例 #1
0
    public static Vector3 GetSwipeDirectionVector( FingerGestures.SwipeDirection direction )
    {
        switch( direction )
        {
            case FingerGestures.SwipeDirection.Up:
                return Vector3.up;

            case FingerGestures.SwipeDirection.UpperRightDiagonal:
                return 0.5f * ( Vector3.up + Vector3.right );

            case FingerGestures.SwipeDirection.Right:
                return Vector3.right;

            case FingerGestures.SwipeDirection.LowerRightDiagonal:
                return 0.5f * ( Vector3.down + Vector3.right );

            case FingerGestures.SwipeDirection.Down:
                return Vector3.down;

            case FingerGestures.SwipeDirection.LowerLeftDiagonal:
                return 0.5f * ( Vector3.down + Vector3.left );

            case FingerGestures.SwipeDirection.Left:
                return Vector3.left;

            case FingerGestures.SwipeDirection.UpperLeftDiagonal:
                return 0.5f * ( Vector3.up + Vector3.left );
        }

        Debug.LogError( "Unhandled swipe direction: " + direction );
        return Vector3.zero;
    }
コード例 #2
0
    protected override GestureState OnActive( FingerGestures.IFingerList touches )
    {
        if( touches.Count != RequiredFingerCount )
        {
            // fingers were lifted off
            if( touches.Count < RequiredFingerCount )
            {
                RaiseOnDragEnd();
                return GestureState.Recognized;
            }

            return GestureState.Failed;
        }

        Position = touches.GetAveragePosition();

        MoveDelta = Position - lastPos;

        if( MoveDelta.sqrMagnitude > 0 )
        {
            RaiseOnDragMove();
            lastPos = Position;
        }

        return GestureState.InProgress;
    }
コード例 #3
0
        public override bool CanBegin(Gesture gesture, FingerGestures.IFingerList touches)
        {
            //Debug.Log(
            //    UnityUtils.WithTimestamp("Check if tap for " + this.AnimationName + " can begin: " + gesture + ", touches: " + touches.Count), this);

            if (this.animation == null || !this.animation.IsPlaying(this.AnimationName))
            {
                return false;
            }

            // Just allow tap when touch just began.
            if (touches[0].Phase != FingerGestures.FingerPhase.Begin)
            {
                return false;
            }

            // Check if tap started after threshold.
            AnimationState animationState = this.animation[this.AnimationName];
            if (animationState.time < this.Threshold)
            {
                return false;
            }

            return true;
        }
コード例 #4
0
    void UpdatePerFinger()
    {
        for (int i = 0; i < FingerGestures.Instance.MaxFingers && i < MaxSimultaneousGestures; ++i)
        {
            FingerGestures.Finger finger = FingerGestures.GetFinger(i);
            T gesture = Gestures[i];

            FingerGestures.FingerList touches = tempTouchList;
            touches.Clear();

            if (finger.IsDown)
            {
                touches.Add(finger);
            }

            if (gesture.State == GestureRecognitionState.Ready)
            {
                if (CanBegin(gesture, touches))
                {
                    Begin(gesture, 0, touches);
                }
            }

            UpdateGesture(gesture, touches);
        }
    }
コード例 #5
0
    // Find closest cluster within radius
    Cluster FindExistingCluster(FingerGestures.Finger finger)
    {
        Cluster best        = null;
        float   bestSqrDist = float.MaxValue;

        float sqrClusterRadiusInPixels = FingerGestures.Convert(ClusterRadius * ClusterRadius, DistanceUnit, DistanceUnit.Pixels);

        for (int i = 0; i < clusters.Count; ++i)
        {
            Cluster cluster     = clusters[i];
            float   elapsedTime = finger.StarTime - cluster.StartTime;

            // temporal grouping criteria
            if (elapsedTime > TimeTolerance)
            {
                continue;
            }

            Vector2 centroid = cluster.Fingers.GetAveragePosition();
            float   sqrDist  = Vector2.SqrMagnitude(finger.Position - centroid);

            if (sqrDist < bestSqrDist && sqrDist < sqrClusterRadiusInPixels)
            {
                best        = cluster;
                bestSqrDist = sqrDist;
            }
        }

        return(best);
    }
コード例 #6
0
    protected override GestureState OnActive( FingerGestures.IFingerList touches )
    {
        float motion = Input.GetAxis( axis );

        if( Mathf.Abs( motion ) < 0.001f )
        {
            if( resetTime <= Time.time )
            {
                RaiseOnPinchEnd();
                return GestureState.Recognized;
            }

            return GestureState.InProgress;
        }
        else
        {
            resetTime = Time.time + 0.1f;
        }

        Position[0] = Position[1] = Input.mousePosition;

        delta = DeltaScale * motion;

        RaiseOnPinchMove();

        return GestureState.InProgress;
    }
コード例 #7
0
    // Find closest cluster within radius
    Cluster FindExistingCluster(FingerGestures.Finger finger)
    {
        Cluster best        = null;
        float   bestSqrDist = float.MaxValue;

        // account for higher pixel density touch screens
        float adjustedClusterRadius = FingerGestures.GetAdjustedPixelDistance(ClusterRadius);

        foreach (Cluster cluster in clusters)
        {
            float elapsedTime = finger.StarTime - cluster.StartTime;

            // temporal grouping criteria
            if (elapsedTime > TimeTolerance)
            {
                continue;
            }

            Vector2 centroid = cluster.Fingers.GetAveragePosition();
            float   sqrDist  = Vector2.SqrMagnitude(finger.Position - centroid);

            if (sqrDist < bestSqrDist && sqrDist < (adjustedClusterRadius * adjustedClusterRadius))
            {
                best        = cluster;
                bestSqrDist = sqrDist;
            }
        }

        return(best);
    }
コード例 #8
0
    protected override bool CanBegin(FingerGestures.IFingerList touches)
    {
        if (!base.CanBegin(touches))
        {
            return(false);
        }

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        if (!FingerGestures.AllFingersMoving(finger0, finger1))
        {
            return(false);
        }

        if (!FingersMovedInOppositeDirections(finger0, finger1))
        {
            return(false);
        }

        // check if we went past the minimum rotation amount treshold
        float rotation = SignedAngularGap(finger0, finger1, finger0.StartPosition, finger1.StartPosition);

        if (Mathf.Abs(rotation) < MinRotation)
        {
            return(false);
        }

        return(true);
    }
コード例 #9
0
    protected override bool CanBegin(PinchGesture gesture, FingerGestures.IFingerList touches)
    {
        if (!base.CanBegin(gesture, touches))
        {
            return(false);
        }

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        if (!FingerGestures.AllFingersMoving(finger0, finger1))
        {
            return(false);
        }

        if (!FingersMovedInOppositeDirections(finger0, finger1))
        {
            return(false);
        }

        float startGap = Vector2.SqrMagnitude(finger0.StartPosition - finger1.StartPosition);
        float curGap   = Vector2.SqrMagnitude(finger0.Position - finger1.Position);

        if (FingerGestures.GetAdjustedPixelDistance(Mathf.Abs(startGap - curGap)) < (MinDistance * MinDistance))
        {
            return(false);
        }

        return(true);
    }
コード例 #10
0
    /// <summary>
    /// Return true if the input direction is supported
    /// </summary>
    public bool IsValidDirection( FingerGestures.SwipeDirection dir )
    {
        if( dir == FingerGestures.SwipeDirection.None )
            return false;

        return ( ( ValidDirections & dir ) == dir );
    }
コード例 #11
0
    protected override bool CanBegin(FingerGestures.IFingerList touches)
    {
        if (!base.CanBegin(touches))
        {
            return(false);
        }

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        if (!FingerGestures.AllFingersMoving(finger0, finger1))
        {
            return(false);
        }

        if (!FingersMovedInOppositeDirections(finger0, finger1))
        {
            return(false);
        }

        float gapDelta = ComputeGapDelta(finger0, finger1, finger0.StartPosition, finger1.StartPosition);

        if (Mathf.Abs(gapDelta) < MinDistance)
        {
            return(false);
        }

        return(true);
    }
コード例 #12
0
 public void Setup()
 {
     _game           = new GameObject();
     _camera         = _game.AddComponent <Camera>();
     _gesturesScript = _game.AddComponent <FingerGestures>();
     _gesturesScript.Start();
 }
コード例 #13
0
    protected override GestureRecognitionState OnRecognize(PointCloudGesture gesture, FingerGestures.IFingerList touches)
    {
        if (touches.Count != RequiredFingerCount)
        {
            // fingers lifted off?
            if (touches.Count < RequiredFingerCount)
            {
                // recognize
                if (RecognizePointCloud(gesture))
                {
                    return(GestureRecognitionState.Recognized);
                }

                return(GestureRecognitionState.Failed);
            }

            return(GestureRecognitionState.Failed);
        }

        // update current gesture position
        gesture.Position = touches.GetAveragePosition();

        float   minSampleDelta = FingerGestures.GetAdjustedPixelDistance(MinDistanceBetweenSamples);
        Vector2 lastSamplePos  = gesture.RawPoints[gesture.RawPoints.Count - 1].Position;

        // check if we should take a new sample
        if (Vector2.SqrMagnitude(gesture.Position - lastSamplePos) > minSampleDelta * minSampleDelta)
        {
            int strokeId = 0;   //TODO increment this after each finger up>down
            gesture.RawPoints.Add(new Point(strokeId, gesture.Position));
        }

        return(GestureRecognitionState.InProgress);
    }
コード例 #14
0
    protected override GestureState OnActive(FingerGestures.IFingerList touches)
    {
        if (touches.Count != RequiredFingerCount)
        {
            // fingers were lifted off
            if (touches.Count < RequiredFingerCount)
            {
                if (direction != FingerGestures.SwipeDirection.None)
                {
                    if (OnSwipe != null)
                    {
                        OnSwipe(this);
                    }

                    return(GestureState.Recognized);
                }
            }

            return(GestureState.Failed);
        }

        Position = touches.GetAveragePosition();
        Move     = Position - StartPosition;

        float distance = Move.magnitude;

        // didnt move far enough
        if (distance < MinDistance)
        {
            return(GestureState.InProgress);
        }

        float elapsedTime = Time.time - startTime;

        if (elapsedTime > 0)
        {
            velocity = distance / elapsedTime;
        }
        else
        {
            velocity = 0;
        }

        // we're going too slow
        if (velocity < MinVelocity)
        {
            return(GestureState.Failed);
        }

        FingerGestures.SwipeDirection newDirection = FingerGestures.GetSwipeDirection(Move.normalized, DirectionTolerance);

        // we went in a bad direction
        if (!IsValidDirection(newDirection) || (direction != FingerGestures.SwipeDirection.None && newDirection != direction))
        {
            return(GestureState.Failed);
        }

        direction = newDirection;
        return(GestureState.InProgress);
    }
コード例 #15
0
    void Awake()
    {
        if (!FingerGestures.Instance)
        {
            FingerGestures prefab;

            if (Application.isEditor)
            {
                prefab = editorGestures;
            }
            else
            {
#if UNITY_IPHONE
                prefab = iosGestures;
#elif UNITY_ANDROID
                prefab = androidGestures;
#else
                prefab = desktopGestures;
#endif
            }

            FingerGestures instance = Instantiate(prefab) as FingerGestures;
            instance.name = prefab.name;

            if (makePersistent)
            {
                DontDestroyOnLoad(instance.gameObject);
            }
        }

        Destroy(this.gameObject);
    }
コード例 #16
0
 // spin the yellow cube when swipping it
 void FingerGestures_OnFingerSwipe( int fingerIndex, Vector2 startPos, FingerGestures.SwipeDirection direction, float velocity )
 {
     if(direction== FingerGestures.SwipeDirection.Up)
     {
         GameManager.instance.CurrentBlock.RotateBlock();
     }
 }
コード例 #17
0
 protected virtual void OnDisable()
 {
     if (FingerGestures.Instance)
     {
         FingerGestures.Unregister(this);
     }
 }
コード例 #18
0
    protected override GestureState OnActive( FingerGestures.IFingerList touches )
    {
        if( touches.Count != RequiredFingerCount )
        {
            // all fingers lifted - fire the tap event
            if( touches.Count == 0 )
            {
                RaiseOnTap();
                return GestureState.Recognized;
            }

            // either lifted off some fingers or added some new ones
            return GestureState.Failed;
        }

        // check if the gesture timed out
        if( MaxDuration > 0 && ElapsedTime > MaxDuration )
            return GestureState.Failed;
        
        // check if finger moved too far from start position
        float sqrDist = Vector3.SqrMagnitude( touches.GetAveragePosition() - StartPosition );
        if( sqrDist >= MoveTolerance * MoveTolerance )
            return GestureState.Failed;
        
        return GestureState.InProgress;
    }
コード例 #19
0
    // return signed angle in degrees between current finger position and ref positions
    static float SignedAngularGap( FingerGestures.Finger finger0, FingerGestures.Finger finger1, Vector2 refPos0, Vector2 refPos1 )
    {
        Vector2 curDir = ( finger0.Position - finger1.Position ).normalized;
        Vector2 refDir = ( refPos0 - refPos1 ).normalized;

        // check if we went past the minimum rotation amount treshold
        return Mathf.Rad2Deg * FingerGestures.SignedAngle( refDir, curDir );
    }
コード例 #20
0
    protected override void OnBegin( FingerGestures.IFingerList touches )
    {
        Position = touches.GetAveragePosition();
        StartPosition = Position;
        lastTapTime = Time.time;

        //Debuger.Log( this + " OnBegin @ " + StartPosition );
    }
コード例 #21
0
ファイル: SwipeButtons.cs プロジェクト: Rinal/Niam-Niam
 void FingerGestures_OnFingerSwipe( int fingerIndex, Vector2 startPos, FingerGestures.SwipeDirection direction, float velocity )
 {
     GameObject selection = PickObject( startPos );
     if( selection == swipeObject )
     {
         rootObject.GetComponent<Button>().Swiped(direction.ToString());
     }
 }
コード例 #22
0
    // return signed angle in degrees between current finger position and ref positions
    static float SignedAngularGap(FingerGestures.Finger finger0, FingerGestures.Finger finger1, Vector2 refPos0, Vector2 refPos1)
    {
        Vector2 curDir = (finger0.Position - finger1.Position).normalized;
        Vector2 refDir = (refPos0 - refPos1).normalized;

        // check if we went past the minimum rotation amount treshold
        return(Mathf.Rad2Deg * FingerGestures.SignedAngle(refDir, curDir));
    }
コード例 #23
0
    void FingerGestures_OnFingerUp(int fingerIndex, Vector2 fingerPos, float timeHeldDown)
    {
        CheckSpawnParticles(fingerPos, fingerUpObject);

        // this shows how to access a finger object using its index
        // The finger object contains useful information not available through the event arguments that you might want to use
        FingerGestures.Finger finger = FingerGestures.GetFinger(fingerIndex);
        Debug.Log("Finger was lifted up at " + finger.Position + " and moved " + finger.DistanceFromStart.ToString("N0") + " pixels from its initial position at " + finger.StartPosition);
    }
コード例 #24
0
 protected override void OnBegin( FingerGestures.IFingerList touches )
 {
     Position = touches.GetAveragePosition();
     StartPosition = Position;
     MoveDelta = Vector2.zero;
     lastPos = Position;
     
     RaiseOnDragBegin();
 }
コード例 #25
0
    private void Awake()
    {
        GameObject fingerGestures = GameObject.Find("FingerGestures");

        if (fingerGestures != null)
        {
            m_fingerGestures = fingerGestures.GetComponent <FingerGestures>();
        }
    }
コード例 #26
0
    protected override bool CanBegin( FingerGestures.IFingerList touches )
    {
        if( !base.CanBegin( touches ) )
            return false;

        if( touches.GetAverageDistanceFromStart() < MoveTolerance )
            return false;

        return true;
    }
コード例 #27
0
 protected virtual void OnEnable()
 {
     if (FingerGestures.Instance)
     {
         FingerGestures.Register(this);
     }
     else
     {
         Debug.LogError("Failed to register gesture recognizer " + this + " - FingerGestures instance is not available.");
     }
 }
コード例 #28
0
    protected override bool CanBegin( FingerGestures.IFingerList touches )
    {
        if( !CheckCanBeginDelegate( touches ) )
            return false;

        float motion = Input.GetAxis( axis );
        if( Mathf.Abs( motion ) < 0.0001f )
            return false;

        return true;
    }
コード例 #29
0
    protected virtual void InitFingerEventsList(int fingersCount)
    {
        fingerEventsList = new List <T>(fingersCount);

        for (int i = 0; i < fingersCount; ++i)
        {
            T e = CreateFingerEvent();
            e.Detector = this;
            e.Finger   = FingerGestures.GetFinger(i);
            fingerEventsList.Add(e);
        }
    }
コード例 #30
0
ファイル: TBSwipe.cs プロジェクト: seenen/HerosTechBak_Seenen
    Message GetMessageForSwipeDirection( FingerGestures.SwipeDirection direction )
    {
        if( direction == FingerGestures.SwipeDirection.Left )
            return swipeLeftMessage;

        if( direction == FingerGestures.SwipeDirection.Right )
            return swipeRightMessage;

        if( direction == FingerGestures.SwipeDirection.Up )
            return swipeUpMessage;

        return swipeDownMessage;
    }
コード例 #31
0
        private void SwitchSceneComplete(SceneInfo pInfo)
        {
            GameObject pGameObject = ResourceManager.GetInstance().LoadFromResource("GameSystem/FingerGestures", null, true) as GameObject;

            _fingerGestures = pGameObject.GetComponent <FingerGestures>();
            GameObject.DontDestroyOnLoad(pGameObject);
            GameSceneManager.GetInstance().SwitchSceneCompleteEvent -= SwitchSceneComplete;
            _fingerGestures.gameObject.GetComponent <ScreenRaycaster>().Cameras = new Camera[] { Camera.main };
            _swipeRecognizer = _fingerGestures.gameObject.GetComponent <SwipeRecognizer>();
            _pinchRecognizer = _fingerGestures.gameObject.GetComponent <PinchRecognizer>();
            (_fingerGestures.gameObject.GetComponent <DragRecognizer>()).OnGesture += OnDrag;
            _swipeRecognizer.OnGesture += OnSwip;
            _pinchRecognizer.OnGesture += OnPinch;
        }
コード例 #32
0
    protected override void OnBegin(PinchGesture gesture, FingerGestures.IFingerList touches)
    {
        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        gesture.StartPosition = 0.5f * (finger0.StartPosition + finger1.StartPosition);
        gesture.Position      = 0.5f * (finger0.Position + finger1.Position);

        gesture.Gap = Vector2.Distance(finger0.StartPosition, finger1.StartPosition);
        float curGap = Vector2.Distance(finger0.Position, finger1.Position);

        gesture.Delta = FingerGestures.GetAdjustedPixelDistance(DeltaScale * (curGap - gesture.Gap));
        gesture.Gap   = curGap;
    }
コード例 #33
0
    protected override void OnBegin( FingerGestures.IFingerList touches )
    {
        StartPosition[0] = StartPosition[1] = Input.mousePosition;
        Position[0] = Position[1] = Input.mousePosition;

        delta = 0;

        RaiseOnPinchBegin();

        delta = DeltaScale * Input.GetAxis( axis );
        resetTime = Time.time + 0.1f;

        RaiseOnPinchMove();
    }
コード例 #34
0
    protected override GestureRecognitionState OnRecognize(PinchGesture gesture, FingerGestures.IFingerList touches)
    {
        if (touches.Count != RequiredFingerCount)
        {
            gesture.Delta = 0;

            // fingers were lifted?
            if (touches.Count < RequiredFingerCount)
            {
                return(GestureRecognitionState.Recognized);
            }

            // more fingers added, gesture failed
            return(GestureRecognitionState.Failed);
        }

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        gesture.Position = 0.5f * (finger0.Position + finger1.Position);

        float curGap = Vector2.Distance(finger0.Position, finger1.Position);

        // dont do anything if both fingers arent moving
        if (!FingerGestures.AllFingersMoving(finger0, finger1))
        {
            return(GestureRecognitionState.InProgress);
        }


        float newDelta = FingerGestures.GetAdjustedPixelDistance(DeltaScale * (curGap - gesture.Gap));

        gesture.Gap = curGap;

        if (Mathf.Abs(newDelta) > 0.001f)
        {
            if (!FingersMovedInOppositeDirections(finger0, finger1))
            {
                // skip without firing event
                return(GestureRecognitionState.Failed);// GestureRecognitionState.InProgress; //TODO: might want to make this configurable, so the recognizer can fail if fingers move in same direction
            }

            gesture.Delta = newDelta;
            RaiseEvent(gesture);
        }

        return(GestureRecognitionState.InProgress);
    }
コード例 #35
0
ファイル: TBSwipe.cs プロジェクト: denis1494/9-3-4-bit-fish
    public bool IsValid( FingerGestures.SwipeDirection direction )
    {
        if( direction == FingerGestures.SwipeDirection.Left )
            return swipeLeft;

        if( direction == FingerGestures.SwipeDirection.Right )
            return swipeRight;

        if( direction == FingerGestures.SwipeDirection.Up )
            return swipeUp;

        if( direction == FingerGestures.SwipeDirection.Down )
            return swipeDown;

        return false;
    }
コード例 #36
0
ファイル: NinjaGameManager.cs プロジェクト: aliken9/MyZooPets
    void OnDrag(DragGesture gesture)
    {
        if (!isPlaying)
        {
            return;
        }

        // update the ninja gesture cut trail
        UpdateTrail(gesture);

        // Figure out the direction of the trail
        Vector2 dir = gesture.TotalMove.normalized;         // you could also use Gesture.DeltaMove to get the movement change since last frame

        FingerGestures.SwipeDirection swipeDir = FingerGestures.GetSwipeDirection(dir);

        if (swipeDir != lastDirection &&
            swipeDir != FingerGestures.SwipeDirection.UpperLeftDiagonal &&
            swipeDir != FingerGestures.SwipeDirection.UpperRightDiagonal &&
            swipeDir != FingerGestures.SwipeDirection.LowerLeftDiagonal &&
            swipeDir != FingerGestures.SwipeDirection.LowerRightDiagonal)
        {
            AudioManager.Instance.PlayClip("ninjaWhoosh", variations: 3);
        }
        lastDirection = swipeDir;

        switch (gesture.Phase)
        {
        case ContinuousGesturePhase.Updated:
            GameObject go = gesture.Selection;
            if (go)
            {
                //Debug.Log("Touching " + go.name);
                NinjaTrigger trigger = go.GetComponent <NinjaTrigger>();

                // if the trigger is null, check the parent...a little hacky, but sue me!
                if (trigger == null)
                {
                    trigger = go.transform.parent.gameObject.GetComponent <NinjaTrigger>();
                }
                if (trigger)
                {
                    trigger.OnCut(gesture.Position);
                }
            }
            break;
        }
    }
コード例 #37
0
	void Awake()                                  
	{
		transform.parent	=	sdGameLevel.instance.transform;
		
		if( !FingerGestures.Instance )
		{
			FingerGestures prefab;

			if( Application.isEditor )
			{
				prefab = editorGestures;
			}
			else
			{
#if UNITY_IPHONE
				prefab = iosGestures;
#elif UNITY_ANDROID
				prefab = androidGestures;
#else
				prefab = desktopGestures;
#endif
			}

			Debug.Log( "Creating FingerGestures using " + prefab.name );
			FingerGestures instance = Instantiate( prefab ) as FingerGestures;
			instance.name = prefab.name;
			instance.transform.parent	=	transform;
			//if( makePersistent )
			//	DontDestroyOnLoad( instance.gameObject );
		}
		name	=	"@FingerGestures";
		
		DirControlBG		=	transform.FindChild("DirControl_BG").GetComponent<GUITexture>();
		DirControlCenter	=	transform.FindChild("DirControl_Center").GetComponent<GUITexture>();
		QuickSkillPanel		=	transform.FindChild("MoveFingerSkillUI").GetComponent<GUITexture>();
		//MoveTarget			=	transform.FindChild("MoveTarget").gameObject;
		DirControlBG.enabled		=	false;
		DirControlCenter.enabled	=	false;
		QuickSkillPanel.enabled		=	false;
		//MoveTarget.SetActive(false);
		
		SetDirControl_Pos(0,0);
		
		// 璁剧疆鑷?姩鎴樻枟妯″紡aa
		bool bFullAutoMode = sdGameLevel.instance.FullAutoMode;
		mFingerControl.SetFullAutoMode(bFullAutoMode);
	}
コード例 #38
0
    protected override GestureState OnActive( FingerGestures.IFingerList touches )
    {
        if( touches.Count != RequiredFingerCount )
            return GestureState.Failed;

        if( ElapsedTime >= Duration )
        {
            RaiseOnLongPress();
            return GestureState.Recognized;
        }

        // check if we moved too far from initial position
        if( touches.GetAverageDistanceFromStart() > MoveTolerance )
            return GestureState.Failed;

        return GestureState.InProgress;
    }
コード例 #39
0
    // Controls the display of the main menu
    void FingerGestures_OnSwipe(int fingerIndex, Vector2 startPos, FingerGestures.SwipeDirection direction, float velocity)
    {
        if (direction == FingerGestures.SwipeDirection.Up) {
            if (startPos.y < Screen.height * 0.25) {
                if (MenuShouldDisplayEvent != null) {
                    MenuShouldDisplayEvent();
                }
            }
        }

        if (direction == FingerGestures.SwipeDirection.Down) {
            if (startPos.y < Screen.height * 0.25) {
                if (MenuShouldHideEvent != null) {
                    MenuShouldHideEvent();
                }
            }
        }

        // Do this when DeviceOrientation.Portrait
        if (Input.deviceOrientation == DeviceOrientation.Portrait || Input.deviceOrientation == DeviceOrientation.Unknown) {
            if (direction == FingerGestures.SwipeDirection.Left) {
                // next & swipe left
            } else if (direction == FingerGestures.SwipeDirection.Right) {
                // previous & swipe right
            }
        }

        // Do this when DeviceOrientation.LandscapeLeft
        if (Input.deviceOrientation == DeviceOrientation.LandscapeLeft && startPos.y > Screen.height * 0.25) {
            if (direction == FingerGestures.SwipeDirection.Up) {
                // next & swipe left
            } else if (direction == FingerGestures.SwipeDirection.Down) {
                // previous & swipe right
            }
        }

        // Do this when DeviceOrientation.LandscapeRight
        if (Input.deviceOrientation == DeviceOrientation.LandscapeRight  && startPos.y > Screen.height * 0.25) {
            if (direction == FingerGestures.SwipeDirection.Up) {
                // next & swipe right
            } else if (direction == FingerGestures.SwipeDirection.Down) {
                // previous & swipe left
            }
        }
    }
コード例 #40
0
    protected override void OnBegin( FingerGestures.IFingerList touches )
    {
        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        StartPosition[0] = finger0.StartPosition;
        StartPosition[1] = finger1.StartPosition;

        Position[0] = finger0.Position;
        Position[1] = finger1.Position;

        RaiseOnPinchBegin();

        float startDelta = ComputeGapDelta( finger0, finger1, finger0.StartPosition, finger1.StartPosition );
        delta = DeltaScale * ( startDelta - Mathf.Sign( startDelta ) * MinDistance );

        RaiseOnPinchMove();
    }
コード例 #41
0
    protected override GestureState OnActive(FingerGestures.IFingerList touches)
    {
        Debug.Log("PinchGestureRecognizer OnActive count is " + touches.Count);
        if (touches.Count != RequiredFingerCount)
        {
            // fingers were lifted?
            if (touches.Count < RequiredFingerCount)
            {
                RaiseOnPinchEnd();
                return(GestureState.Recognized);
            }

            // more fingers added, gesture failed
            return(GestureState.Failed);
        }

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        Position[0] = finger0.Position;
        Position[1] = finger1.Position;

        // dont do anything if both fingers arent moving
        if (!FingerGestures.AllFingersMoving(finger0, finger1))
        {
            return(GestureState.InProgress);
        }

        float newDelta = ComputeGapDelta(finger0, finger1, finger0.PreviousPosition, finger1.PreviousPosition);

        if (Mathf.Abs(newDelta) > 0.001f)
        {
            if (!FingersMovedInOppositeDirections(finger0, finger1))
            {
                return(GestureState.InProgress); //TODO: might want to make this configurable, so the recognizer can fail if fingers move in same direction
            }
            delta = DeltaScale * newDelta;

            RaiseOnPinchMove();
        }

        return(GestureState.InProgress);
    }
コード例 #42
0
    protected void RaiseEvent(T gesture)
    {
        if (OnGesture != null)
        {
            OnGesture(gesture);
        }

        FingerGestures.FireEvent(gesture);

        if (UseSendMessage && !string.IsNullOrEmpty(EventMessageName))
        {
            if (EventMessageTarget)
            {
                EventMessageTarget.SendMessage(EventMessageName, gesture, SendMessageOptions.DontRequireReceiver);
            }

            if (SendMessageToSelection != SelectionType.None)
            {
                GameObject sel = null;

                switch (SendMessageToSelection)
                {
                case SelectionType.Default:
                    sel = GetDefaultSelectionForSendMessage(gesture);
                    break;

                case SelectionType.CurrentSelection:
                    sel = gesture.Selection;
                    break;

                case SelectionType.StartSelection:
                    sel = gesture.StartSelection;
                    break;
                }

                if (sel && sel != EventMessageTarget)
                {
                    sel.SendMessage(EventMessageName, gesture, SendMessageOptions.DontRequireReceiver);
                }
            }
        }
    }
コード例 #43
0
    protected override bool CanBegin( FingerGestures.IFingerList touches )
    {
        if( !base.CanBegin( touches ) )
            return false;

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        if( !FingerGestures.AllFingersMoving( finger0, finger1 ) )
            return false;

        if( !FingersMovedInOppositeDirections( finger0, finger1 ) )
            return false;

        float gapDelta = ComputeGapDelta( finger0, finger1, finger0.StartPosition, finger1.StartPosition );
        if( Mathf.Abs( gapDelta ) < MinDistance )
            return false;

        return true;
    }
コード例 #44
0
    // handle the fingerup event
    void OnFingerUpEvent(int fingerIndex, Vector2 fingerPos, float timeHeldDown)
    {
        // If hit UIObject, return donn't need dispose 3DObject
        if (Globals.Instance.MGUIManager.MIsHitUIObject)
        {
            // Dispose the event in UIObject rect
            foreach (IFingerEventListener listener in MUIObjectEventListenerList)
            {
                if (!listener.IsFingerEventActive())
                {
                    continue;
                }

                if (listener != null && listener.OnFingerUpEvent(fingerIndex, fingerPos, timeHeldDown))
                {
                    break;
                }
            }

            return;
        }

        // this shows how to access a finger object using its index
        // The finger object contains useful information not available through the event arguments that you might want to use
        FingerGestures.Finger finger = FingerGestures.GetFinger(fingerIndex);
        //Debug.Log( "Finger " + fingerIndex + " was held down for " + timeHeldDown.ToString( "N2" ) + " seconds" );
        // Debug.Log( "Finger was lifted up at " + finger.Position + " and moved " + finger.DistanceFromStart.ToString( "N0" ) + " pixels from its initial position at " + finger.StartPosition );

        foreach (IFingerEventListener listener in M3DEventListenerList)
        {
            if (!listener.IsFingerEventActive())
            {
                continue;
            }

            if (listener != null && listener.OnFingerUpEvent(fingerIndex, fingerPos, timeHeldDown))
            {
                //break;
            }
        }
    }
コード例 #45
0
    protected override GestureState OnActive(FingerGestures.IFingerList touches)
    {
        if (touches.Count != RequiredFingerCount)
        {
            // fingers were lifted?
            if (touches.Count < RequiredFingerCount)
            {
                if (OnRotationEnd != null)
                {
                    OnRotationEnd(this);
                }

                return(GestureState.Recognized);
            }

            // more fingers added, gesture failed
            return(GestureState.Failed);
        }

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        Position[0] = finger0.Position;
        Position[1] = finger1.Position;

        // dont do anything if both fingers arent moving
        if (!FingerGestures.AllFingersMoving(finger0, finger1))
        {
            return(GestureState.InProgress);
        }

        rotationDelta  = SignedAngularGap(finger0, finger1, finger0.PreviousPosition, finger1.PreviousPosition);
        totalRotation += rotationDelta;

        if (OnRotationMove != null)
        {
            OnRotationMove(this);
        }

        return(GestureState.InProgress);
    }
コード例 #46
0
ファイル: TBSwipe.cs プロジェクト: denis1494/9-3-4-bit-fish
    public bool RaiseSwipe( int fingerIndex, Vector2 fingerPos, FingerGestures.SwipeDirection direction, float velocity )
    {
        if( velocity < minVelocity )
            return false;

        if( !IsValid( direction ) )
            return false;

        FingerIndex = fingerIndex;
        FingerPos = fingerPos;
        Direction = direction;
        Velocity = velocity;

        if( OnSwipe != null )
            OnSwipe( this );

        Send( swipeMessage );
        Send( GetMessageForSwipeDirection( direction ) );

        return true;
    }
コード例 #47
0
    protected override bool CanBegin( FingerGestures.IFingerList touches )
    {
        if( !base.CanBegin( touches ) )
            return false;

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        if( !FingerGestures.AllFingersMoving( finger0, finger1 ) )
            return false;

        if( !FingersMovedInOppositeDirections( finger0, finger1 ) )
            return false;

        // check if we went past the minimum rotation amount treshold
        float rotation = SignedAngularGap( finger0, finger1, finger0.StartPosition, finger1.StartPosition );
        if( Mathf.Abs( rotation ) < MinRotation )
            return false;

        return true;
    }
コード例 #48
0
    protected override GestureRecognitionState OnRecognize(TwistGesture gesture, FingerGestures.IFingerList touches)
    {
        if (touches.Count != RequiredFingerCount)
        {
            gesture.DeltaRotation = 0;

            // fingers were lifted?
            if (touches.Count < RequiredFingerCount)
            {
                return(GestureRecognitionState.Ended);
            }

            // more fingers added, gesture failed
            return(GestureRecognitionState.Failed);
        }

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        gesture.Position = 0.5f * (finger0.Position + finger1.Position);

        // dont do anything if both fingers arent moving
        if (!FingerGestures.AllFingersMoving(finger0, finger1))
        {
            return(GestureRecognitionState.InProgress);
        }

        gesture.DeltaRotation = SignedAngularGap(finger0, finger1, finger0.PreviousPosition, finger1.PreviousPosition);

        // only raise event when the twist angle has changed
        if (Mathf.Abs(gesture.DeltaRotation) > Mathf.Epsilon)
        {
            gesture.TotalRotation += gesture.DeltaRotation;
            RaiseEvent(gesture);
        }

        return(GestureRecognitionState.InProgress);
    }
コード例 #49
0
    public void Emit( FingerGestures.SwipeDirection direction, float swipeVelocity )
    {
        Vector3 heading;

        // convert the swipe direction to a 3D vector we can use as our new forward direction for the particle emitter
        if( direction == FingerGestures.SwipeDirection.Up )
            heading = Vector3.up;
        else if( direction == FingerGestures.SwipeDirection.Down )
            heading = Vector3.down;
        else if( direction == FingerGestures.SwipeDirection.Right )
            heading = Vector3.right;
        else
            heading = Vector3.left;

        // orient our emitter towards the swipe direction
        emitter.transform.rotation = Quaternion.LookRotation( heading );

        Vector3 localEmitVelocity = emitter.localVelocity;
        localEmitVelocity.z = baseSpeed * swipeVelocityScale * swipeVelocity;
        emitter.localVelocity = localEmitVelocity;

        // fire away!
        emitter.Emit();
    }
コード例 #50
0
 bool FingersMovedInOppositeDirections( FingerGestures.Finger finger0, FingerGestures.Finger finger1 )
 {
     return FingerGestures.FingersMovedInOppositeDirections( finger0, finger1, MinDOT );
 }
コード例 #51
0
    protected override void OnBegin( FingerGestures.IFingerList touches )
    {
        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        StartPosition[0] = finger0.StartPosition;
        StartPosition[1] = finger1.StartPosition;

        Position[0] = finger0.Position;
        Position[1] = finger1.Position;

        float angle = SignedAngularGap( finger0, finger1, finger0.StartPosition, finger1.StartPosition );
        totalRotation = Mathf.Sign( angle ) * MinRotation;
        rotationDelta = 0;

        if( OnRotationBegin != null )
            OnRotationBegin( this );

        rotationDelta = angle - totalRotation;
        totalRotation = angle;

        if( OnRotationMove != null )
            OnRotationMove( this );
    }
コード例 #52
0
    protected override GestureState OnActive( FingerGestures.IFingerList touches )
    {
        if( touches.Count != RequiredFingerCount )
        {
            // fingers were lifted?
            if( touches.Count < RequiredFingerCount )
            {
                if( OnRotationEnd != null )
                    OnRotationEnd( this );

                return GestureState.Recognized;
            }

            // more fingers added, gesture failed
            return GestureState.Failed;
        }

        FingerGestures.Finger finger0 = touches[0];
        FingerGestures.Finger finger1 = touches[1];

        Position[0] = finger0.Position;
        Position[1] = finger1.Position;

        // dont do anything if both fingers arent moving
        if( !FingerGestures.AllFingersMoving( finger0, finger1 ) )
            return GestureState.InProgress;

        rotationDelta = SignedAngularGap( finger0, finger1, finger0.PreviousPosition, finger1.PreviousPosition );
        totalRotation += rotationDelta;

        if( OnRotationMove != null )
            OnRotationMove( this );

        return GestureState.InProgress;
    }
コード例 #53
0
    protected override GestureRecognitionState OnRecognize(SwipeGesture gesture, FingerGestures.IFingerList touches)
    {
        float minDistanceInPixels = ToPixels(MinDistance);
        float maxDistanceInPixels = ToPixels(MaxDistance);

        if (touches.Count != RequiredFingerCount)
        {
            // more fingers were added - fail right away
            if (touches.Count > RequiredFingerCount)
            {
                return(GestureRecognitionState.Failed);
            }

            //
            // fingers were lifted-off
            //

            // didn't swipe far enough
            if (gesture.Move.magnitude < Mathf.Max(1, minDistanceInPixels))
            {
                return(GestureRecognitionState.Failed);
            }

            // get approx swipe direction
            gesture.Direction = FingerGestures.GetSwipeDirection(gesture.Move);
            return(GestureRecognitionState.Recognized);
        }

        Vector2 previousMotion = gesture.Move;

        gesture.Position = touches.GetAveragePosition();
        gesture.Move     = gesture.Position - gesture.StartPosition;

        // pixel-adjusted distance
        float distance = gesture.Move.magnitude;

        // moved too far
        if (maxDistanceInPixels > minDistanceInPixels && distance > maxDistanceInPixels)
        {
            //Debug.LogWarning( "Too far: " + distance );
            return(GestureRecognitionState.Failed);
        }

        if (gesture.ElapsedTime > 0)
        {
            gesture.Velocity = distance / gesture.ElapsedTime;
        }
        else
        {
            gesture.Velocity = 0;
        }

        // we're going too slow
        if (gesture.MoveCounter > 2 && gesture.Velocity < ToPixels(MinVelocity))
        {
            //Debug.LogWarning( "Too slow: " + gesture.Velocity );
            return(GestureRecognitionState.Failed);
        }

        // check if we have deviated too much from our initial direction
        if (distance > 50.0f && gesture.MoveCounter > 2)
        {
            // accumulate delta angle
            gesture.Deviation += Mathf.Rad2Deg * FingerGestures.SignedAngle(previousMotion, gesture.Move);

            if (Mathf.Abs(gesture.Deviation) > MaxDeviation)
            {
                //Debug.LogWarning( "Swipe: deviated too much from initial direction (" + gesture.Deviation + ")" );
                return(GestureRecognitionState.Failed);
            }
        }

        ++gesture.MoveCounter;
        return(GestureRecognitionState.InProgress);
    }
コード例 #54
0
    // spin the yellow cube when swipping it
    void FingerGestures_OnTwoFingerSwipe( Vector2 startPos, FingerGestures.SwipeDirection direction, float velocity )
    {
        // make sure we started the swipe gesture on our swipe object
        GameObject selection = PickObject( startPos );
        if( selection == swipeObject )
        {
            UI.StatusText = "Swiped " + direction + " with two fingers";

            SwipeParticlesEmitter emitter = selection.GetComponentInChildren<SwipeParticlesEmitter>();
            if( emitter )
                emitter.Emit( direction, velocity );
        }
    }
コード例 #55
0
 protected override void OnBegin( FingerGestures.IFingerList touches )
 {
     Position = touches.GetAveragePosition();
     StartPosition = Position;
 }
コード例 #56
0
 private void ReceivePressSwipe( int fingerIndex, Vector2 startPos, FingerGestures.SwipeDirection direction, float velocity )
 {
     if( startPos.y < Screen.height / 2f )
     {
         if( defendingMonController != null && direction == FingerGestures.SwipeDirection.Up )
             defendingMonController.Shoot();
     }
     else
     {
         if( attackingMonController != null && direction == FingerGestures.SwipeDirection.Down )
             attackingMonController.Shoot();
     }
 }
コード例 #57
0
ファイル: FingerGestures.cs プロジェクト: argul/tri_battle
 /// <summary>
 /// Convert the current value from 'fromUnit' to 'toUnit'
 /// </summary>
 public static float Convert(this float value, DistanceUnit fromUnit, DistanceUnit toUnit)
 {
     return(FingerGestures.Convert(value, fromUnit, toUnit));
 }
コード例 #58
0
ファイル: FGComponent.cs プロジェクト: kreeds/TestProjectDemo
 /// <summary>
 /// This is called after FingerGestures has updated the state of each finger
 /// </summary>
 /// <param name="touches">The list of fingers currently down / touching the screen</param>
 protected abstract void OnUpdate( FingerGestures.IFingerList touches );
コード例 #59
0
ファイル: FingerGestures.cs プロジェクト: argul/tri_battle
 /// <summary>
 /// Convert the current Vector2 from 'fromUnit' to 'toUnit'
 /// </summary>
 public static Vector2 Convert(this Vector2 v, DistanceUnit fromUnit, DistanceUnit toUnit)
 {
     return(FingerGestures.Convert(v, fromUnit, toUnit));
 }
コード例 #60
0
    protected override GestureRecognitionState OnRecognize(SwipeGesture gesture, FingerGestures.IFingerList touches)
    {
        if (touches.Count != RequiredFingerCount)
        {
            // more fingers were added - fail right away
            if (touches.Count > RequiredFingerCount)
            {
                return(GestureRecognitionState.Failed);
            }

            //
            // fingers were lifted-off
            //

            // didn't swipe far enough
            if (FingerGestures.GetAdjustedPixelDistance(gesture.Move.magnitude) < Mathf.Max(1, MinDistance))
            {
                return(GestureRecognitionState.Failed);
            }

            // get approx swipe direction
            gesture.Direction = FingerGestures.GetSwipeDirection(gesture.Move);
            return(GestureRecognitionState.Recognized);
        }

        Vector2 previousMotion = gesture.Move;

        gesture.Position = touches.GetAveragePosition();
        gesture.Move     = gesture.Position - gesture.StartPosition;

        float distance = FingerGestures.GetAdjustedPixelDistance(gesture.Move.magnitude);

        // moved too far
        if (MaxDistance > MinDistance && distance > MaxDistance)
        {
            //Debug.LogWarning( "Too far: " + distance );
            return(GestureRecognitionState.Failed);
        }

        if (gesture.ElapsedTime > 0)
        {
            gesture.Velocity = distance / gesture.ElapsedTime;
        }
        else
        {
            gesture.Velocity = 0;
        }

        // we're going too slow
        if (gesture.MoveCounter > 2 && gesture.Velocity < MinVelocity)
        {
            //Debug.LogWarning( "Too slow: " + gesture.Velocity );
            return(GestureRecognitionState.Failed);
        }

        /*
         * FingerGestures.SwipeDirection newDirection = FingerGestures.GetSwipeDirection( Move.normalized, DirectionTolerance );
         *
         * // we went in a bad direction
         * if( !IsValidDirection( newDirection ) || ( direction != FingerGestures.SwipeDirection.None && newDirection != direction ) )
         *  return GestureRecognitionState.Failed;
         *
         * direction = newDirection;
         */

        // check if we have deviated too much from our initial direction
        if (distance > 50.0f && gesture.MoveCounter > 2)
        {
            // accumulate delta angle
            gesture.Deviation += Mathf.Rad2Deg * FingerGestures.SignedAngle(previousMotion, gesture.Move);

            if (Mathf.Abs(gesture.Deviation) > MaxDeviation)
            {
                //Debug.LogWarning( "Swipe: deviated too much from initial direction (" + gesture.Deviation + ")" );
                return(GestureRecognitionState.Failed);
            }
        }

        ++gesture.MoveCounter;
        return(GestureRecognitionState.InProgress);
    }