PanZoom: snap to pixel grid only at rest to kill spring-settle shiver (#177)

UpdateTransform() rounded both translations every frame. During a spring's
settling tail the pan translation moves <1px over many frames, so per-frame
rounding quantized that smooth glide into a 1px staircase while the unrounded
Scale term kept sliding underneath it - a visible shiver, worst on
high-refresh displays where the tail is sampled more finely.

Rounding only buys crisp 1:1 / the NVIDIA #55 fix at rest (at fractional
animation scales the image is sub-pixel sampled regardless), so gate it on a
new CanvasViewState.SnapTranslation flag: round when settled, use raw floats
during animation. Mirrors how XAML's Image behaves (layout rounding at rest,
smooth sub-pixel resampling while a composition scale animation runs).

Make PanZoomAnimationOnGoing the single source of truth - its setter keeps
SnapTranslation == !value, so snapping can never be left off at rest. Every
stop path (FinishSpringAnimation, StopAnimationSnappingToTarget, shrug
completion) clears the flag before rebuilding the transform so the resting
frame is snapped.

Author: riyasy

Src/FlyPhotos/Display/Controllers/CanvasViewManager.cs

@@ -85,7 +85,23 @@ internal class CanvasViewManager
     /// <summary>
     /// Indicates if a pan or zoom animation is currently in progress.
     /// </summary>
-    public bool PanZoomAnimationOnGoing { get; private set; }
+    /// <remarks>
+    /// This is the SINGLE SOURCE OF TRUTH for pixel snapping: the setter keeps
+    /// <see cref="CanvasViewState.SnapTranslation"/> equal to <c>!value</c>, so snapping is on exactly when
+    /// no animation is running. That makes it structurally impossible to leave snapping off at rest — every
+    /// path that ends an animation flips this back to <c>false</c> and thereby re-enables snapping. Stop
+    /// paths must still rebuild the transform (<c>UpdateTransform()</c>) AFTER setting this false so the
+    /// resting frame is rebuilt with rounding applied.
+    /// </remarks>
+    public bool PanZoomAnimationOnGoing
+    {
+        get;
+        private set
+        {
+            field = value;
+            _canvasViewState.SnapTranslation = !value;
+        }
+    }
 
     /// <summary>
     /// Fires when the view's "fitted to screen" state changes.
@@ -852,7 +868,7 @@ private void StartZoomAnimation(float targetScale, Point zoomAnchor)
         _zoomCenter = zoomAnchor;
 
         _currentAnimation = AnimationType.SpringZoom;
-        PanZoomAnimationOnGoing = true;
+        PanZoomAnimationOnGoing = true; // setter turns OFF snapping for the duration of the spring
         ViewChanged?.Invoke();
     }
 
@@ -885,7 +901,7 @@ private void StartSpringPanAndZoomAnimation(float targetScale, Point targetPosit
         _springPanZoomTargetCanvasSize = targetCanvasSize;
 
         _currentAnimation = AnimationType.SpringPanAndZoom;
-        PanZoomAnimationOnGoing = true;
+        PanZoomAnimationOnGoing = true; // setter turns OFF snapping for the duration of the spring
         ViewChanged?.Invoke();
     }
 
@@ -910,7 +926,7 @@ private void StartShrugAnimation()
     {
         _shrugStartPosition = _canvasViewState.ImagePos;
         _currentAnimation = AnimationType.Shrug;
-        PanZoomAnimationOnGoing = true;
+        PanZoomAnimationOnGoing = true; // setter turns OFF snapping for the duration of the wiggle
         _animationStopwatch.Restart();
         ViewChanged?.Invoke();
     }
@@ -954,8 +970,12 @@ private void FinishSpringAnimation()
     {
         _animationStopwatch.Stop();
         _currentAnimation = AnimationType.None;
-        PanZoomAnimationOnGoing = false;
+        PanZoomAnimationOnGoing = false; // setter re-enables snapping now that we are at rest
         _suppressZoomUpdateForNextAnimation = false;
+        // Rebuild the transform AFTER snapping is back on so the final resting frame lands on the
+        // device-pixel grid (crisp 1:1 / NVIDIA fix). The settled branch already wrote the exact target
+        // Scale/ImagePos, so this just re-snaps them. See CanvasViewState.SnapTranslation.
+        _canvasViewState.UpdateTransform();
         AnimationCompleted?.Invoke();
     }
 
