Changes before error encountered

Agent-Logs-Url: https://github.com/jMonkeyEngine/jmonkeyengine/sessions/0b0ee217-37c6-4d49-9616-3c58c9350a06

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

Author: Copilot

jme3-core/src/main/java/com/jme3/anim/SkinningControl.java

@@ -60,6 +60,8 @@
 import java.io.IOException;
 import java.nio.Buffer;
 import java.nio.FloatBuffer;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -140,6 +142,22 @@ public class SkinningControl extends AbstractControl implements JmeCloneable {
      */
     private boolean updateBounds = false;
 
+    /**
+     * Maximum number of vertices processed per frame when updating bounding
+     * volumes during hardware skinning. Processing is spread across multiple
+     * frames (the cursor resumes where it left off), keeping each frame's cost
+     * bounded. {@link Integer#MAX_VALUE} (the default) means all vertices are
+     * processed in one frame, matching the old behaviour.
+     */
+    private int boundingUpdateBudget = Integer.MAX_VALUE;
+
+    /**
+     * Per-geometry state for incremental bounding-volume updates. Only used
+     * when {@link #boundingUpdateBudget} is smaller than the vertex count of
+     * the mesh, allowing the work to be spread over several frames.
+     */
+    private transient Map<Geometry, BoundsUpdateState> boundsUpdateStates = new HashMap<>();
+
     private MatParamOverride numberOfJointsParam = new MatParamOverride(VarType.Int, "NumberOfBones", null);
     private MatParamOverride jointMatricesParam = new MatParamOverride(VarType.Matrix4Array, "BoneMatrices", null);
 
@@ -281,6 +299,43 @@ public boolean isUpdateBounds() {
         return updateBounds;
     }
 
+    /**
+     * Sets the maximum number of vertices considered per frame when updating
+     * bounding volumes during hardware skinning. Use this to distribute the
+     * CPU cost of the bounds update across several frames instead of paying the
+     * full price in a single frame.
+     *
+     * <p>The update cursor advances by at most {@code budget} vertices each
+     * frame and resumes where it left off the next frame. When a full pass over
+     * all vertices is complete, the geometry's model bound is refreshed with
+     * the newly computed values. In the meantime, the geometry keeps the bound
+     * from the previous completed pass.
+     *
+     * <p>A value of {@link Integer#MAX_VALUE} (the default) processes all
+     * vertices in one frame, matching the original behaviour. Values &le; 0
+     * are treated as {@link Integer#MAX_VALUE}.
+     *
+     * @param budget max vertices per frame (any positive integer; values
+     *               &le; 0 are normalized to {@link Integer#MAX_VALUE})
+     * @see #getBoundingUpdateBudget()
+     * @see #setUpdateBounds(boolean)
+     */
+    public void setBoundingUpdateBudget(int budget) {
+        this.boundingUpdateBudget = (budget <= 0) ? Integer.MAX_VALUE : budget;
+        boundsUpdateStates.clear();
+    }
+
+    /**
+     * Returns the maximum number of vertices processed per frame when updating
+     * bounding volumes during hardware skinning.
+     *
+     * @return the bounding-update vertex budget
+     * @see #setBoundingUpdateBudget(int)
+     */
+    public int getBoundingUpdateBudget() {
+        return boundingUpdateBudget;
+    }
+
     /**
      * Recursively finds and adds animated geometries to the targets list.
      *
@@ -803,17 +858,23 @@ private void applySkinningTangents(Mesh mesh, Matrix4f[] offsetMatrices, VertexB
     }
 
     /**
-     * Computes the bounding volume of an animated mesh from the bind pose
-     * positions and the current skinning matrices, then sets it on the geometry.
-     * This is used during hardware skinning to keep culling correct, since the
-     * GPU-transformed vertex positions are not reflected in the CPU-side vertex
-     * buffer.
+     * Computes (or incrementally advances) the bounding volume of an animated
+     * mesh from the bind-pose positions and the current skinning matrices, then
+     * sets it on the geometry once a full pass is complete.
+     *
+     * <p>When {@link #boundingUpdateBudget} is smaller than the vertex count,
+     * at most {@code boundingUpdateBudget} vertices are processed each call.
+     * The per-geometry {@link BoundsUpdateState} records the cursor and the
+     * in-progress min/max so subsequent calls resume from where they left off.
+     * The geometry's bound is only updated after all vertices have been visited
+     * in a single pass; in the meantime it keeps the bound from the last
+     * completed pass.
      *
      * @param geometry       the geometry whose bound needs to be updated
      * @param mesh           the animated mesh
      * @param offsetMatrices the bone offset matrices for this frame
      */
-    private static void updateSkinnedMeshBound(Geometry geometry, Mesh mesh,
+    private void updateSkinnedMeshBound(Geometry geometry, Mesh mesh,
             Matrix4f[] offsetMatrices) {
         VertexBuffer bindPosVB = mesh.getBuffer(Type.BindPosePosition);
         if (bindPosVB == null) {
@@ -831,27 +892,56 @@ private static void updateSkinnedMeshBound(Geometry geometry, Mesh mesh,
         int fourMinusMaxWeights = 4 - maxWeightsPerVert;
 
         FloatBuffer bindPos = (FloatBuffer) bindPosVB.getData();
-        bindPos.rewind();
         IndexBuffer boneIndex = IndexBuffer.wrapIndexBuffer(boneIndexVB.getData());
         FloatBuffer boneWeightBuf = (FloatBuffer) boneWeightVB.getData();
-        boneWeightBuf.rewind();
         // Use array() when available (heap buffer), otherwise copy to a local array.
         float[] weights;
         if (boneWeightBuf.hasArray()) {
             weights = boneWeightBuf.array();
         } else {
             weights = new float[boneWeightBuf.limit()];
+            boneWeightBuf.rewind();
             boneWeightBuf.get(weights);
         }
-        int idxWeights = 0;
 
         int numVerts = bindPos.limit() / 3;
-        float minX = Float.POSITIVE_INFINITY, minY = Float.POSITIVE_INFINITY,
-                minZ = Float.POSITIVE_INFINITY;
-        float maxX = Float.NEGATIVE_INFINITY, maxY = Float.NEGATIVE_INFINITY,
-                maxZ = Float.NEGATIVE_INFINITY;
 
-        for (int v = 0; v < numVerts; v++) {
+        // Decide whether we need incremental (multi-frame) processing.
+        boolean incremental = (boundingUpdateBudget < numVerts);
+        BoundsUpdateState state = null;
+        if (incremental) {
+            state = boundsUpdateStates.get(geometry);
+            if (state == null) {
+                state = new BoundsUpdateState();
+                boundsUpdateStates.put(geometry, state);
+            }
+        }
+
+        // Starting vertex and accumulated min/max for this pass.
+        int startVertex;
+        float minX, minY, minZ, maxX, maxY, maxZ;
+        if (state != null && state.nextVertex > 0) {
+            // Resume an in-progress pass.
+            startVertex = state.nextVertex;
+            minX = state.minX; minY = state.minY; minZ = state.minZ;
+            maxX = state.maxX; maxY = state.maxY; maxZ = state.maxZ;
+        } else {
+            // Start a fresh pass.
+            startVertex = 0;
+            minX = Float.POSITIVE_INFINITY; minY = Float.POSITIVE_INFINITY;
+            minZ = Float.POSITIVE_INFINITY;
+            maxX = Float.NEGATIVE_INFINITY; maxY = Float.NEGATIVE_INFINITY;
+            maxZ = Float.NEGATIVE_INFINITY;
+        }
+
+        int budget = incremental ? boundingUpdateBudget : numVerts;
+        int endVertex = Math.min(startVertex + budget, numVerts);
+
+        // Position the bind-pose buffer at the correct vertex.
+        bindPos.position(startVertex * 3);
+        int idxWeights = startVertex * 4;
+
+        for (int v = startVertex; v < endVertex; v++) {
             float vtx = bindPos.get();
             float vty = bindPos.get();
             float vtz = bindPos.get();
@@ -884,6 +974,19 @@ private static void updateSkinnedMeshBound(Geometry geometry, Mesh mesh,
             if (rz > maxZ) maxZ = rz;
         }
 
+        if (endVertex < numVerts) {
+            // Pass not yet complete – save state and wait for the next frame.
+            state.nextVertex = endVertex;
+            state.minX = minX; state.minY = minY; state.minZ = minZ;
+            state.maxX = maxX; state.maxY = maxY; state.maxZ = maxZ;
+            return;
+        }
+
+        // Full pass complete – reset cursor and commit the bounding box.
+        if (state != null) {
+            state.nextVertex = 0;
+        }
+
         // Reuse the existing BoundingBox if possible to avoid allocation.
         BoundingVolume bv = mesh.getBound();
         BoundingBox bbox;
@@ -904,6 +1007,21 @@ private static void updateSkinnedMeshBound(Geometry geometry, Mesh mesh,
         geometry.setModelBound(bbox);
     }
 
+    /**
+     * Holds the incremental bounding-volume update state for a single geometry
+     * when {@link #boundingUpdateBudget} limits processing to fewer than all
+     * vertices per frame.
+     */
+    private static final class BoundsUpdateState {
+        int nextVertex = 0;
+        float minX = Float.POSITIVE_INFINITY;
+        float minY = Float.POSITIVE_INFINITY;
+        float minZ = Float.POSITIVE_INFINITY;
+        float maxX = Float.NEGATIVE_INFINITY;
+        float maxY = Float.NEGATIVE_INFINITY;
+        float maxZ = Float.NEGATIVE_INFINITY;
+    }
+
     /**
      * Serialize this Control to the specified exporter, for example when saving
      * to a J3O file.
@@ -917,6 +1035,7 @@ public void write(JmeExporter ex) throws IOException {
         OutputCapsule oc = ex.getCapsule(this);
         oc.write(armature, "armature", null);
         oc.write(updateBounds, "updateBounds", false);
+        oc.write(boundingUpdateBudget, "boundingUpdateBudget", Integer.MAX_VALUE);
     }
 
     /**
@@ -932,6 +1051,7 @@ public void read(JmeImporter im) throws IOException {
         InputCapsule in = im.getCapsule(this);
         armature = (Armature) in.readSavable("armature", null);
         updateBounds = in.readBoolean("updateBounds", false);
+        boundingUpdateBudget = in.readInt("boundingUpdateBudget", Integer.MAX_VALUE);
 
         for (MatParamOverride mpo : spatial.getLocalMatParamOverrides().getArray()) {
             if (mpo.getName().equals("NumberOfBones") || mpo.getName().equals("BoneMatrices")) {
@@ -949,6 +1069,7 @@ public void read(JmeImporter im) throws IOException {
      */
     private void updateAnimationTargets(Spatial spatial) {
         targets.clear();
+        boundsUpdateStates.clear();
         collectAnimatedGeometries(spatial);
     }