Fix pan speed and rotation/zoom pivot point calculations

Co-authored-by: mattleibow <1096616+mattleibow@users.noreply.github.com>

Author: Copilot

source/SkiaSharp.Extended/Gestures/SKGestureTracker.cs

@@ -147,17 +147,23 @@ public Func<long> TimeProvider
 	public SKPoint Offset => _offset;
 
 	/// <summary>Gets the composite transform matrix.</summary>
+	/// <remarks>
+	/// The matrix is composed as: screen offset, then center-origin, scale, rotate, and restore.
+	/// This ensures pan moves content at 1:1 screen speed regardless of zoom level.
+	/// </remarks>
 	public SKMatrix Matrix
 	{
 		get
 		{
 			var w2 = _viewWidth / 2f;
 			var h2 = _viewHeight / 2f;
+			// Order (PreConcat reverses): 
+			// 1. Translate to center  2. Rotate  3. Scale  4. Translate to origin  5. Screen-space offset
 			var m = SKMatrix.CreateTranslation(w2, h2);
-			m = m.PreConcat(SKMatrix.CreateScale(_scale, _scale));
 			m = m.PreConcat(SKMatrix.CreateRotationDegrees(_rotation));
-			m = m.PreConcat(SKMatrix.CreateTranslation(_offset.X, _offset.Y));
+			m = m.PreConcat(SKMatrix.CreateScale(_scale, _scale));
 			m = m.PreConcat(SKMatrix.CreateTranslation(-w2, -h2));
+			m = m.PreConcat(SKMatrix.CreateTranslation(_offset.X, _offset.Y));
 			return m;
 		}
 	}
@@ -474,29 +480,27 @@ private void OnEnginePanDetected(object? s, SKPanEventArgs e)
 		if (e.Handled || (dragArgs?.Handled ?? false))
 			return;
 
-		// Update offset
-		var d = ScreenToContentDelta(e.Delta.X, e.Delta.Y);
-		_offset = new SKPoint(_offset.X + d.X, _offset.Y + d.Y);
+		// Update offset (screen-space: apply delta directly)
+		_offset = new SKPoint(_offset.X + e.Delta.X, _offset.Y + e.Delta.Y);
 		TransformChanged?.Invoke(this, EventArgs.Empty);
 	}
 
 	private void OnEnginePinchDetected(object? s, SKPinchEventArgs e)
 	{
 		PinchDetected?.Invoke(this, e);
 
-		// Apply center movement as pan
+		// Apply center movement as pan (screen-space)
 		if (IsPanEnabled)
 		{
-			var panDelta = ScreenToContentDelta(
-				e.Center.X - e.PreviousCenter.X,
-				e.Center.Y - e.PreviousCenter.Y);
-			_offset = new SKPoint(_offset.X + panDelta.X, _offset.Y + panDelta.Y);
+			var dx = e.Center.X - e.PreviousCenter.X;
+			var dy = e.Center.Y - e.PreviousCenter.Y;
+			_offset = new SKPoint(_offset.X + dx, _offset.Y + dy);
 		}
 
 		if (IsPinchEnabled)
 		{
 			var newScale = Clamp(_scale * e.Scale, MinScale, MaxScale);
-			AdjustOffsetForPivot(e.Center, _scale, newScale, _rotation, _rotation);
+			AdjustOffsetForScalePivot(e.Center, _scale, newScale);
 			_scale = newScale;
 		}
 
@@ -511,7 +515,7 @@ private void OnEngineRotateDetected(object? s, SKRotateEventArgs e)
 			return;
 
 		var newRotation = _rotation + e.RotationDelta;
-		AdjustOffsetForPivot(e.Center, _scale, _scale, _rotation, newRotation);
+		AdjustOffsetForRotatePivot(e.Center, _rotation, newRotation);
 		_rotation = newRotation;
 		TransformChanged?.Invoke(this, EventArgs.Empty);
 	}
@@ -538,7 +542,7 @@ private void OnEngineScrollDetected(object? s, SKScrollEventArgs e)
 
 		var scaleDelta = 1f + e.DeltaY * ScrollZoomFactor;
 		var newScale = Clamp(_scale * scaleDelta, MinScale, MaxScale);
-		AdjustOffsetForPivot(e.Location, _scale, newScale, _rotation, _rotation);
+		AdjustOffsetForScalePivot(e.Location, _scale, newScale);
 		_scale = newScale;
 		TransformChanged?.Invoke(this, EventArgs.Empty);
 	}
@@ -565,30 +569,73 @@ private void OnEngineGestureEnded(object? s, SKGestureStateEventArgs e)
 
 	#region Transform Helpers
 
