Example #1
0
 public static void Pinch(PinchInfo PI)
 {
     if (IT_Gesture.onPinchE != null)
     {
         IT_Gesture.onPinchE(PI);
     }
 }
Example #2
0
 /// <summary>
 /// Called on pinch gestures
 /// </summary>
 protected virtual void OnPinch(PinchInfo pinch)
 {
     if (cameraRig != null)
     {
         DoPinchZoom(pinch);
     }
 }
Example #3
0
    /// <summary>
    /// Perform a zoom with the given pinch
    /// </summary>
    protected void DoPinchZoom(PinchInfo pinch)
    {
        float currentDistance = (pinch.touch1.currentPosition - pinch.touch2.currentPosition).magnitude;
        float prevDistance    = (pinch.touch1.previousPosition - pinch.touch2.previousPosition).magnitude;

        float zoomChange   = prevDistance / currentDistance;
        float prevZoomDist = cameraRig.zoomDist;

        cameraRig.SetZoom(zoomChange * cameraRig.rawZoomDist);

        // Calculate actual zoom change after clamping
        zoomChange = cameraRig.zoomDist / prevZoomDist;

        // First get floor position of middle of gesture
        Vector2 averageScreenPos = (pinch.touch1.currentPosition + pinch.touch2.currentPosition) * 0.5f;
        Ray     ray = cameraRig.cachedCamera.ScreenPointToRay(averageScreenPos);

        Vector3 worldPos = Vector3.zero;
        float   dist;

        if (cameraRig.floorPlane.Raycast(ray, out dist))
        {
            worldPos = ray.GetPoint(dist);
        }

        // Vector from our current look pos to this point
        Vector3 offsetValue = worldPos - cameraRig.lookPosition;

        // Pan towards or away from our zoom center
        PanCamera(offsetValue * (1 - zoomChange));
    }
Example #4
0
 public static void Pinch(PinchInfo PI)
 {
     if (onPinchE != null)
     {
         onPinchE(PI);
     }
 }
 //called when pinch is detected
 void OnPinch(PinchInfo pinfo)
 {
     if (!ImageTarget.gameObject.activeInHierarchy)
     {
         return;
     }
     zoomSpeed -= pinfo.magnitude * zoomSpeedModifier / IT_Gesture.GetDPIFactor();
 }
 //called when pinch is detected
 void OnPinch(PinchInfo pinfo)
 {
     zoomSpeed -= pinfo.magnitude * zoomSpeedModifier / IT_Gesture.GetDPIFactor();
 }
Example #7
0
 //called when pinch is detected
 void OnPinch(PinchInfo pinfo)
 {
     zoomSpeed-=pinfo.magnitude*zoomSpeedModifier;
 }
Example #8
0
 void OnPinch(PinchInfo pinfo)
 {
     zoomSpeed -= pinfo.magnitude * zoomSpeedModifier;
 }
 private void Update()
 {
     if (Input.touchCount == 2)
     {
         Touch   touch     = Input.touches[0];
         Touch   touch2    = Input.touches[1];
         Vector2 position  = touch.position;
         Vector2 position2 = touch2.position;
         Vector2 vector    = position - lastTouchPos1;
         Vector2 vector2   = position2 - lastTouchPos2;
         if (firstTouch)
         {
             firstTouch   = false;
             initPos1     = position;
             initPos2     = position2;
             initGradient = (position - position2).normalized;
             float x = position.x - position2.x;
             float y = position.y - position2.y;
             prevAngle = IT_Gesture.VectorToAngle(new Vector2(x, y));
         }
         if (touch.phase == TouchPhase.Moved && touch2.phase == TouchPhase.Moved)
         {
             float num = Vector2.Dot(vector, vector2);
             if (num < 0.5f)
             {
                 Vector2 normalized  = (position - initPos1).normalized;
                 Vector2 normalized2 = (position2 - initPos2).normalized;
                 float   num2        = Vector2.Dot(normalized, initGradient);
                 float   num3        = Vector2.Dot(normalized2, initGradient);
                 if (num2 < 0.7f && num3 < 0.7f)
                 {
                     float x2      = position.x - position2.x;
                     float y2      = position.y - position2.y;
                     float current = IT_Gesture.VectorToAngle(new Vector2(x2, y2));
                     float num4    = Mathf.DeltaAngle(current, prevAngle);
                     if (rotationSmoothing == _SmoothMethod.None)
                     {
                         RotateInfo rI = new RotateInfo(num4, position, position2);
                         IT_Gesture.Rotate(rI);
                     }
                     else
                     {
                         if (Mathf.Abs(num4) > 0f)
                         {
                             AddRotVal(num4);
                         }
                         float averageValue = GetAverageValue();
                         if (averageValue != 0f)
                         {
                             RotateInfo rI2 = new RotateInfo(averageValue, position, position2);
                             IT_Gesture.Rotate(rI2);
                         }
                     }
                     prevAngle = current;
                 }
                 else
                 {
                     Vector2 vector3 = position - position2;
                     float   num5    = (position - vector - (position2 - vector2)).magnitude - vector3.magnitude;
                     if (Mathf.Abs(num5) > 0.5f)
                     {
                         PinchInfo pI = new PinchInfo(num5, position, position2);
                         IT_Gesture.Pinch(pI);
                     }
                 }
             }
         }
         lastTouchPos1 = position;
         lastTouchPos2 = position2;
     }
     else if (!firstTouch)
     {
         firstTouch = true;
         if (rotationSmoothing != 0)
         {
             ClearRotVal();
         }
     }
 }