@@ -968,6 +988,10 @@ private void FinishSpringAnimation()
     /// </summary>
     private void StopAnimationSnappingToTarget()
     {
+        // We are forcing the view to its settled target. Clear the animation flag FIRST (its setter
+        // re-enables snapping) so the per-case UpdateTransform calls below build a snapped, device-pixel
+        // aligned resting frame.
+        PanZoomAnimationOnGoing = false;
         switch (_currentAnimation)
         {
             case AnimationType.SpringZoom:
@@ -993,7 +1017,6 @@ private void StopAnimationSnappingToTarget()
 
         _animationStopwatch.Stop();
         _currentAnimation = AnimationType.None;
-        PanZoomAnimationOnGoing = false;
         _suppressZoomUpdateForNextAnimation = false;
     }
 
@@ -1122,11 +1145,10 @@ private void AnimateShrug()
             _animationStopwatch.Stop();
             // Animation finished. Ensure the image is back to its exact starting position.
             _canvasViewState.ImagePos = _shrugStartPosition;
+            _currentAnimation = AnimationType.None;
+            PanZoomAnimationOnGoing = false; // setter re-enables snapping BEFORE the rebuild below
             _canvasViewState.UpdateTransform();
             ViewChanged?.Invoke();
-
-            _currentAnimation = AnimationType.None;
-            PanZoomAnimationOnGoing = false;
             return;
         }
 

Src/FlyPhotos/Display/State/CanvasViewState.cs

@@ -16,13 +16,27 @@ internal class CanvasViewState
 
     public int Rotation = 0;
 
+    /// <summary>
+    /// When true (the default, i.e. at rest), the translations are rounded to whole pixels so the image lands
+    /// on the device-pixel grid — this keeps 1:1 rendering crisp and avoids the NVIDIA nearest-neighbour glitch
+    /// (#55). <see cref="Controllers.CanvasViewManager"/> clears it for the duration of a pan/zoom/shrug
+    /// animation: rounding a continuously-moving translation every frame quantizes the smooth spring-settle
+    /// into a 1px staircase, producing a visible "shiver" in the settling tail (worst on high-refresh
+    /// displays). Rounding buys nothing mid-animation anyway — the fractional Scale already sub-pixel-samples
+    /// the image — so we round only when settled. This mirrors how the XAML Image element behaves (layout
+    /// rounding at rest, smooth sub-pixel resampling during a composition scale animation).
+    /// </summary>
+    public bool SnapTranslation = true;
+
     public void UpdateTransform()
     {
         Mat = Matrix3x2.Identity;
 
-        // Round the first translation to nearest integer to avoid subpixel rendering
-        float translateX1 = MathF.Round((float)(-ImageRect.Width * 0.5f));
-        float translateY1 = MathF.Round((float)(-ImageRect.Height * 0.5f));
+        // Centering translation. Round to whole pixels when snapping (at rest) to avoid subpixel rendering.
+        // This term is constant for a given image, so it never contributes to settle-shiver; gating it keeps
+        // the matrix fully unsnapped during animation for consistency.
+        float translateX1 = SnapTranslation ? MathF.Round((float)(-ImageRect.Width * 0.5f)) : (float)(-ImageRect.Width * 0.5f);
+        float translateY1 = SnapTranslation ? MathF.Round((float)(-ImageRect.Height * 0.5f)) : (float)(-ImageRect.Height * 0.5f);
         Mat *= Matrix3x2.CreateTranslation(translateX1, translateY1);
 
         // Scale operation remains unchanged
@@ -31,9 +45,10 @@ public void UpdateTransform()
         // Rotation remains unchanged
         Mat *= Matrix3x2.CreateRotation((float)(Math.PI * Rotation / 180f));
 
-        // Round the second translation to nearest integer to avoid subpixel rendering
-        float translateX2 = MathF.Round((float)ImagePos.X);
-        float translateY2 = MathF.Round((float)ImagePos.Y);
+        // Pan translation. Per-frame rounding of this term during an animation is what causes the
+        // settle-shiver, so round only when settled (SnapTranslation == true); see SnapTranslation.
+        float translateX2 = SnapTranslation ? MathF.Round((float)ImagePos.X) : (float)ImagePos.X;
+        float translateY2 = SnapTranslation ? MathF.Round((float)ImagePos.Y) : (float)ImagePos.Y;
         Mat *= Matrix3x2.CreateTranslation(translateX2, translateY2);
 
         // Calculate inverse transform