2.14.0 - major memory leak patches.

Author: Waterpicker

build.gradle.kts

@@ -11,7 +11,7 @@ plugins {
 }
 
 group = "gg.generations"
-version = "2.13.2"
+version = "2.14.0"
 
 java.toolchain.languageVersion.set(JavaLanguageVersion.of(21))
 

src/library/java/gg/generations/rarecandy/pokeutils/Pair.java

@@ -27,6 +27,12 @@ public void b(B b) {
         this.b = b;
     }
 
+    public Pair<A, B> set(A a, B b) {
+        a(a);
+        b(b);
+        return this;
+    }
+
     @Override
     public int hashCode() {
         return Objects.hash(a, b);

src/library/java/gg/generations/rarecandy/renderer/animation/Animation.java

@@ -3,6 +3,7 @@
 import gg.generations.rarecandy.pokeutils.ModelNode;
 import gg.generations.rarecandy.pokeutils.SkeletalTransform;
 import org.joml.Matrix4f;
+import org.joml.Matrix4fStack;
 import org.joml.Quaternionf;
 import org.joml.Vector3f;
 
@@ -11,7 +12,6 @@
 import java.util.function.BiConsumer;
 
 public class Animation {
-    private final static Matrix4f IDENTITY = new Matrix4f();
 
     public static final int FPS_60 = 1000;
     public static final int FPS_24 = 400;
@@ -21,6 +21,20 @@ public class Animation {
     public static Vector3f TRANSLATE = new Vector3f();
     protected static Vector3f SCALE = new Vector3f(1, 1, 1);
     protected static Vector3f TRANSLATION = new Vector3f();
+
+    private static final Matrix4f[] MATRIX = new Matrix4f[220];
+    private static final Matrix4fStack GLOBAL = new Matrix4fStack(220);
+    private final static Matrix4f IDENTITY = new Matrix4f();
+    private static final Matrix4f TEMP_GLOBAL_TRANSFORM = new Matrix4f();
+    private static final Matrix4f TEMP_BONE_RESULT = new Matrix4f();
+    private static final Vector3f TEMP_ORIGIN_VECTOR = new Vector3f();
+
+    static {
+        for (int i = 0; i < MATRIX.length; i++) {
+            MATRIX[i] = new Matrix4f();
+        }
+    }
+
     public final String name;
     public final double animationDuration;
     protected final Skeleton skeleton;
@@ -29,6 +43,9 @@ public class Animation {
     private final AnimationNode[] animationNodes;
     public Map<String, Offset> offsets;
 
+    private Matrix4f[] cachedBoneTransforms;
+    private final Matrix4f cachedIdentity = new Matrix4f().identity();
+
     public float ticksPerSecond;
     public boolean loops;
     public boolean ignoreInstancedTime = false;
@@ -96,41 +113,111 @@ public float getAnimationTime(double secondsPassed) {
     }
 
     public Matrix4f[] getFrameTransform(AnimationInstance instance) {
-        var boneTransforms = new Matrix4f[this.skeleton.jointMap.size()];
-        readNodeHierarchy(instance.getCurrentTime(), skeleton.rootNode, new Matrix4f().identity(), boneTransforms, false);
-        for (int i = 0; i < boneTransforms.length; i++) {
-            if(boneTransforms[i] == null) boneTransforms[i] = new Matrix4f();
+
+        if (cachedBoneTransforms == null || cachedBoneTransforms.length != skeleton.jointMap.size()) {
+            cachedBoneTransforms = new Matrix4f[skeleton.jointMap.size()];
+            for (int i = 0; i < cachedBoneTransforms.length; i++) {
+                cachedBoneTransforms[i] = new Matrix4f();
+            }
         }
 
-        return boneTransforms;
+        // Reset all transforms to identity before populating
+        for (Matrix4f mat : cachedBoneTransforms) {
+            mat.identity();
+        }
+
+        GLOBAL.identity();
+
+        readNodeHierarchyPooled(instance.getCurrentTime(), skeleton.rootNode, cachedBoneTransforms, false, 0);
+        return cachedBoneTransforms;
     }
 
     public void getFrameOffset(AnimationInstance instance) {
-        this.offsets.forEach((k, v) -> {
+        for (Map.Entry<String, Offset> entry : this.offsets.entrySet()) {
+            String k = entry.getKey();
+            Offset v = entry.getValue();
             var offsetInstance = instance.offsets.computeIfAbsent(k, a -> new Transform());
             offsetInstance.offset().zero();
             offsetInstance.scale().set(1, 1);
 
             offsets.get(k).calcOffset(instance.getCurrentTime(), offsetInstance);
-        });
+        }
     }
 
     public Matrix4f[] getFrameTransform(double secondsPassed) {
-        var boneTransforms = new Matrix4f[this.skeleton.jointMap.size()];
-        readNodeHierarchy(getAnimationTime(secondsPassed), skeleton.rootNode, new Matrix4f().identity(), boneTransforms, false);
+        if (cachedBoneTransforms == null || cachedBoneTransforms.length != skeleton.jointMap.size()) {
+            cachedBoneTransforms = new Matrix4f[skeleton.jointMap.size()];
+            for (int i = 0; i < cachedBoneTransforms.length; i++) {
+                cachedBoneTransforms[i] = new Matrix4f();
+            }
+        }
 
-        for (int i = 0; i < boneTransforms.length; i++) {
-            if(boneTransforms[i] == null) boneTransforms[i] = new Matrix4f();
+        for (Matrix4f mat : cachedBoneTransforms) {
+            mat.identity();
         }
 
-        return boneTransforms;
+        readNodeHierarchyPooled(getAnimationTime(secondsPassed), skeleton.rootNode, cachedBoneTransforms, false, 0);
+        return cachedBoneTransforms;
     }
 
-    private static final Matrix4f matrix = new Matrix4f();
+    public void readNodeHierarchyPooled(float animTime, ModelNode node, Matrix4f[] boneTransforms, boolean offsetUsed, int depth) {
+
+
+        var name = node.name;
+        var nodeTransform = MATRIX[depth].set(node.transform);  // Reuses existing static 'matrix' field
+
+        var animationNodeId = skeleton.boneIdMap.getOrDefault(name, -1);
+        var bone = skeleton.get(name);
+
+        if (animationNodeId != -1) {
+            var animNode = animationNodes[animationNodeId];
+
+            if (animNode != null) {
+                var scale = ignoreScaling ? SCALE : AnimationMath.calcInterpolatedScaling(animTime, animNode);
+                var rotation = AnimationMath.calcInterpolatedRotation(animTime, animNode);
+
+                // Reuse pooled Vector3f for "origin" case
+                Vector3f translation;
+                if (name.equalsIgnoreCase("origin")) {
+                    translation = TEMP_ORIGIN_VECTOR;
+                } else {
+                    translation = AnimationMath.calcInterpolatedPosition(animTime, animNode);
+                }
+
+                if (!offsetUsed) {
+                    offsetUsed = true;
+                    translation.add(rootOffset.position());
+                    rotation.mul(rootOffset.rotation());
+                }
+
+                if(!isIdentityTransform(translation, scale, rotation, 1e-5f)) nodeTransform.identity().translationRotateScale(translation, rotation, scale);
+            }
+        }
+
+
+
+        // Reuse pooled Matrix4f for globalTransform
+        TEMP_GLOBAL_TRANSFORM.set(GLOBAL).mul(nodeTransform);
+
+        if (bone != null && animationNodeId >= 0 && animationNodeId < boneTransforms.length) {
+            // Write directly into pre-allocated array slot
+            TEMP_GLOBAL_TRANSFORM.mul(bone.inverseBindMatrix, boneTransforms[animationNodeId]);
+        }
+
+        var nextDepth = depth + 1;
+
+        GLOBAL.pushMatrix();
+        GLOBAL.set(TEMP_GLOBAL_TRANSFORM);
+
+        for (var child : node.children) {
+            readNodeHierarchyPooled(animTime, child, boneTransforms, offsetUsed, nextDepth);
+        }
+        GLOBAL.popMatrix();
+    }
 
     public void readNodeHierarchy(float animTime, ModelNode node, Matrix4f parentTransform, Matrix4f[] boneTransforms, boolean offsetUsed) {
         var name = node.name;
-        var nodeTransform = matrix.set(node.transform);
+        var nodeTransform = MATRIX[0].set(node.transform);
 
         var animationNodeId = skeleton.boneIdMap.getOrDefault(name, -1);
         var bone = skeleton.get(name);
@@ -245,6 +332,30 @@ public void calcOffset(float animTime, Transform instance) {
             instance.scale().set(uScale, vScale);
         }
     }
+
+    public static boolean isIdentityTransform(
+            Vector3f translation,
+            Vector3f scale,
+            Quaternionf rotation,
+            float eps
+    ) {
+        boolean tX = translation.x == 0.0f;
+        boolean tY = translation.y == 0.0f;
+        boolean tZ = translation.z == 0.0f;
+
+        boolean sX = scale.x == 0.0f;
+        boolean sY = scale.y == 0.0f;
+        boolean sZ = scale.z == 0.0f;
+
+        boolean rX = rotation.x == 0.0f;
+        boolean rY = rotation.y == 0.0f;
+        boolean rZ = rotation.z == 0.0f;
+        boolean rW = rotation.w == 1.0f;
+
+        return tX && tY && tZ
+                && sX && sY && sZ
+                && rX && rY && rZ && rW;
+    }
 }
 
 

src/library/java/gg/generations/rarecandy/renderer/animation/AnimationController.java

@@ -16,7 +16,7 @@ public class AnimationController {
         Arrays.fill(NO_ANIMATION, identity);
     }
 
-    public final List<AnimationInstance> playingInstances = new ArrayList<>();
+    public final Set<AnimationInstance> playingInstances = new LinkedHashSet<>();
     public final Map<Animation, Matrix4f[]> instanceIgnoringAnimTransforms = new HashMap<>();
 
     public void render(double globalSecondsPassed) {
@@ -44,6 +44,8 @@ public void render(double globalSecondsPassed) {
             playingInstance.animation.getFrameOffset(playingInstance);
         }
 
-        playingInstances.removeAll(instancesToRemove);
+        for (AnimationInstance animationInstance : instancesToRemove) {
+            playingInstances.remove(animationInstance);
+        }
     }
 }

src/library/java/gg/generations/rarecandy/renderer/animation/AnimationInstance.java

@@ -13,7 +13,7 @@ public class AnimationInstance {
     public double startTime = -1;
     public Matrix4f[] matrixTransforms;
     public final Map<String, Transform> offsets = new HashMap<>();
-
+    private boolean registered = false;
 
     protected Animation animation;
     protected float currentTime;
@@ -67,6 +67,7 @@ public boolean isPaused() {
 
     public void destroy() {
         this.unused = true;
+        this.registered = false;
     }
 
     public boolean shouldDestroy() {
@@ -82,4 +83,15 @@ public Transform getOffset(String name) {
 
         return offset;
     }
+
+    /**
+     * Ensures this instance is registered with the controller exactly once.
+     * O(1) check instead of O(n) contains().
+     */
+    public void ensureRegistered(AnimationController controller) {
+        if (!registered && !unused) {
+            controller.playingInstances.add(this);
+            registered = true;
+        }
+    }
 }

src/library/java/gg/generations/rarecandy/renderer/animation/AnimationMath.java

@@ -5,17 +5,22 @@
 import org.joml.Vector3f;
 
 public class AnimationMath {
+    private static final Pair<TransformStorage.TimeKey<Quaternionf>, TransformStorage.TimeKey<Quaternionf>> QUATERIONF_KEYPAIR = new Pair<>(null, null);
+    private static final Pair<TransformStorage.TimeKey<Vector3f>, TransformStorage.TimeKey<Vector3f>> VECTOR3F_KEYPAIR = new Pair<>(null, null);
+
+    private static final Vector3f DEST_SCALE = new Vector3f();
+    private static final Vector3f DEST_TRANSLATION = new Vector3f();
+    private static final Quaternionf DEST_ROTATION = new Quaternionf();
 
     public static Vector3f calcInterpolatedPosition(float animTime, Animation.AnimationNode node) {
         if (node.positionKeys.size() == 1) return node.getDefaultPosition().value();
 
         var positions = findPositions(animTime, node);
         float factor = (float) ((animTime - (float) positions.a().time()) / (positions.b().time() - positions.a().time()));
 
-        var start = new Vector3f(positions.a().value());
-        var end = new Vector3f(positions.b().value());
-        var delta = new Vector3f(end.sub(start));
-        return new Vector3f(start.add(delta.mul(factor)));
+        var start = positions.a().value();
+        var end = positions.b().value();
+        return DEST_TRANSLATION.set(end).sub(start).mul(factor).add(start);
     }
 
     public static Quaternionf calcInterpolatedRotation(float animTime, Animation.AnimationNode node) {
@@ -24,48 +29,46 @@ public static Quaternionf calcInterpolatedRotation(float animTime, Animation.Ani
         var rotations = findRotations(animTime, node);
         var deltaTime = (float) (rotations.b().time() - rotations.a().time());
         var factor = (animTime - (float) rotations.a().time()) / deltaTime;
-        var start = new Quaternionf(rotations.a().value());
-        var end = new Quaternionf(rotations.b().value());
-        return new Quaternionf(start.slerp(end, factor));
+        var start = rotations.a().value();
+        var end = rotations.b().value();
+        return DEST_ROTATION.set(start).slerp(end, factor);
     }
 
     public static Vector3f calcInterpolatedScaling(float animTime, Animation.AnimationNode node) {
         if (node.scaleKeys.size() == 1) return node.getDefaultScale().value();
 
-        var out = new Vector3f();
         var scalings = findScalings(animTime, node);
         var deltaTime = (float) (scalings.b().time() - scalings.a().time());
         var factor = (animTime - (float) scalings.a().time()) / deltaTime;
-        var start = new Vector3f(scalings.a().value());
-        var end = new Vector3f(scalings.b().value());
-        var delta = new Vector3f(end.sub(start));
-        return out.add(start.add(delta.mul(factor)));
+        var start = scalings.a().value();
+        var end = scalings.b().value();
+        return DEST_SCALE.set(end).sub(start).mul(factor).add(start);
     }
 
     public static Pair<TransformStorage.TimeKey<Vector3f>, TransformStorage.TimeKey<Vector3f>> findPositions(float animTime, Animation.AnimationNode node) {
         for (var key : node.positionKeys) {
             if (animTime < key.time())
-                return new Pair<>(node.positionKeys.getBefore(key), key);
+                return VECTOR3F_KEYPAIR.set(node.positionKeys.getBefore(key), key);
         }
 
-        return new Pair<>(node.positionKeys.get(0), node.positionKeys.get(1));
+        return VECTOR3F_KEYPAIR.set(node.positionKeys.get(0), node.positionKeys.get(1));
     }
 
     public static Pair<TransformStorage.TimeKey<Quaternionf>, TransformStorage.TimeKey<Quaternionf>> findRotations(float animTime, Animation.AnimationNode node) {
         for (var key : node.rotationKeys) {
             if (animTime < key.time())
-                return new Pair<>(node.rotationKeys.getBefore(key), key);
+                return QUATERIONF_KEYPAIR.set(node.rotationKeys.getBefore(key), key);
         }
 
-        return new Pair<>(node.rotationKeys.get(0), node.rotationKeys.get(1));
+        return QUATERIONF_KEYPAIR.set(node.rotationKeys.get(0), node.rotationKeys.get(1));
     }
 
     public static Pair<TransformStorage.TimeKey<Vector3f>, TransformStorage.TimeKey<Vector3f>> findScalings(float animTime, Animation.AnimationNode node) {
         for (var key : node.scaleKeys) {
             if (animTime < key.time())
-                return new Pair<>(node.scaleKeys.getBefore(key), key);
+                return VECTOR3F_KEYPAIR.set(node.scaleKeys.getBefore(key), key);
         }
 
-        return new Pair<>(node.scaleKeys.get(0), node.scaleKeys.get(1));
+        return VECTOR3F_KEYPAIR.set(node.scaleKeys.get(0), node.scaleKeys.get(1));
     }
 }

src/library/java/gg/generations/rarecandy/renderer/pipeline/Pipeline.java

@@ -31,22 +31,26 @@ public void unbind(Material material) {
     }
 
     public void updateOtherUniforms(ObjectInstance instance, RenderObject renderObject) {
+        var context = UniformUploadContext.INSTANCE.with(renderObject, instance);
+
         for (var name : uniforms.keySet()) {
             var uniform = uniforms.get(name);
             if (!uniformSuppliers.containsKey(name))
                 RareCandy.fatal("No handler for uniform with name \"" + name + "\"");
             if (uniform.type != GL20C.GL_SAMPLER_2D)
-                uniformSuppliers.get(name).accept(new UniformUploadContext(renderObject, instance, uniform));
+                uniformSuppliers.get(name).accept(context.with(uniform));
         }
     }
 
     public void updateTexUniforms(ObjectInstance instance, RenderObject renderObject) {
+        var context = UniformUploadContext.INSTANCE.with(renderObject, instance);
+
         for (var name : uniforms.keySet()) {
             var uniform = uniforms.get(name);
             if (!uniformSuppliers.containsKey(name))
                 RareCandy.fatal("No handler for uniform with name \"" + name + "\"");
             if (uniform.type == GL20C.GL_SAMPLER_2D)
-                uniformSuppliers.get(name).accept(new UniformUploadContext(renderObject, instance, uniform));
+                uniformSuppliers.get(name).accept(UniformUploadContext.INSTANCE.with(uniform));
         }
     }