Example #10
0
 private void transformSingleAnchor(PinchDetector pinchDetector, PinchInfo pinchInfo)
 {
     var pinchPositionDelta = pinchInfo.pinchDetectorInitialPosition - pinchDetector.Position;
     pinchInfo.node.transform.position = pinchInfo.nodeInitialPosition - pinchPositionDelta;
 }
Example #11
0
    private void UpdatePinchSingle(PinchDetector pinchDetector, ClosestNode closestNode, ref PinchInfo pinchInfo)
    {
        // if pinch detected, update pinch info
        if (pinchDetector.DidStartPinch) {
            pinchInfo = GetPinchInfo(pinchDetector, closestNode);
        }

        if (pinchInfo.node != null) {
            // set node as pinched when pinch starts
            if (pinchDetector.DidStartPinch) {
                pinchInfo.node.Pinched = true;
            }

            // update node position to match pinch movement
            if (pinchDetector.IsPinching) {
                transformSingleAnchor(pinchDetector, pinchInfo);
            }

            // release node when pinch ends
            if (pinchDetector.DidEndPinch) {
                pinchInfo.node.Pinched = false;
            }
        }
    }
Example #12
0
 void OnPinch(PinchInfo pinfo)
 {
     this.zoomSpeed-=pinfo.magnitude* this.zoomSpeedModifier/IT_Gesture.GetDPIFactor();
 }
Example #13
0
    private void transformSingleAnchor(PinchDetector pinchDetector, PinchInfo pinchInfo)
    {
        var pinchPositionDelta = pinchInfo.pinchDetectorInitialPosition - pinchDetector.Position;

        pinchInfo.node.transform.position = pinchInfo.nodeInitialPosition - pinchPositionDelta;
    }
Example #14
0
    private void UpdatePinchSingle(PinchDetector pinchDetector, ClosestNode closestNode, ref PinchInfo pinchInfo)
    {
        // if pinch detected, update pinch info
        if (pinchDetector.DidStartPinch)
        {
            pinchInfo = GetPinchInfo(pinchDetector, closestNode);
        }

        if (pinchInfo.node != null)
        {
            // set node as pinched when pinch starts
            if (pinchDetector.DidStartPinch)
            {
                pinchInfo.node.Pinched = true;
            }

            // update node position to match pinch movement
            if (pinchDetector.IsPinching)
            {
                transformSingleAnchor(pinchDetector, pinchInfo);
            }

            // release node when pinch ends
            if (pinchDetector.DidEndPinch)
            {
                pinchInfo.node.Pinched = false;
            }
        }
    }
Example #15
0
 public static void Pinch(PinchInfo PI)
 {
     if(onPinchE!=null) onPinchE(PI);
 }
