fix(renderer): correctly center rotated sprites, align collision check

Two fixes for rotated text rendering:

1. Overlay centering: revert pre-compensation in centred_sprite_transform
   and instead compute the overlay origin in overlay_sprite_with_rotation
   so the rotated output image's center lands where the unrotated
   sprite's center would be. Formula:
     origin = (x + w/2 - dst_w/2, y + h/2 - dst_h/2)

2. Collision check: rotate the sprite via rotate_sprite_expand_top_left
   before checking against the bubble mask, matching the bilinear-
   resampled pixels used by the actual render overlay path. Previously
   rotated source pixels directly, which could miss edge pixels
   introduced by bilinear interpolation.

Co-authored-by: DeepSeek V4 <deepseek@v4.ai>

Author: zachelnet

crates/koharu-app/src/renderer.rs

@@ -707,23 +707,26 @@ fn sprite_collides_with_bubble_mask(
     mask: &GrayImage,
     bubble_id: u8,
 ) -> bool {
-    let origin_x = transform.x.round() as i32;
-    let origin_y = transform.y.round() as i32;
     let mask_w = mask.width() as i32;
     let mask_h = mask.height() as i32;
 
+    // Rotate the sprite first so the collision check uses the same
+    // bilinear-resampled pixels as the actual render overlay path.
     let rotation_rad = transform.rotation_deg.to_radians();
-    let cos = rotation_rad.cos();
-    let sin = rotation_rad.sin();
+    let (rotated, _, _) = rotate_sprite_expand_top_left(sprite, rotation_rad);
 
-    for (x, y, pixel) in sprite.enumerate_pixels() {
+    // Match the overlay origin computed by overlay_sprite_with_rotation.
+    let origin_x =
+        (transform.x + transform.width * 0.5 - rotated.width() as f32 * 0.5).round() as i32;
+    let origin_y =
+        (transform.y + transform.height * 0.5 - rotated.height() as f32 * 0.5).round() as i32;
+
+    for (x, y, pixel) in rotated.enumerate_pixels() {
         if pixel.0[3] <= MASK_COLLISION_ALPHA_THRESHOLD {
             continue;
         }
-        let fx = x as f32;
-        let fy = y as f32;
-        let mask_x = origin_x + (cos * fx - sin * fy).round() as i32;
-        let mask_y = origin_y + (sin * fx + cos * fy).round() as i32;
+        let mask_x = origin_x + x as i32;
+        let mask_y = origin_y + y as i32;
         if mask_x < 0 || mask_y < 0 || mask_x >= mask_w || mask_y >= mask_h {
             return true;
         }
@@ -999,19 +1002,9 @@ fn centred_sprite_transform(
     let sprite_h = sprite_height as f32;
     let cx = anchor_box.x + anchor_box.width * 0.5;
     let cy = anchor_box.y + anchor_box.height * 0.5;
-
-    // The sprite is rotated around its top-left corner (CSS transform-origin model).
-    // Compute the top-left such that the sprite's visual center lands at (cx, cy).
-    let hw = sprite_w * 0.5;
-    let hh = sprite_h * 0.5;
-    let cos = rotation_deg.to_radians().cos();
-    let sin = rotation_deg.to_radians().sin();
-    let rotated_center_x = cos * hw - sin * hh;
-    let rotated_center_y = sin * hw + cos * hh;
-
     Transform {
-        x: (cx - rotated_center_x).round(),
-        y: (cy - rotated_center_y).round(),
+        x: (cx - sprite_w * 0.5).round(),
+        y: (cy - sprite_h * 0.5).round(),
         width: sprite_w,
         height: sprite_h,
         rotation_deg,
@@ -1048,9 +1041,14 @@ fn overlay_sprite_with_rotation(
         return;
     }
 
-    let (rotated, min_x, min_y) = rotate_sprite_expand_top_left(sprite, rotation_deg.to_radians());
-    let origin_x = (transform.x + min_x).round() as i64;
-    let origin_y = (transform.y + min_y).round() as i64;
+    let (rotated, _, _) = rotate_sprite_expand_top_left(sprite, rotation_deg.to_radians());
+    // The unrotated sprite is centered at (transform.x + w/2, transform.y + h/2).
+    // Align the rotated sprite's center to the same point so rotated text
+    // stays visually centered within its layout box.
+    let origin_x =
+        (transform.x + transform.width * 0.5 - rotated.width() as f32 * 0.5).round() as i64;
+    let origin_y =
+        (transform.y + transform.height * 0.5 - rotated.height() as f32 * 0.5).round() as i64;
     imageops::overlay(canvas, &rotated, origin_x, origin_y);
 }