perf(render): avoid geometry allocations on proxy reuse (#80)

Compare cached ray-proxy geometry directly and allocate a snapshot only when client proxies need rebuilding.

Validated twice by the protected performance-ray-proxy A/B gate, including against the post-#79 dev baseline: PASS_OPTIMIZED.

Author: TypeThe0ry

src/main/java/top/ellan/mahjong/table/render/SparrowRayInteractionProxyCoordinator.java

@@ -4,6 +4,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -75,12 +76,12 @@ synchronized void replace(
                 if (viewer == null || !viewer.isOnline()) {
                     continue;
                 }
-                List<InteractionGeometry> geometry = interactionGeometry(interactions);
                 ActiveProxies current = previous.get(viewerId);
-                if (this.canReuse(viewerId, viewer, current, geometry)) {
+                if (this.canReuse(viewerId, viewer, current, interactions)) {
                     next.put(viewerId, current);
                     continue;
                 }
+                List<InteractionGeometry> geometry = interactionGeometry(interactions);
                 List<ClientProxy> proxies = this.backend.create(viewer, interactions);
                 if (!proxies.isEmpty()) {
                     ActiveProxies created = new ActiveProxies(
@@ -135,11 +136,11 @@ private boolean canReuse(
         UUID viewerId,
         Player viewer,
         ActiveProxies active,
-        List<InteractionGeometry> geometry
+        List<DisplayInteractionRayRegistry.RayInteraction> interactions
     ) {
         if (active == null
             || active.viewer() != viewer
-            || !active.geometry().equals(geometry)
+            || !sameGeometry(active.geometry(), interactions)
             || active.proxies().isEmpty()) {
             return false;
         }
@@ -153,6 +154,21 @@ private boolean canReuse(
         return true;
     }
 
+    private static boolean sameGeometry(
+        List<InteractionGeometry> geometry,
+        List<DisplayInteractionRayRegistry.RayInteraction> interactions
+    ) {
+        if (geometry.size() != interactions.size()) {
+            return false;
+        }
+        for (int index = 0; index < geometry.size(); index++) {
+            if (!geometry.get(index).matches(interactions.get(index))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     private static List<InteractionGeometry> interactionGeometry(
         List<DisplayInteractionRayRegistry.RayInteraction> interactions
     ) {
@@ -355,6 +371,17 @@ private record InteractionGeometry(
         float height,
         float depth
     ) {
+        private boolean matches(DisplayInteractionRayRegistry.RayInteraction interaction) {
+            return Objects.equals(this.worldId, interaction.worldId())
+                && Double.compare(this.centerX, interaction.centerX()) == 0
+                && Double.compare(this.centerY, interaction.centerY()) == 0
+                && Double.compare(this.centerZ, interaction.centerZ()) == 0
+                && Double.compare(this.acrossX, interaction.acrossX()) == 0
+                && Double.compare(this.acrossZ, interaction.acrossZ()) == 0
+                && Float.compare(this.width, interaction.width()) == 0
+                && Float.compare(this.height, interaction.height()) == 0
+                && Float.compare(this.depth, interaction.depth()) == 0;
+        }
     }
 
     private static final class SparrowBackend implements Backend {