Example #16
0
    void Update()
    {
        if (Input.touchCount == 2)
        {
            Touch touch1 = Input.touches[0];
            Touch touch2 = Input.touches[1];

            Vector2 pos1 = touch1.position;
            Vector2 pos2 = touch2.position;

            Vector2 delta1 = pos1 - lastTouchPos1;
            Vector2 delta2 = pos2 - lastTouchPos2;


            if (firstTouch)
            {
                firstTouch = false;

                //for rotate
                initPos1     = pos1;
                initPos2     = pos2;
                initGradient = (pos1 - pos2).normalized;

                float curX = pos1.x - pos2.x;
                float curY = pos1.y - pos2.y;
                prevAngle = IT_Gesture.VectorToAngle(new Vector2(curX, curY));
            }


            if (touch1.phase == TouchPhase.Moved && touch2.phase == TouchPhase.Moved)
            {
                float dot = Vector2.Dot(delta1, delta2);
                if (dot < .5f)
                {
                    Vector2 grad1 = (pos1 - initPos1).normalized;
                    Vector2 grad2 = (pos2 - initPos2).normalized;

                    float dot1 = Vector2.Dot(grad1, initGradient);
                    float dot2 = Vector2.Dot(grad2, initGradient);

                    //rotate
                    if (dot1 < 0.7f && dot2 < 0.7f)
                    {
                        float curX     = pos1.x - pos2.x;
                        float curY     = pos1.y - pos2.y;
                        float curAngle = IT_Gesture.VectorToAngle(new Vector2(curX, curY));
                        float val      = Mathf.DeltaAngle(curAngle, prevAngle);

                        if (rotationSmoothing == _SmoothMethod.None)
                        {
                            RotateInfo rotateInfo = new RotateInfo(val, pos1, pos2);
                            IT_Gesture.Rotate(rotateInfo);
                        }
                        else
                        {
                            if (Mathf.Abs(val) > 0)
                            {
                                AddRotVal(val);
                            }

                            float valueAvg = GetAverageValue();
                            if (valueAvg != 0)
                            {
                                RotateInfo rotateInfo = new RotateInfo(valueAvg, pos1, pos2);
                                IT_Gesture.Rotate(rotateInfo);
                            }
                        }

                        prevAngle = curAngle;
                    }
                    //pinch
                    else
                    {
                        Vector2 curDist  = pos1 - pos2;
                        Vector2 prevDist = (pos1 - delta1) - (pos2 - delta2);
                        float   pinch    = prevDist.magnitude - curDist.magnitude;

                        if (Mathf.Abs(pinch) > 0.5f)
                        {
                            PinchInfo pinchInfo = new PinchInfo(pinch, pos1, pos2);
                            IT_Gesture.Pinch(pinchInfo);
                        }
                    }
                }
            }

            lastTouchPos1 = pos1;
            lastTouchPos2 = pos2;
        }
        else
        {
            if (!firstTouch)
            {
                firstTouch = true;
                if (rotationSmoothing != _SmoothMethod.None)
                {
                    ClearRotVal();
                }
            }
        }
    }
Example #17
0
	void Update(){
		if(Input.touchCount==2){
			Touch touch1=Input.touches[0];
			Touch touch2=Input.touches[1];
			
			Vector2 pos1 = touch1.position; 
			Vector2 pos2 = touch2.position; 
			
			Vector2 delta1 = pos1-lastTouchPos1;
			Vector2 delta2 = pos2-lastTouchPos2;
			
			
			if(firstTouch){
				firstTouch=false;
				
				//for rotate
				initPos1=pos1;
				initPos2=pos2;
				initGradient=(pos1-pos2).normalized;
				
				float curX=pos1.x-pos2.x;
				float curY=pos1.y-pos2.y;
				prevAngle=Gesture.VectorToAngle(new Vector2(curX, curY));				
			}
			
			
			if(touch1.phase==TouchPhase.Moved && touch2.phase==TouchPhase.Moved){
				
				float dot = Vector2.Dot(delta1, delta2);
				if(dot<0){
					Vector2 grad1=(pos1-initPos1).normalized;
					Vector2 grad2=(pos2-initPos2).normalized;
					
					float dot1=Vector2.Dot(grad1, initGradient);
					float dot2=Vector2.Dot(grad2, initGradient);
					
					//rotate				
					if(dot1<0.7f && dot2<0.7f){
						
						float curX=pos1.x-pos2.x;
						float curY=pos1.y-pos2.y;
						float curAngle=Gesture.VectorToAngle(new Vector2(curX, curY));
						float val=Mathf.DeltaAngle(curAngle, prevAngle);
						
						if(rotationSmoothing==_SmoothMethod.None){
							RotateInfo rotateInfo=new RotateInfo(val, pos1, pos2);
                            Gesture.Rotate(rotateInfo);
                        }
                        else{
                            if(Mathf.Abs(val)>0) AddRotVal(val);
                           
                            float valueAvg=GetAverageValue();
							RotateInfo rotateInfo=new RotateInfo(valueAvg, pos1, pos2);
                            Gesture.Rotate(rotateInfo);
                        }
						
						prevAngle=curAngle;
					}
					//pinch
					else{
						Vector2 curDist=pos1-pos2;
						Vector2 prevDist=(pos1-delta1)-(pos2-delta2);
						float pinch=prevDist.magnitude-curDist.magnitude;
						
						PinchInfo pinchInfo=new PinchInfo(pinch, pos1, pos2);
						Gesture.Pinch(pinchInfo);
					}
				}
				
				
			}
			
			lastTouchPos1=pos1;
			lastTouchPos2=pos2;
			
		}
		else{
			if(!firstTouch){
                firstTouch=true;
                if(rotationSmoothing!=_SmoothMethod.None) ClearRotVal();
            }
		}
	}
Example #18
0
 void onPinch(PinchInfo pinfo)
 {
     //This function get called when a pinch is done on the screen -> zoom
     zoomSpeed-=pinfo.magnitude*3;
 }