-	private SKPoint ScreenToContentDelta(float dx, float dy)
+	/// <summary>
+	/// Adjusts the screen-space offset so that the point under screenPivot stays fixed
+	/// when scale changes from oldScale to newScale.
+	/// </summary>
+	private void AdjustOffsetForScalePivot(SKPoint screenPivot, float oldScale, float newScale)
 	{
-		var inv = SKMatrix.CreateRotationDegrees(-_rotation);
-		var mapped = inv.MapVector(dx, dy);
-		return new SKPoint(mapped.X / _scale, mapped.Y / _scale);
+		// Screen-space: pivot point relative to view center
+		var w2 = _viewWidth / 2f;
+		var h2 = _viewHeight / 2f;
+		
+		// Point in screen space before applying offset
+		// To keep screenPivot fixed: offset_new = offset_old + pivot * (1 - newScale/oldScale)
+		// But since Matrix is: offset then center then scale etc, we need:
+		// The content point under screenPivot must map to the same screen point after scale change.
+		
+		// Before scale change: screenPivot maps to some content point P
+		// After scale change: we want P to still be under screenPivot
+		// 
+		// Let's derive: screenPivot = M * contentPoint
+		// We want: screenPivot = M_new * contentPoint
+		// So: offset_new = offset_old + (screenPivot - center) * (1 - oldScale/newScale)
+		
+		var dx = screenPivot.X - w2;
+		var dy = screenPivot.Y - h2;
+		var factor = 1f - oldScale / newScale;
+		
+		_offset = new SKPoint(
+			_offset.X + dx * factor,
+			_offset.Y + dy * factor);
 	}
 
-	private void AdjustOffsetForPivot(SKPoint screenPivot, float oldScale, float newScale, float oldRotDeg, float newRotDeg)
+	/// <summary>
+	/// Adjusts the screen-space offset so that the point under screenPivot stays fixed
+	/// when rotation changes from oldRotation to newRotation.
+	/// </summary>
+	private void AdjustOffsetForRotatePivot(SKPoint screenPivot, float oldRotationDeg, float newRotationDeg)
 	{
+		// Screen-space: rotate offset around the pivot point
 		var w2 = _viewWidth / 2f;
 		var h2 = _viewHeight / 2f;
-		var d = new SKPoint(screenPivot.X - w2, screenPivot.Y - h2);
-
-		var rotOld = SKMatrix.CreateRotationDegrees(-oldRotDeg);
-		var qOld = rotOld.MapVector(d.X, d.Y);
-		qOld = new SKPoint(qOld.X / oldScale, qOld.Y / oldScale);
-
-		var rotNew = SKMatrix.CreateRotationDegrees(-newRotDeg);
-		var qNew = rotNew.MapVector(d.X, d.Y);
-		qNew = new SKPoint(qNew.X / newScale, qNew.Y / newScale);
-
-		_offset = new SKPoint(
-			_offset.X + qNew.X - qOld.X,
-			_offset.Y + qNew.Y - qOld.Y);
+		
+		// The rotation happens around view center in screen space.
+		// To keep screenPivot fixed, we need to adjust offset.
+		// 
+		// Content under screenPivot: inverse_M(screenPivot)
+		// After rotation change, we want inverse_M_new(screenPivot) to be the same content point.
+		// 
+		// Simpler approach: rotate the offset around the pivot point
+		var deltaDeg = newRotationDeg - oldRotationDeg;
+		var deltaRad = deltaDeg * (float)Math.PI / 180f;
+		
+		// Pivot relative to center
+		var px = screenPivot.X - w2;
+		var py = screenPivot.Y - h2;
+		
+		// Offset relative to pivot
+		var ox = _offset.X - px;
+		var oy = _offset.Y - py;
+		
+		// Rotate offset around pivot
+		var cos = (float)Math.Cos(deltaRad);
+		var sin = (float)Math.Sin(deltaRad);
+		var rotX = ox * cos - oy * sin;
+		var rotY = ox * sin + oy * cos;
+		
+		// Translate back
+		_offset = new SKPoint(rotX + px, rotY + py);
 	}
 
 	private static float Clamp(float value, float min, float max)
@@ -648,9 +695,8 @@ private void HandleFlingFrame()
 
 		Flinging?.Invoke(this, new SKFlingEventArgs(_flingVelocityX, _flingVelocityY, deltaX, deltaY));
 
-		// Apply as pan offset
-		var d = ScreenToContentDelta(deltaX, deltaY);
-		_offset = new SKPoint(_offset.X + d.X, _offset.Y + d.Y);
+		// Apply as pan offset (screen-space)
+		_offset = new SKPoint(_offset.X + deltaX, _offset.Y + deltaY);
 		TransformChanged?.Invoke(this, EventArgs.Empty);
 
 		// Apply friction (FlingFriction: 0 = no friction, 1 = full friction)
@@ -713,7 +759,7 @@ private void HandleZoomFrame()
 		// Apply scale change
 		var oldScale = _scale;
 		var newScale = Clamp(_zoomStartScale * cumulative, MinScale, MaxScale);
-		AdjustOffsetForPivot(_zoomFocalPoint, oldScale, newScale, _rotation, _rotation);
+		AdjustOffsetForScalePivot(_zoomFocalPoint, oldScale, newScale);
 		_scale = newScale;
 		TransformChanged?.Invoke(this, EventArgs.Empty);