Update To Latest JoltC Commit

Commit 52d8c98df523f449eb3e01b1060a0fde052970d1

Author: Morgoth398

README.md

@@ -4,9 +4,7 @@ This project provides Java Bindings for [JoltPhysics](https://github.com/jrouwe/
 This project is in a usable, working state regarding the features that the C wrapper exposes. When the wrapper exposes new features, I try to update this project as fast as possible.
 
 # Supported Platforms
-Windows and Linux are directly supported. The Linux .so file was built on Linux Mint 22.2.
-
-Nevertheless, you should be able to use these bindings for Mac if you provide your own `.dylib` file and load it.
+Windows, Linux and Mac are directly supported. The native libraries were build by [the workflow the C Wrapper provides](https://github.com/amerkoleci/joltc/blob/main/.github/workflows/build.yml).
 
 # Building The Project
 1. Download [Java 26](https://www.oracle.com/de/java/technologies/downloads/)

src/main/java/generation/JoltGenerator.java

@@ -252,18 +252,18 @@
 //				
 //			valueLayouts = new ArrayList<String>();
 //			functionPointer.getParameters().forEach(parameter -> {
-//				String layout = GeneratorUtils.stripPrefixes(config, getLayoutString(parameter.getType()), false);
+//				String layout = GeneratorUtils.transformName(config, getLayoutString(parameter.getType()), false);
 //				valueLayouts.add(layout);
 //			});
 //
-//			returnTypeLayout = GeneratorUtils.stripPrefixes(
+//			returnTypeLayout = GeneratorUtils.transformName(
 //					config,
 //					getLayoutString(functionPointer.getReturnType().getType()),
 //					false);
 //			
 //			hasReturnType = !method.getReturnType().getIsVoid();
 //			
-//			name = GeneratorUtils.stripPrefixes(config, functionPointer.getName(), true).replaceAll("\\*\\s*$", "").trim();
+//			name = GeneratorUtils.transformName(config, functionPointer.getName(), true).replaceAll("\\*\\s*$", "").trim();
 //			constantsName = name.replaceAll("([\\p{Ll}\\p{Nd}])(\\p{Lu})", "$1_$2").toUpperCase();
 //		}
 //

src/main/java/volucris/bindings/jolt/Jolt.java

@@ -39,7 +39,8 @@ public static void loadNativeLibrary() {
 	}
 
 	public static void loadNativeLibrary(boolean debug) {
-		NativeLibraryLoader.loadLibrary("natives/jolt", "jolt", debug);
+		NativeLibraryLoader.loadLibrary("natives/jolt", "joltc", debug);
+	}
 	}
 
 	public static boolean init() {

src/main/java/volucris/bindings/jolt/physicsSystem/PhysicsSystem.java

@@ -73,6 +73,7 @@ public final class PhysicsSystem {
     private static final LazyConstant<MethodHandle> JPH_PHYSICS_SYSTEM_DRAW_CONSTRAINT_LIMITS;
     private static final LazyConstant<MethodHandle> JPH_PHYSICS_SYSTEM_DRAW_CONSTRAINT_REFERENCE_FRAME;
     private static final LazyConstant<MethodHandle> JPH_PHYSICS_SYSTEM_GET_BODY_PTR;
+    private static final LazyConstant<MethodHandle> JPH_PHYSICS_SYSTEM_UPDATE2;
 
     private final MemorySegment segment;
 
@@ -117,6 +118,7 @@ public final class PhysicsSystem {
         JPH_PHYSICS_SYSTEM_DRAW_CONSTRAINT_LIMITS = downcallHandleVoid("JPH_PhysicsSystem_DrawConstraintLimits", UNBOUNDED_ADDRESS, UNBOUNDED_ADDRESS);
         JPH_PHYSICS_SYSTEM_DRAW_CONSTRAINT_REFERENCE_FRAME = downcallHandleVoid("JPH_PhysicsSystem_DrawConstraintReferenceFrame", UNBOUNDED_ADDRESS, UNBOUNDED_ADDRESS);
         JPH_PHYSICS_SYSTEM_GET_BODY_PTR = downcallHandle("JPH_PhysicsSystem_GetBodyPtr", UNBOUNDED_ADDRESS, UNBOUNDED_ADDRESS, JAVA_INT);
+        JPH_PHYSICS_SYSTEM_UPDATE2 = downcallHandle("JPH_PhysicsSystem_Update2", JAVA_INT, UNBOUNDED_ADDRESS, JAVA_FLOAT, JAVA_INT, UNBOUNDED_ADDRESS, UNBOUNDED_ADDRESS);
         //@formatter:on
     }
 
@@ -1218,6 +1220,45 @@ public static MemorySegment getBodyPtr(
         return new Body(segment);
     }
 
+    public static int update2(
+        MemorySegment system, 
+        float deltaTime, 
+        int collisionSteps, 
+        MemorySegment tempAllocator, 
+        MemorySegment jobSystem
+    ) {
+        MethodHandle method = JPH_PHYSICS_SYSTEM_UPDATE2.get();
+        try {
+            return (int) method.invokeExact(
+                system, 
+                deltaTime, 
+                collisionSteps, 
+                tempAllocator, 
+                jobSystem
+            );
+        } catch (Throwable e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    /**
+     * Typed method of {@link #update2}.
+     */
+    public final int update2(
+        float deltaTime, 
+        int collisionSteps, 
+        TempAllocator tempAllocator, 
+        JobSystem jobSystem
+    ) {
+        return (int) update2(
+            this.segment, 
+            deltaTime, 
+            collisionSteps, 
+            tempAllocator.memorySegment(), 
+            jobSystem.memorySegment()
+        );
+    }
+    
     public MemorySegment memorySegment() {
     	return segment;
     }

src/main/java/volucris/bindings/jolt/physicsSystem/TempAllocator.java

@@ -0,0 +1,105 @@
+/*
+ * MACHINE GENERATED FILE, DO NOT EDIT.
+ */
+package volucris.bindings.jolt.physicsSystem;
+
+import edu.umd.cs.findbugs.annotations.Nullable;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.invoke.MethodHandle;
+
+import static java.lang.foreign.ValueLayout.*;
+import static volucris.bindings.core.FFMUtils.*;;
+
+/**
+ * 
+ */
+public final class TempAllocator {
+
+    private static final LazyConstant<MethodHandle> JPH_TEMP_ALLOCATOR_CREATE;
+    private static final LazyConstant<MethodHandle> JPH_TEMP_ALLOCATOR_MALLOC_CREATE;
+    private static final LazyConstant<MethodHandle> JPH_TEMP_ALLOCATOR_DESTROY;
+
+    private final MemorySegment segment;
+
+    static {
+        //@formatter:off
+        JPH_TEMP_ALLOCATOR_CREATE = downcallHandle("JPH_TempAllocator_Create", UNBOUNDED_ADDRESS, JAVA_INT);
+        JPH_TEMP_ALLOCATOR_MALLOC_CREATE = downcallHandle("JPH_TempAllocatorMalloc_Create", UNBOUNDED_ADDRESS);
+        JPH_TEMP_ALLOCATOR_DESTROY = downcallHandleVoid("JPH_TempAllocator_Destroy", UNBOUNDED_ADDRESS);
+        //@formatter:on
+    }
+
+    public TempAllocator(
+        int size
+    ) {
+        this(
+            Arena.ofAuto(),
+            size
+        );
+    }
+    
+    public TempAllocator(
+        Arena arena,
+        int size
+    ) {
+         MemorySegment segment = create(
+            size
+         );
+    
+         this.segment = segment.reinterpret(arena, s -> destroy(s));
+    }
+    
+    public TempAllocator() {
+        this(Arena.ofAuto());
+    }
+    
+    public TempAllocator(Arena arena) {
+        MemorySegment segment = create();
+        this.segment = segment.reinterpret(arena, s -> destroy(s));
+    }
+    
+    public TempAllocator(MemorySegment segment) {
+        this.segment = segment;
+    }
+
+    public static MemorySegment create(
+        int size
+    ) {
+        MethodHandle method = JPH_TEMP_ALLOCATOR_CREATE.get();
+        try {
+            return (MemorySegment) method.invokeExact(
+                size
+            );
+        } catch (Throwable e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    public static MemorySegment create() {
+        MethodHandle method = JPH_TEMP_ALLOCATOR_MALLOC_CREATE.get();
+        try {
+            return (MemorySegment) method.invokeExact();
+        } catch (Throwable e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    public static void destroy(
+        MemorySegment allocator
+    ) {
+        MethodHandle method = JPH_TEMP_ALLOCATOR_DESTROY.get();
+        try {
+            method.invokeExact(
+                allocator
+            );
+        } catch (Throwable e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    public MemorySegment memorySegment() {
+    	return segment;
+    }
+    
+}

src/main/resources/classConfigs/physicsSystem/TempAllocator.yaml

@@ -0,0 +1,41 @@
+class-description:
+  name: TempAllocator
+  package-name: volucris.bindings.jolt.physicsSystem
+  directory: src/main/java/volucris/bindings/jolt/physicsSystem
+  is-static: false
+  parent:
+  interfaces: []
+  is-sealed: false
+  permits: []
+  is-abstract: false
+  is-final: true
+  instance-parameter: allocator
+
+imports:
+static-imports:
+  - java.lang.foreign.ValueLayout.*
+  - volucris.bindings.core.FFMUtils.*;
+
+macro-name-prefixes:
+excluded-macro-name-prefixes:
+macro-names:
+excluded-macro-names:
+
+symbol-prefixes:
+symbols:
+
+function-name-prefixes:
+  - JPH_TempAllocator_
+  - JPH_TempAllocatorMalloc_
+excluded-function-name-prefixes:
+function-name-postfixes:
+excluded-function-name-postfixes:
+
+constructors:
+  - native-function: JPH_TempAllocator_Create
+    destructor: JPH_TempAllocator_Destroy
+  - native-function: JPH_TempAllocatorMalloc_Create
+    destructor: JPH_TempAllocator_Destroy
+struct:
+native-functions:    
+native-function-pointers:

src/main/resources/globalConfig/globalConfig.yaml

@@ -1,5 +1,7 @@
 naming:
   strip-prefixes:
+    - JPH_TempAllocator_
+    - JPH_TempAllocatorMalloc_
     - JPH_SkeletonPose_
     - JPH_BodyManager_
     - JPH_PhysicsUpdateError_

src/main/resources/headers/joltc.h

@@ -3167,4 +3167,14 @@ JPH_CAPI uint32_t JPH_LinearCurve_GetPointCount(const JPH_LinearCurve* curve);
 JPH_CAPI void JPH_LinearCurve_GetPoint(const JPH_LinearCurve* curve, uint32_t index, JPH_Point* result);
 JPH_CAPI void JPH_LinearCurve_GetPoints(const JPH_LinearCurve* curve, JPH_Point* points, uint32_t* count);
 
+/* Temp Allocator */
+typedef struct JPH_TempAllocator JPH_TempAllocator;
+
+JPH_CAPI JPH_TempAllocator* JPH_TempAllocator_Create(uint32_t size);
+JPH_CAPI JPH_TempAllocator* JPH_TempAllocatorMalloc_Create(void);
+JPH_CAPI void JPH_TempAllocator_Destroy(JPH_TempAllocator* allocator);
+
+/* Explicit Allocator Variants */
+JPH_CAPI JPH_PhysicsUpdateError JPH_PhysicsSystem_Update2(JPH_PhysicsSystem* system, float deltaTime, int collisionSteps, JPH_TempAllocator* tempAllocator, JPH_JobSystem* jobSystem);
+
 #endif /* JOLT_C_H_ */