Make barycentric coordinate computation opt-in via CollisionResults flag

Agent-Logs-Url: https://github.com/jMonkeyEngine/jmonkeyengine/sessions/86d05467-fc58-41ed-a878-1c31d48e6575

Co-authored-by: riccardobl <4943530+riccardobl@users.noreply.github.com>

Author: Copilot

jme3-core/src/main/java/com/jme3/collision/CollisionResults.java

@@ -46,6 +46,38 @@ public class CollisionResults implements Iterable<CollisionResult> {
 
     private ArrayList<CollisionResult> results = null;
     private boolean sorted = true;
+    private boolean requiresBaryCoords = false;
+
+    /**
+     * Returns whether collision queries against this instance will compute and
+     * store barycentric coordinates in each {@link CollisionResult}.
+     *
+     * <p>Barycentric coordinate computation is disabled by default.
+     * Enable it when you need the (u, v) weights for texture-coordinate
+     * interpolation or other per-hit surface lookups.
+     *
+     * @return true if barycentric coordinates will be computed
+     * @see #setRequiresBaryCoords(boolean)
+     */
+    public boolean isRequiresBaryCoords() {
+        return requiresBaryCoords;
+    }
+
+    /**
+     * Controls whether collision queries against this instance should compute
+     * and store barycentric coordinates in each {@link CollisionResult}.
+     *
+     * <p>Barycentric coordinate computation is disabled by default.
+     * Enable it when you need the (u, v) weights for texture-coordinate
+     * interpolation or other per-hit surface lookups.
+     *
+     * @param requiresBaryCoords true to enable barycentric coordinate
+     *     computation, false (the default) to skip it
+     * @see #isRequiresBaryCoords()
+     */
+    public void setRequiresBaryCoords(boolean requiresBaryCoords) {
+        this.requiresBaryCoords = requiresBaryCoords;
+    }
 
     /**
      * Clears all collision results added to this list

jme3-core/src/main/java/com/jme3/collision/bih/BIHNode.java

@@ -402,7 +402,7 @@ public final int intersectWhere(Ray r,
             for (int i = node.leftIndex; i <= node.rightIndex; i++) {
                 tree.getTriangle(i, v1, v2, v3);
 
-                Vector2f baryCoords = new Vector2f();
+                Vector2f baryCoords = results.isRequiresBaryCoords() ? new Vector2f() : null;
                 float t = r.intersects(v1, v2, v3, baryCoords);
                 if (!Float.isInfinite(t)) {
                     if (worldMatrix != null) {
@@ -424,7 +424,9 @@ public final int intersectWhere(Ray r,
                         CollisionResult cr = new CollisionResult(contactPoint, worldSpaceDist);
                         cr.setContactNormal(contactNormal);
                         cr.setTriangleIndex(tree.getTriangleIndex(i));
-                        cr.setContactBaryCoords(baryCoords);
+                        if (baryCoords != null) {
+                            cr.setContactBaryCoords(baryCoords);
+                        }
                         results.addCollision(cr);
                         cols++;
                     }

jme3-core/src/main/java/com/jme3/math/Ray.java

@@ -477,15 +477,17 @@ public int collideWith(Collidable other, CollisionResults results) {
             return bv.collideWith(this, results);
         } else if (other instanceof AbstractTriangle) {
             AbstractTriangle tri = (AbstractTriangle) other;
-            Vector2f baryCoords = new Vector2f();
+            Vector2f baryCoords = results.isRequiresBaryCoords() ? new Vector2f() : null;
             float d = intersects(tri.get1(), tri.get2(), tri.get3(), baryCoords);
             if (Float.isInfinite(d) || Float.isNaN(d)) {
                 return 0;
             }
 
             Vector3f point = new Vector3f(direction).multLocal(d).addLocal(origin);
             CollisionResult cr = new CollisionResult(point, d);
-            cr.setContactBaryCoords(baryCoords);
+            if (baryCoords != null) {
+                cr.setContactBaryCoords(baryCoords);
+            }
             results.addCollision(cr);
             return 1;
         } else {

jme3-core/src/test/java/com/jme3/collision/RayCollisionTest.java

@@ -166,7 +166,7 @@ public void testBarycentricReconstructsContactPoint() {
 
     /**
      * Verifies that CollisionResult contains barycentric coords when a ray
-     * collides with an AbstractTriangle.
+     * collides with an AbstractTriangle and the flag is enabled.
      */
     @Test
     public void testCollisionResultContainsBaryCoords() {
@@ -181,6 +181,7 @@ public void testCollisionResultContainsBaryCoords() {
 
         Triangle tri = new Triangle(v0, v1, v2);
         CollisionResults results = new CollisionResults();
+        results.setRequiresBaryCoords(true);
         int count = ray.collideWith(tri, results);
 
         Assert.assertEquals("Expected exactly 1 collision", 1, count);
@@ -189,11 +190,37 @@ public void testCollisionResultContainsBaryCoords() {
         Assert.assertNotNull("CollisionResult should not be null", cr);
 
         Vector2f bary = cr.getContactBaryCoords();
-        Assert.assertNotNull("Barycentric coords should be set", bary);
+        Assert.assertNotNull("Barycentric coords should be set when flag is enabled", bary);
         Assert.assertEquals("u should be 1/3", 1f / 3f, bary.x, DELTA);
         Assert.assertEquals("v should be 1/3", 1f / 3f, bary.y, DELTA);
     }
 
+    /**
+     * Verifies that barycentric coords are NOT computed when the flag is
+     * disabled (the default).
+     */
+    @Test
+    public void testCollisionResultNoBaryCoordsByDefault() {
+        Vector3f v0 = new Vector3f(0f, 0f, 0f);
+        Vector3f v1 = new Vector3f(1f, 0f, 0f);
+        Vector3f v2 = new Vector3f(0f, 1f, 0f);
+
+        float cx = (v0.x + v1.x + v2.x) / 3f;
+        float cy = (v0.y + v1.y + v2.y) / 3f;
+        Ray ray = new Ray(new Vector3f(cx, cy, 5f), new Vector3f(0f, 0f, -1f));
+
+        Triangle tri = new Triangle(v0, v1, v2);
+        CollisionResults results = new CollisionResults(); // flag defaults to false
+        int count = ray.collideWith(tri, results);
+
+        Assert.assertEquals("Expected exactly 1 collision", 1, count);
+
+        CollisionResult cr = results.getClosestCollision();
+        Assert.assertNotNull("CollisionResult should not be null", cr);
+        Assert.assertNull("Barycentric coords should be null when flag is disabled",
+                cr.getContactBaryCoords());
+    }
+
     /**
      * Verifies that no intersection returns POSITIVE_INFINITY and bary is not
      * modified.