├── Editor.meta
├── Editor
    ├── RapierEntry.cs
    └── RapierEntry.cs.meta
├── README.md
├── README.md.meta
├── Runtime.meta
├── Runtime
    ├── Components.meta
    ├── Components
    │   ├── RapierConfiguration.cs
    │   ├── RapierConfiguration.cs.meta
    │   ├── RapierFixedJoint.cs
    │   ├── RapierFixedJoint.cs.meta
    │   ├── RapierJoint.cs
    │   ├── RapierJoint.cs.meta
    │   ├── RapierPrismaticJoint.cs
    │   ├── RapierPrismaticJoint.cs.meta
    │   ├── RapierRevoluteJoint.cs
    │   ├── RapierRevoluteJoint.cs.meta
    │   ├── RapierSphericalJoint.cs
    │   └── RapierSphericalJoint.cs.meta
    ├── NativeLoader.cs
    ├── NativeLoader.cs.meta
    ├── Packages.rapier4unity.Runtime.asmdef
    ├── Packages.rapier4unity.Runtime.asmdef.meta
    ├── PhysicsEventWrapper.cs
    ├── PhysicsEventWrapper.cs.meta
    ├── RapierBindings.cs
    ├── RapierBindings.cs.meta
    ├── RapierBinds.cs
    └── RapierBinds.cs.meta
├── Unity.Rapier4Unity.CodeGen.meta
├── Unity.Rapier4Unity.CodeGen
    ├── ILPPHelpers.cs
    ├── ILPPHelpers.cs.meta
    ├── PhysicsPostProcessor.cs
    ├── PhysicsPostProcessor.cs.meta
    ├── Unity.Rapier4Unity.CodeGen.asmdef
    └── Unity.Rapier4Unity.CodeGen.asmdef.meta
├── build_bin.meta
├── build_bin
    ├── Android.meta
    ├── Android
    │   ├── librapier_c_bind.so
    │   ├── librapier_c_bind.so.meta
    │   ├── libunitybridge.so
    │   └── libunitybridge.so.meta
    ├── Windows.meta
    ├── Windows
    │   ├── rapier_c_bind.dll
    │   ├── rapier_c_bind.dll.meta
    │   ├── rapier_c_bind.pdb
    │   ├── rapier_c_bind.pdb.meta
    │   ├── unitybridge.dll
    │   ├── unitybridge.dll.meta
    │   ├── unitybridge.pdb
    │   └── unitybridge.pdb.meta
    ├── iOS.meta
    ├── iOS
    │   ├── librapier_c_bind.a
    │   ├── librapier_c_bind.a.meta
    │   ├── libunitybridge.a
    │   └── libunitybridge.a.meta
    ├── macOS.meta
    └── macOS
    │   ├── rapier_c_bind.bundle
    │   ├── rapier_c_bind.bundle.meta
    │   ├── unitybridge.bundle
    │   └── unitybridge.bundle.meta
├── docs~
    ├── overview.mp4
    ├── raycast.mp4
    └── readme.md
├── package.json
├── package.json.meta
└── source~
    └── rapier-c-bind
        ├── .gitignore
        ├── .idea
            ├── .gitignore
            ├── encodings.xml
            ├── modules.xml
            ├── rapier-c-bind.iml
            └── vcs.xml
        ├── Cargo.toml
        ├── android_linker.ld
        ├── build-debug.bat
        ├── build-debug.sh
        ├── build-release.bat
        ├── build-release.sh
        ├── export-to-unity-dynamic-binder
            ├── Cargo.toml
            └── src
            │   └── main.rs
        ├── get-build-dependencies.bat
        ├── get-build-dependencies.sh
        ├── rapierbind
            ├── Cargo.toml
            └── src
            │   ├── handles.rs
            │   ├── lib.rs
            │   └── utils.rs
        ├── readme.md
        └── unitybridge
            ├── Cargo.toml
            └── src
                └── lib.rs


/Editor.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 5bdb05de1422482393a4bb22a326f444
3 | timeCreated: 1741914902


--------------------------------------------------------------------------------
/Editor/RapierEntry.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Reflection;
 5 | using System.Runtime.InteropServices;
 6 | using UnityEditor;
 7 | using UnityEngine;
 8 | using UnityEngine.LowLevel;
 9 | 
10 | namespace Editor
11 | {
12 |     [InitializeOnLoad]
13 |     public static class RapierEntry
14 |     {
15 |         static RapierEntry()
16 |         {
17 |             // Check if the override is enabled
18 |             if (!EditorPrefs.GetBool("RapierPhysicsOverrideEnabled", true))
19 |                 return;
20 |             
21 |             if (GetSelectedPhysicSDKInfoProperty() is {} idProp)
22 |             {
23 |                 // Set the physics backend to 'Rapier' (by setting the id to the null physics backend id)
24 |                 if (idProp.uintValue != 3737844653)
25 |                 {
26 |                     idProp.uintValue = 3737844653;
27 |                     idProp.serializedObject.ApplyModifiedProperties();
28 |                     Debug.LogWarning("Physics backend set to 'None' as Rapier is enabled.\n<b><color=\"#ff00ffff\">Please restart the editor for changes to take effect.</color></b>");
29 |                 }
30 |             }
31 |         }
32 | 
33 |         static IReadOnlyCollection<(string Name, uint Id)> GetPhysicSDKInfos()
34 |         {
35 |             var returnVal = new List<(string Name, uint Id)>();
36 |             
37 |             var getIntegrationInfos = typeof(Physics).GetMethods(BindingFlags.NonPublic|BindingFlags.Static).First(m=> m.GetParameters().Length == 2 && m.Name=="GetIntegrationInfos");
38 |             var args = new object[] { null, null };
39 |             getIntegrationInfos.Invoke(null, args);
40 |             var integrationType = Type.GetType("UnityEngine.IntegrationInfo, UnityEngine.PhysicsModule");
41 |             var integrationInfos = (IntPtr)args[0];
42 |             var integrationCount = (ulong)args[1];
43 |             for (var i = 0; i < (int)integrationCount; i++)
44 |             {
45 |                 var integrationInfo = Marshal.PtrToStructure(integrationInfos, integrationType);
46 |                 var id = integrationType.GetField("Id").GetValue(integrationInfo);
47 |                 var name = integrationType.GetProperty("Name").GetValue(integrationInfo);
48 |                 returnVal.Add(((string)name, (uint)id));
49 |                 integrationInfos += Marshal.SizeOf(integrationType);
50 |             }
51 |             
52 |             return returnVal;
53 |         }
54 | 
55 |         static SerializedProperty GetSelectedPhysicSDKInfoProperty()
56 |         {
57 |             var found = AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/DynamicsManager.asset");
58 |             var serializedObject = found is not null ? new SerializedObject(found[0]) : null;
59 |             return serializedObject?.FindProperty("m_CurrentBackendId");
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/Editor/RapierEntry.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 9030555664e5456091892898eeb3c3af
3 | timeCreated: 1741914989


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Rapier for Unity
 2 | This package lets you simulate physics in unity using Rapier. 
 3 | 
 4 | This is useful for when you want to run physics in non-unity clients for validation. 
 5 | E.g. Server Authoritive setup with client side prediction. An example of excellent use is running Rapier on a SpaceTimeDB server, and when syncing it with a client also running Rapier.
 6 | 
 7 | 
 8 | 
 9 | ## Overview
10 | Quick showcase:
11 | <video src='https://github.com/user-attachments/assets/7429283b-71d8-4e6a-a1fb-1256f48382cc' width=180/>
12 | 
13 | Note how it acts just like normal Unity! and it even supports raycasting! 
14 | <video src='https://github.com/user-attachments/assets/5d6ed46d-ddd2-47f2-9d2e-7d43020aa74f' width=180/>
15 | 


--------------------------------------------------------------------------------
/README.md.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 895eff6c0a45aaa4ab03cf834175e018
3 | TextScriptImporter:
4 |   externalObjects: {}
5 |   userData: 
6 |   assetBundleName: 
7 |   assetBundleVariant: 
8 | 


--------------------------------------------------------------------------------
/Runtime.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 3d64abb060db4b6b8c0dc1aac7b7b470
3 | timeCreated: 1741962361


--------------------------------------------------------------------------------
/Runtime/Components.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 266beaf39e7f5744db95e80daa36d67c
3 | folderAsset: yes
4 | DefaultImporter:
5 |   externalObjects: {}
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/Runtime/Components/RapierConfiguration.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using UnityEngine;
 3 | 
 4 | namespace RapierPhysics
 5 | {
 6 |     public class RapierConfiguration : MonoBehaviour
 7 |     {
 8 |         [Header("Time Settings")]
 9 |         [Tooltip("The ticks per second for physics simulation. Default: 50 (1.0f/50.0f = 0.02 seconds)")]
10 |         public float PhysicsTicksPerSecond = 50.0f;
11 | 
12 |         [Header("Solver Parameters")]
13 |         [Tooltip("The number of solver iterations run by the constraints solver for calculating forces. Higher values increase accuracy but decrease performance. Default: 4")]
14 |         public int NumSolverIterations = 4;
15 | 
16 |         [Tooltip("Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration. Default: 1")]
17 |         public int NumInternalPgsIterations = 1;
18 | 
19 |         [Tooltip("Number of additional friction resolution iterations run during the last solver sub-step. Default: 0")]
20 |         public int NumAdditionalFrictionIterations = 0;
21 | 
22 |         [Tooltip("The number of stabilization iterations run at each solver iteration. Default: 2")]
23 |         public int NumInternalStabilizationIterations = 2;
24 | 
25 |         [Tooltip("Maximum number of substeps performed by the continuous collision detection (CCD) solver. Higher values improve collision accuracy but increase computational cost. Default: 1")]
26 |         public int MaxCcdSubsteps = 1;
27 | 
28 |         [Header("Constraint Parameters")]
29 |         [Tooltip("The damping ratio used by the springs for contact constraint stabilization. Larger values make the constraints more compliant (allowing more visible penetrations before stabilization). Default: 5.0")]
30 |         public float ContactDampingRatio = 5.0f;
31 | 
32 |         [Tooltip("The natural frequency used by the springs for contact constraint regularization. Increasing this value will make penetrations get fixed more quickly at the expense of potential jitter effects due to overshooting. Default: 30.0")]
33 |         public float ContactNaturalFrequency = 30.0f;
34 | 
35 |         [Tooltip("The natural frequency used by the springs for joint constraint regularization. Increasing this value will make penetrations get fixed more quickly. Default: 1.0e6")]
36 |         public float JointNaturalFrequency = 1.0e6f;
37 | 
38 |         [Tooltip("The fraction of critical damping applied to joints for constraints regularization. Larger values make the constraints more compliant (allowing more joint drift before stabilization). Default: 1.0")]
39 |         public float JointDampingRatio = 1.0f;
40 | 
41 |         [Header("Collision and Correction")]
42 |         [Tooltip("The approximate size of most dynamic objects in the scene, representing units-per-meter. This value is used internally to scale various length-based tolerances. For example, in a 2D game, if your typical object size is 100 pixels, set this to 100.0. Default: 1.0")]
43 |         public float LengthUnit = 1.0f;
44 | 
45 |         [Tooltip("The maximal distance separating two objects that will generate predictive contacts. This value is implicitly scaled by length_unit. Default: 0.002m")]
46 |         public float NormalizedPredictionDistance = 0.002f;
47 | 
48 |         [Tooltip("Maximum amount of penetration the solver will attempt to resolve in one timestep. This value is implicitly scaled by length_unit. Default: 10.0")]
49 |         public float NormalizedMaxCorrectiveVelocity = 10.0f;
50 | 
51 | 
52 |         public void Awake()
53 |         {
54 |             RapierBindings.SetIntegrationParameters(
55 |                 1.0f / PhysicsTicksPerSecond,
56 |                 new UIntPtr((uint)NumSolverIterations),
57 |                 new UIntPtr((uint)NumInternalPgsIterations),
58 |                 new UIntPtr((uint)NumAdditionalFrictionIterations),
59 |                 new UIntPtr((uint)NumInternalStabilizationIterations),
60 |                 new UIntPtr((uint)MaxCcdSubsteps),
61 |                 ContactDampingRatio,
62 |                 JointDampingRatio,
63 |                 ContactNaturalFrequency,
64 |                 JointNaturalFrequency,
65 |                 NormalizedPredictionDistance,
66 |                 NormalizedMaxCorrectiveVelocity,
67 |                 LengthUnit
68 |             );
69 |         }
70 |     }
71 | }


--------------------------------------------------------------------------------
/Runtime/Components/RapierConfiguration.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 95a4f99b18461b948a89155c2f37b64c


--------------------------------------------------------------------------------
/Runtime/Components/RapierFixedJoint.cs:
--------------------------------------------------------------------------------
1 | namespace RapierPhysics
2 | {
3 |     public class RapierFixedJoint : RapierJoint
4 |     {
5 | 
6 |     }
7 | }


--------------------------------------------------------------------------------
/Runtime/Components/RapierFixedJoint.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 66acd02b04fd29843b68a8f5031d4580


--------------------------------------------------------------------------------
/Runtime/Components/RapierJoint.cs:
--------------------------------------------------------------------------------
 1 | using Codice.CM.Common;
 2 | using UnityEngine;
 3 | 
 4 | namespace RapierPhysics
 5 | {
 6 |     /// <summary>
 7 |     ///     The base class for all joints.
 8 |     /// </summary>
 9 |     public abstract class RapierJoint : MonoBehaviour
10 |     {
11 |         [Header("Joint Settings")]
12 |         /// <summary>
13 |         /// The self collision flag. If false, the joint will not collide with itself.
14 |         /// </summary>
15 |         public bool SelfCollision = true;
16 | 
17 |         /// <summary>
18 |         /// The anchor rigidbody, the primary body that this joint is attached to.
19 |         /// </summary>
20 |         /// 
21 |         public Rigidbody Anchor;
22 | 
23 |         /// <summary>
24 |         /// The articulation rigidbody that is attached to the anchor.
25 |         /// </summary>
26 |         public Rigidbody Mover;
27 | 
28 |         /// <summary>
29 |         /// The first anchor point in local space.
30 |         /// </summary>
31 |         public Vector3 Anchor1;
32 | 
33 |         /// <summary>
34 |         /// The second anchor point in local space.
35 |         /// </summary>
36 |         public Vector3 Anchor2;
37 | 
38 |         protected virtual void OnEnable()
39 |         {
40 |             // Only register the joint if both anchor and mover are set
41 |             if (Anchor == null || Mover == null)
42 |             {
43 |                 Debug.LogError("Anchor and Mover must be set for the joint to work properly.");
44 |                 return;
45 |             }
46 | 
47 |             RapierLoop.RegisterJoint(this);
48 |         }
49 | 
50 |         protected virtual void OnDisable()
51 |         {
52 |             RapierLoop.UnregisterJoint(this);
53 |         }
54 | 
55 |         // Create gizmos to show the anchor points in the editor (only when selected)
56 |         protected virtual void OnDrawGizmos()
57 |         {
58 |             if (Anchor == null || Mover == null) return;
59 | 
60 |             // Draw the anchor points in local space
61 |             Gizmos.color = Color.red;
62 |             Gizmos.DrawSphere(Anchor.transform.TransformPoint(Anchor1), 0.1f);
63 |             Gizmos.color = Color.blue;
64 |             Gizmos.DrawSphere(Mover.transform.TransformPoint(Anchor2), 0.1f);
65 |         }
66 |     }
67 | }


--------------------------------------------------------------------------------
/Runtime/Components/RapierJoint.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: db46171464b4fef46a5c6b141d962bdb


--------------------------------------------------------------------------------
/Runtime/Components/RapierPrismaticJoint.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace RapierPhysics
 4 | {
 5 |     public class RapierPrismaticJoint : RapierJoint
 6 |     {
 7 |         /// <summary>
 8 |         /// The axis of rotation in local space.
 9 |         /// </summary>
10 |         public Vector3 Axis = Vector3.up;
11 | 
12 |         /// <summary>
13 |         /// The limits of the joint in local space.
14 |         /// </summary>
15 |         public Vector2 Limits = new Vector2(-1, 1);
16 | 
17 |         // Override the gizmos to show the axis of rotation and limits
18 |         protected override void OnDrawGizmos()
19 |         {
20 |             base.OnDrawGizmos();
21 |             if (Anchor == null || Mover == null) return;
22 | 
23 |             Gizmos.color = Color.red;
24 |             Gizmos.DrawLine(Anchor.transform.TransformPoint(Anchor1), Anchor.transform.TransformPoint(Anchor1 + Axis));
25 | 
26 |             Gizmos.color = Color.green;
27 |             Vector3 limit1 = Anchor.transform.TransformPoint(Anchor1 + Axis * Limits.x);
28 |             Vector3 limit2 = Anchor.transform.TransformPoint(Anchor1 + Axis * Limits.y);
29 |             Gizmos.DrawLine(limit1, limit2);
30 |             Gizmos.DrawSphere(limit1, 0.1f);
31 |             Gizmos.DrawSphere(limit2, 0.1f);
32 |         }
33 |     }
34 | }


--------------------------------------------------------------------------------
/Runtime/Components/RapierPrismaticJoint.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 51abd5c8a96a2b740b9f16bd03119a6f


--------------------------------------------------------------------------------
/Runtime/Components/RapierRevoluteJoint.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace RapierPhysics
 4 | {
 5 |     public class RapierRevoluteJoint : RapierJoint
 6 |     {
 7 |         /// <summary>
 8 |         /// The axis of rotation in local space.
 9 |         /// </summary>
10 |         public Vector3 Axis;
11 | 
12 |         // Override the gizmos to show the axis of rotation
13 |         protected override void OnDrawGizmos()
14 |         {
15 |             base.OnDrawGizmos();
16 |             if (Anchor == null || Mover == null) return;
17 | 
18 |             Gizmos.color = Color.red;
19 |             Gizmos.DrawLine(Anchor.transform.TransformPoint(Anchor1), Anchor.transform.TransformPoint(Anchor1 + Axis));
20 |         }
21 |     }
22 | }


--------------------------------------------------------------------------------
/Runtime/Components/RapierRevoluteJoint.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: b3bfa10bf729f3b4d8ac485a495b9aaf


--------------------------------------------------------------------------------
/Runtime/Components/RapierSphericalJoint.cs:
--------------------------------------------------------------------------------
1 | namespace RapierPhysics
2 | {
3 |     public class RapierSphericalJoint : RapierJoint
4 |     {
5 | 
6 |     }
7 | }


--------------------------------------------------------------------------------
/Runtime/Components/RapierSphericalJoint.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: bcd60b6a29b8cb24f81e78eebf04fe57


--------------------------------------------------------------------------------
/Runtime/NativeLoader.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Runtime.InteropServices;
  3 | 
  4 | namespace Packages.rapier4unity.Runtime
  5 | {
  6 |     public static class NativeLoader
  7 |     {
  8 |         
  9 | #if UNITY_EDITOR_OSX
 10 |         private const string LibSystem = "/usr/lib/libSystem.dylib";
 11 | 
 12 |         // Flags for dlopen
 13 |         [Flags]
 14 |         public enum LoadMode : int
 15 |         {
 16 |             /// Only resolve symbols as needed
 17 |             Lazy = 0x1,		
 18 |             /// Resolve all symbols immediately
 19 |             Now = 0x2,		
 20 |             /// Symbols in this library are available to libraries loaded after this one
 21 |             Global = 0x8	
 22 |         }
 23 | 
 24 |         [DllImport(LibSystem)]
 25 |         static extern IntPtr dlopen(string path, LoadMode mode);
 26 | 
 27 |         [DllImport(LibSystem)]
 28 |         static extern IntPtr dlsym(IntPtr handle, string symbol);
 29 | 
 30 |         [DllImport(LibSystem)]
 31 |         static extern int dlclose(IntPtr handle);
 32 | 
 33 |         [DllImport(LibSystem)]
 34 |         static extern IntPtr dlerror(); // Get error message
 35 | #else
 36 |         private const string LibWindows = "kernel32.dll";
 37 |         
 38 |         [DllImport(LibWindows)]
 39 |         static extern IntPtr LoadLibraryA(string path);
 40 |         
 41 |         [DllImport(LibWindows)]
 42 |         static extern IntPtr GetProcAddress(IntPtr handle, string symbol);
 43 |         
 44 |         [DllImport(LibWindows, EntryPoint = "FreeLibrary")]
 45 |         static extern bool Win32FreeLibrary(IntPtr handle);
 46 |         
 47 |         [DllImport(LibWindows)]
 48 |         static extern IntPtr GetLastError();
 49 | #endif
 50 | 
 51 | 
 52 |         /// <summary>
 53 |         /// Load a library from the path (relative or absolute)
 54 |         /// DLL on Windows, dylib on OSX
 55 |         /// </summary>
 56 |         /// <param name="path">Path (can be relative to Unity project root or absolute) </param>
 57 |         /// <returns> Handle to Library </returns>
 58 |         public static IntPtr LoadLibrary(string path) =>
 59 | #if UNITY_EDITOR_OSX && UNITY_EDITOR
 60 |             dlopen(path, LoadMode.Lazy);
 61 | #elif UNITY_EDITOR
 62 |             LoadLibraryA(path);
 63 | #else
 64 |             throw new PlatformNotSupportedException("Loading libraries is not supported on player");
 65 | #endif
 66 |         
 67 |         /// <summary>
 68 |         ///  Get a function pointer from the library
 69 |         /// </summary>
 70 |         /// <param name="handle"> Library Handle gotten from <see cref="LoadLibrary"/> </param>
 71 |         /// <param name="symbol"> Name of the Symbol to load from the library </param>
 72 |         /// <returns></returns>
 73 |         public static IntPtr GetFunction(IntPtr handle, string symbol) =>
 74 | #if UNITY_EDITOR_OSX
 75 |             dlsym(handle, symbol);
 76 | #else
 77 |             GetProcAddress(handle, symbol);
 78 | #endif
 79 | 
 80 |         /// <summary>
 81 |         ///  Free the library handle
 82 |         /// </summary>
 83 |         /// <param name="handle"> The Library Handle gotten from <see cref="LoadLibrary"/> </param>
 84 |         public static void FreeLibrary(IntPtr handle) =>
 85 | #if UNITY_EDITOR_OSX
 86 |             dlclose(handle);
 87 | #else
 88 |             Win32FreeLibrary(handle);
 89 | #endif
 90 |         
 91 |         /// <summary>
 92 |         ///   Get the last error message from the native library
 93 |         /// </summary>
 94 |         /// <returns> The Error Message </returns>
 95 |         public static string GetLastErrorString() =>
 96 | #if UNITY_EDITOR_OSX
 97 |             Marshal.PtrToStringAnsi(dlerror());
 98 | #else 
 99 |             Marshal.PtrToStringAnsi(GetLastError());
100 | #endif
101 |         
102 |     }
103 |     
104 |     public static class UnityRapierBridge
105 |     {
106 | #if !UNITY_EDITOR && (UNITY_IOS || UNITY_WEBGL)
107 |         private const string DllName = "__Internal";
108 | #else
109 | 		private const string DllName = "unitybridge";
110 | #endif
111 | 
112 |         private const CallingConvention Convention = CallingConvention.Cdecl;
113 |         
114 |         [DllImport(DllName, CallingConvention = Convention)]
115 |         public static extern IntPtr GetDefaultUnityLogger();
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/Runtime/NativeLoader.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 75ebc69e608e4337b8f7308de502a36e
3 | timeCreated: 1743053785


--------------------------------------------------------------------------------
/Runtime/Packages.rapier4unity.Runtime.asmdef:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "Runtime",
 3 |     "rootNamespace": "",
 4 |     "references": [
 5 |         "GUID:d8b63aba1907145bea998dd612889d6b",
 6 |         "GUID:e0cd26848372d4e5c891c569017e11f1",
 7 |         "GUID:2665a8d13d1b3f18800f46e256720795"
 8 |     ],
 9 |     "includePlatforms": [],
10 |     "excludePlatforms": [],
11 |     "allowUnsafeCode": true,
12 |     "overrideReferences": false,
13 |     "precompiledReferences": [],
14 |     "autoReferenced": true,
15 |     "defineConstraints": [],
16 |     "versionDefines": [],
17 |     "noEngineReferences": false
18 | }


--------------------------------------------------------------------------------
/Runtime/Packages.rapier4unity.Runtime.asmdef.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: dd1901c2a7d344979b302ee04acb1add
3 | AssemblyDefinitionImporter:
4 |   externalObjects: {}
5 |   userData: 
6 |   assetBundleName: 
7 |   assetBundleVariant: 
8 | 


--------------------------------------------------------------------------------
/Runtime/PhysicsEventWrapper.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using Packages.rapier4unity.Runtime;
  4 | using RapierPhysics;
  5 | using Unity.Collections;
  6 | using Unity.Collections.LowLevel.Unsafe;
  7 | using Unity.Mathematics;
  8 | using UnityEngine;
  9 | using UnityEngine.Assertions;
 10 | using UnityEngine.Events;
 11 | using UnityEngine.LowLevel;
 12 | using Object = UnityEngine.Object;
 13 | 
 14 | namespace Packages.rapier4unity.Runtime
 15 | {
 16 | 	/// <summary>
 17 | 	/// This class is used to wrap the physics event system.
 18 | 	/// Everything from OnTriggerEnter to OnJointBreak is wrapped here.
 19 | 	/// </summary>
 20 | #if UNITY_EDITOR
 21 | 	[UnityEditor.InitializeOnLoad]
 22 | #endif
 23 | 	public static class PhysicsEventWrapper
 24 | 	{
 25 | #if UNITY_EDITOR
 26 | 		static PhysicsEventWrapper()
 27 | 		{
 28 | 			// Ensure that we teardown the physics bindings when exiting play mode
 29 | 			UnityEditor.EditorApplication.playModeStateChanged += state =>
 30 | 			{
 31 | 				if (state == UnityEditor.PlayModeStateChange.EnteredEditMode)
 32 | 				{
 33 | 					if (RapierBindings.IsAvailable)
 34 | 					{
 35 | 						RapierBindings.Teardown();
 36 | 						RapierBindings.UnloadCalls();
 37 | 					}
 38 | 				}
 39 | 			};
 40 | 		}
 41 | #endif
 42 | 
 43 | 		[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
 44 | 		static void SetupPlayerLoop()
 45 | 		{
 46 | 			RapierBindings.LoadCalls();
 47 | 
 48 | 			// Get the current player loop
 49 | 			PlayerLoopSystem loop = PlayerLoop.GetCurrentPlayerLoop();
 50 | 			for (int i = 0; i < loop.subSystemList.Length; i++)
 51 | 			{
 52 | 				PlayerLoopSystem subSystem = loop.subSystemList[i];
 53 | 				if (subSystem.type == typeof(UnityEngine.PlayerLoop.FixedUpdate))
 54 | 				{
 55 | 					// Append FixedUpdate to subsytems
 56 | 					PlayerLoopSystem[] newSubSystems = new PlayerLoopSystem[subSystem.subSystemList.Length + 1];
 57 | 					for (int j = 0; j < subSystem.subSystemList.Length; j++)
 58 | 						newSubSystems[j] = subSystem.subSystemList[j];
 59 | 					newSubSystems[subSystem.subSystemList.Length] = new PlayerLoopSystem
 60 | 					{
 61 | 						type = typeof(RapierLoop),
 62 | 						updateDelegate = RapierLoop.FixedUpdate
 63 | 					};
 64 | 					subSystem.subSystemList = newSubSystems;
 65 | 					loop.subSystemList[i] = subSystem;
 66 | 				}
 67 | 
 68 | 				if (subSystem.type == typeof(UnityEngine.PlayerLoop.Initialization))
 69 | 				{
 70 | 					// Append Rapier initialization to subsytems
 71 | 					PlayerLoopSystem[] newSubSystems = new PlayerLoopSystem[subSystem.subSystemList.Length + 1];
 72 | 					for (int j = 0; j < subSystem.subSystemList.Length; j++)
 73 | 						newSubSystems[j] = subSystem.subSystemList[j];
 74 | 					newSubSystems[subSystem.subSystemList.Length] = new PlayerLoopSystem
 75 | 					{
 76 | 						type = typeof(RapierLoop),
 77 | 						updateDelegate = RapierLoop.Initialization
 78 | 					};
 79 | 					subSystem.subSystemList = newSubSystems;
 80 | 					loop.subSystemList[i] = subSystem;
 81 | 				}
 82 | 			}
 83 | 
 84 | 			// Set the modified player loop
 85 | 			PlayerLoop.SetPlayerLoop(loop);
 86 | 		}
 87 | 	}
 88 | }
 89 | 
 90 | 
 91 | public class RapierLoop
 92 | {
 93 | 	struct EventsForCollider
 94 | 	{
 95 | 		public List<BasicEvent<Collider>> onTriggerEnter;
 96 | 		public List<BasicEvent<Collider>> onTriggerExit;
 97 | 		public List<BasicEvent<Collider>> onTriggerStay;
 98 | 
 99 | 		public List<BasicEvent<Collision>> onCollisionEnter;
100 | 		public List<BasicEvent<Collision>> onCollisionExit;
101 | 		public List<BasicEvent<Collision>> onCollisionStay;
102 | 	}
103 | 
104 | 	struct EventsForMonoBehaviour
105 | 	{
106 | 		public BasicEvent<Collider> onTriggerEnter;
107 | 		public BasicEvent<Collider> onTriggerExit;
108 | 		public BasicEvent<Collider> onTriggerStay;
109 | 
110 | 		public BasicEvent<Collision> onCollisionEnter;
111 | 		public BasicEvent<Collision> onCollisionExit;
112 | 		public BasicEvent<Collision> onCollisionStay;
113 | 	}
114 | 
115 | 	struct BasicEvent<T>
116 | 	{
117 | 		//public delegate* <T, void> callback;
118 | 		delegate void Callback(T collider);
119 | 		Callback m_Callback;
120 | 		public void Invoke(T collider) => m_Callback?.Invoke(collider);
121 | 		public bool IsValid => m_Callback != null;
122 | 		public BasicEvent(MonoBehaviour component, string methodName)
123 | 		{
124 | 			System.Reflection.MethodInfo methodInfo = UnityEventBase.GetValidMethodInfo(component.GetType(), methodName, new[] { typeof(T) });
125 | 			m_Callback = (Callback)methodInfo?.CreateDelegate(typeof(Callback), component);
126 | 		}
127 | 	}
128 | 
129 | 	static Dictionary<Rigidbody, RigidBodyHandle> rigidbodyToHandle = new();
130 | 	static Dictionary<Collider, ColliderHandle> colliderToHandle = new();
131 | 	static Dictionary<ColliderHandle, Collider> handleToCollider = new();
132 | 	static Dictionary<Collider, RigidBodyHandle> fixedRigidbodies = new();
133 | 	static Dictionary<Collider, EventsForCollider> physicsEvents = new();
134 | 	static Dictionary<RapierJoint, ImpulseJointHandle> joints = new();
135 | 	static Dictionary<MonoBehaviour, EventsForMonoBehaviour> monoBehaviourEvents = new();
136 | 	static HashSet<(Collider, Collider)> activeTriggerPairs = new();
137 | 
138 | 	public static void RegisterJoint(RapierJoint joint)
139 | 	{
140 | 		if (joints.ContainsKey(joint))
141 | 			return;
142 | 
143 | 		// If the mover is kinematic, we cannot continue
144 | 		if (joint.Mover.isKinematic)
145 | 		{
146 | 			Debug.LogError("Mover must not be kinematic for the joint to work properly.");
147 | 			return;
148 | 		}
149 | 
150 | 		// Make sure the rigidbodies are registered
151 | 		if (!rigidbodyToHandle.ContainsKey(joint.Anchor))
152 | 		{
153 | 			RigidBodyHandle handle = CreateOrGetRigidBodyHandle(joint.Anchor);
154 | 			UpdateRigidBody(joint.Anchor, handle);
155 | 		}
156 | 
157 | 		if (!rigidbodyToHandle.ContainsKey(joint.Mover))
158 | 		{
159 | 			RigidBodyHandle handle = CreateOrGetRigidBodyHandle(joint.Mover);
160 | 			UpdateRigidBody(joint.Mover, handle);
161 | 		}
162 | 
163 | 		RigidBodyHandle anchorHandle = rigidbodyToHandle[joint.Anchor];
164 | 		RigidBodyHandle moverHandle = rigidbodyToHandle[joint.Mover];
165 | 		ImpulseJointHandle jointHandle;
166 | 		if (joint is RapierFixedJoint fixedJoint)
167 | 		{
168 | 
169 | 			Vector3 anchor1 = Vector3.Scale(fixedJoint.Anchor1, fixedJoint.Anchor.transform.lossyScale);
170 | 			Vector3 anchor2 = Vector3.Scale(fixedJoint.Anchor2, fixedJoint.Mover.transform.lossyScale);
171 | 			jointHandle = RapierBindings.AddFixedJoint(
172 | 				anchorHandle,
173 | 				moverHandle,
174 | 				anchor1.x,
175 | 				anchor1.y,
176 | 				anchor1.z,
177 | 				anchor2.x,
178 | 				anchor2.y,
179 | 				anchor2.z,
180 | 				fixedJoint.SelfCollision);
181 | 		}
182 | 		else if (joint is RapierSphericalJoint sphericalJoint)
183 | 		{
184 | 			Vector3 anchor1 = Vector3.Scale(sphericalJoint.Anchor1, sphericalJoint.Anchor.transform.lossyScale);
185 | 			Vector3 anchor2 = Vector3.Scale(sphericalJoint.Anchor2, sphericalJoint.Mover.transform.lossyScale);
186 | 			jointHandle = RapierBindings.AddSphericalJoint(
187 | 				anchorHandle,
188 | 				moverHandle,
189 | 				anchor1.x,
190 | 				anchor1.y,
191 | 				anchor1.z,
192 | 				anchor2.x,
193 | 				anchor2.y,
194 | 				anchor2.z,
195 | 				sphericalJoint.SelfCollision);
196 | 		}
197 | 		// Check which kind of joint we need to create
198 | 		else if (joint is RapierRevoluteJoint revoluteJoint)
199 | 		{
200 | 			Vector3 anchor1 = Vector3.Scale(revoluteJoint.Anchor1, revoluteJoint.Anchor.transform.lossyScale);
201 | 			Vector3 anchor2 = Vector3.Scale(revoluteJoint.Anchor2, revoluteJoint.Mover.transform.lossyScale);
202 | 			jointHandle = RapierBindings.AddRevoluteJoint(
203 | 				anchorHandle,
204 | 				moverHandle,
205 | 				revoluteJoint.Axis.x,
206 | 				revoluteJoint.Axis.y,
207 | 				revoluteJoint.Axis.z,
208 | 				anchor1.x,
209 | 				anchor1.y,
210 | 				anchor1.z,
211 | 				anchor2.x,
212 | 				anchor2.y,
213 | 				anchor2.z,
214 | 				revoluteJoint.SelfCollision);
215 | 		}
216 | 		else if (joint is RapierPrismaticJoint prismaticJoint)
217 | 		{
218 | 			Vector3 anchor1 = Vector3.Scale(prismaticJoint.Anchor1, prismaticJoint.Anchor.transform.lossyScale);
219 | 			Vector3 anchor2 = Vector3.Scale(prismaticJoint.Anchor2, prismaticJoint.Mover.transform.lossyScale);
220 | 			jointHandle = RapierBindings.AddPrismaticJoint(
221 | 				anchorHandle,
222 | 				moverHandle,
223 | 				prismaticJoint.Axis.x,
224 | 				prismaticJoint.Axis.y,
225 | 				prismaticJoint.Axis.z,
226 | 				anchor1.x,
227 | 				anchor1.y,
228 | 				anchor1.z,
229 | 				anchor2.x,
230 | 				anchor2.y,
231 | 				anchor2.z,
232 | 				prismaticJoint.Limits.x,
233 | 				prismaticJoint.Limits.y,
234 | 				prismaticJoint.SelfCollision);
235 | 		}
236 | 		else
237 | 		{
238 | 			Debug.LogError($"Unsupported joint type: {joint.GetType()}");
239 | 			return;
240 | 		}
241 | 
242 | 		joints[joint] = jointHandle;
243 | 	}
244 | 
245 | 	public static void UnregisterJoint(RapierJoint joint)
246 | 	{
247 | 		if (!joints.ContainsKey(joint))
248 | 			return;
249 | 
250 | 		// Remove joint handle
251 | 		ImpulseJointHandle jointHandle = joints[joint];
252 | 		RapierBindings.RemoveJoint(jointHandle);
253 | 		joints.Remove(joint);
254 | 	}
255 | 
256 | 	public static void AddForceWithMode(Rigidbody rigidbody, Vector3 force, ForceMode mode)
257 | 	{
258 | 		RigidBodyHandle handle = rigidbodyToHandle[rigidbody];
259 | 		RapierBindings.AddForce(handle, force.x, force.y, force.z, mode);
260 | 	}
261 | 
262 | 	public static void AddForce(Rigidbody rigidbody, Vector3 force)
263 | 	{
264 | 		RigidBodyHandle handle = rigidbodyToHandle[rigidbody];
265 | 		RapierBindings.AddForce(handle, force.x, force.y, force.z, ForceMode.Force);
266 | 	}
267 | 
268 | 	public static void AddTorque(Rigidbody rigidbody, Vector3 torque)
269 | 	{
270 | 		RigidBodyHandle handle = rigidbodyToHandle[rigidbody];
271 | 		RapierBindings.AddTorque(handle, torque.x, torque.y, torque.z, ForceMode.Force);
272 | 	}
273 | 
274 | 	public static void AddTorqueWithMode(Rigidbody rigidbody, Vector3 torque, ForceMode mode)
275 | 	{
276 | 		RigidBodyHandle handle = rigidbodyToHandle[rigidbody];
277 | 		RapierBindings.AddTorque(handle, torque.x, torque.y, torque.z, mode);
278 | 	}
279 | 
280 | 	public static void MovePosition(Rigidbody rigidbody, Vector3 position)
281 | 	{
282 | 		if (!rigidbody.isKinematic)
283 | 		{
284 | 			Debug.LogError("MovePosition is not supported for non-kinematic rigidbodies. Apply forces instead or set the rigidbody to kinematic.");
285 | 			return;
286 | 		}
287 | 
288 | 		RigidBodyHandle handle = rigidbodyToHandle[rigidbody];
289 | 		RapierBindings.SetTransformPosition(handle, position.x, position.y, position.z);
290 | 	}
291 | 
292 | 	public static void MoveRotation(Rigidbody rigidbody, Quaternion rotation)
293 | 	{
294 | 		if (!rigidbody.isKinematic)
295 | 		{
296 | 			Debug.LogError("MovePosition is not supported for non-kinematic rigidbodies. Apply forces instead or set the rigidbody to kinematic.");
297 | 			return;
298 | 		}
299 | 
300 | 		RigidBodyHandle handle = rigidbodyToHandle[rigidbody];
301 | 		RapierBindings.SetTransformRotation(handle, rotation.x, rotation.y, rotation.z, rotation.w);
302 | 	}
303 | 
304 | 	public static void Move(Rigidbody rigidbody, Vector3 position, Quaternion rotation)
305 | 	{
306 | 		if (!rigidbody.isKinematic)
307 | 		{
308 | 			Debug.LogError("MovePosition is not supported for non-kinematic rigidbodies. Apply forces instead or set the rigidbody to kinematic.");
309 | 			return;
310 | 		}
311 | 
312 | 		RigidBodyHandle handle = rigidbodyToHandle[rigidbody];
313 | 		RapierBindings.SetTransform(handle, position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w);
314 | 	}
315 | 
316 | 	public static void AddRelativeForce(Rigidbody rigidbody, Vector3 force)
317 | 	{
318 | 		throw new NotImplementedException("AddRelativeForce is not supported in Rapier4Unity. Use AddForce instead.");
319 | 	}
320 | 
321 | 	public static void AddRelativeForceWithMode(Rigidbody rigidbody, Vector3 force, ForceMode mode)
322 | 	{
323 | 		throw new NotImplementedException("AddRelativeForce is not supported in Rapier4Unity. Use AddForce instead.");
324 | 	}
325 | 
326 | 	public static void AddRelativeTorque(Rigidbody rigidbody, Vector3 torque)
327 | 	{
328 | 		throw new NotImplementedException("AddRelativeTorque is not supported in Rapier4Unity. Use AddTorque instead.");
329 | 	}
330 | 
331 | 	public static void AddRelativeTorqueWithMode(Rigidbody rigidbody, Vector3 torque, ForceMode mode)
332 | 	{
333 | 		throw new NotImplementedException("AddRelativeTorque is not supported in Rapier4Unity. Use AddTorque instead.");
334 | 	}
335 | 
336 | 	public struct LocalRaycastHit
337 | 	{
338 | 		internal Vector3 m_Point;
339 | 		internal Vector3 m_Normal;
340 | 		internal uint m_FaceID;
341 | 		internal float m_Distance;
342 | 		internal Vector2 m_UV;
343 | 		internal int m_Collider;
344 | 	}
345 | 
346 | 	public static bool Raycast(Ray ray, out RaycastHit hit)
347 | 	{
348 | 		bool did_hit = BindingExtensions.CastRay(ray.origin.x, ray.origin.y, ray.origin.z, ray.direction.x, ray.direction.y, ray.direction.z, out RapierRaycastHit rapierHit);
349 | 		if (!did_hit)
350 | 		{
351 | 			hit = new RaycastHit();
352 | 			return false;
353 | 		}
354 | 		LocalRaycastHit localHit = new LocalRaycastHit
355 | 		{
356 | 			m_Point = rapierHit.m_Point,
357 | 			m_Normal = rapierHit.m_Normal,
358 | 			m_FaceID = rapierHit.m_FaceID,
359 | 			m_Distance = rapierHit.m_Distance,
360 | 			m_UV = rapierHit.m_UV,
361 | 			m_Collider = handleToCollider[rapierHit.m_Collider].GetInstanceID()
362 | 		};
363 | 		hit = UnsafeUtility.As<LocalRaycastHit, RaycastHit>(ref localHit);
364 | 		return true;
365 | 	}
366 | 
367 | 
368 | 	// Called in the beginning of every frame, this ensures that all colliders and rigidbodies are initialized
369 | 	public static unsafe void Initialization()
370 | 	{
371 | 		if (!Application.isPlaying || !RapierBindings.IsAvailable)
372 | 			return;
373 | 
374 | 		// Find and add all colliders
375 | 		foreach (Collider collider in Object.FindObjectsByType<Collider>(FindObjectsSortMode.None))
376 | 		{
377 | 			AddCollider(collider);
378 | 		}
379 | 
380 | 		// Find and add all rigidbodies
381 | 		foreach (Rigidbody rigidbody in Object.FindObjectsByType<Rigidbody>(FindObjectsSortMode.None))
382 | 		{
383 | 			RigidBodyHandle handle = CreateOrGetRigidBodyHandle(rigidbody);
384 | 			UpdateRigidBody(rigidbody, handle);
385 | 		}
386 | 	}
387 | 
388 | 	private unsafe static void AddCollider(Collider collider)
389 | 	{
390 | 		// Add Rapier Collider if it doesn't exist
391 | 		if (!colliderToHandle.ContainsKey(collider))
392 | 		{
393 | 			Rigidbody potentialRigidbody = collider.GetComponent<Rigidbody>();
394 | 			Vector3 transformScale = collider.transform.localScale;
395 | 
396 | 			switch (collider)
397 | 			{
398 | 				case BoxCollider boxCollider:
399 | 					{
400 | 						ColliderHandle newColliderHandle = RapierBindings.AddCuboidCollider(
401 | 							transformScale.x * boxCollider.size.x / 2,
402 | 							transformScale.y * boxCollider.size.y / 2,
403 | 							transformScale.z * boxCollider.size.z / 2,
404 | 							potentialRigidbody == null ? 0 : potentialRigidbody.mass,
405 | 							boxCollider.isTrigger);
406 | 
407 | 						colliderToHandle[collider] = newColliderHandle;
408 | 						handleToCollider[newColliderHandle] = collider;
409 | 						break;
410 | 					}
411 | 				case SphereCollider sphereCollider:
412 | 					{
413 | 						ColliderHandle newColliderHandle = RapierBindings.AddSphereCollider(
414 | 							transformScale.x * sphereCollider.radius,
415 | 							potentialRigidbody == null ? 0 : potentialRigidbody.mass,
416 | 							sphereCollider.isTrigger);
417 | 						colliderToHandle[collider] = newColliderHandle;
418 | 						handleToCollider[newColliderHandle] = collider;
419 | 						break;
420 | 					}
421 | 				case CapsuleCollider capsuleCollider:
422 | 					{
423 | 						ColliderHandle newColliderHandle = RapierBindings.AddCapsuleCollider(
424 | 							transformScale.x * capsuleCollider.radius,
425 | 							transformScale.y * (capsuleCollider.height / 2) - (transformScale.x * capsuleCollider.radius),
426 | 							potentialRigidbody == null ? 0 : potentialRigidbody.mass,
427 | 							capsuleCollider.isTrigger);
428 | 						colliderToHandle[collider] = newColliderHandle;
429 | 						handleToCollider[newColliderHandle] = collider;
430 | 						break;
431 | 					}
432 | 				case MeshCollider meshCollider:
433 | 					{
434 | 						// Make sure we have a valid mesh
435 | 						Mesh mesh = meshCollider.sharedMesh;
436 | 						if (mesh == null)
437 | 						{
438 | 							Debug.LogError($"MeshCollider on {collider.gameObject.name} has no mesh assigned!");
439 | 							return;
440 | 						}
441 | 
442 | 						// Get vertex data
443 | 						Vector3[] vertices = mesh.vertices;
444 | 						Vector3 scale = collider.transform.localScale;
445 | 						NativeArray<float3> verticesFlat = new NativeArray<float3>(vertices.Length, Allocator.Temp);
446 | 
447 | 						// Apply local scale to vertices
448 | 						for (int i = 0; i < vertices.Length; i++)
449 | 							verticesFlat[i] = (float3)vertices[i] * scale;
450 | 
451 | 						ColliderHandle newColliderHandle;
452 | 
453 | 						if (meshCollider.convex)
454 | 						{
455 | 							// Use convex hull for convex meshes (better performance)
456 | 							newColliderHandle = RapierBindings.AddConvexMeshCollider(
457 | 								(float*)verticesFlat.GetUnsafeReadOnlyPtr(), (UIntPtr)vertices.Length,
458 | 								potentialRigidbody == null ? 0 : potentialRigidbody.mass,
459 | 								meshCollider.isTrigger);
460 | 						}
461 | 						else
462 | 						{
463 | 							// Use trimesh for concave meshes
464 | 							int[] triangles = mesh.triangles;
465 | 							var indicesFlat = new NativeArray<uint>(triangles.Length, Allocator.Temp);
466 | 							for (int i = 0; i < triangles.Length; i++)
467 | 								indicesFlat[i] = (uint)triangles[i];
468 | 
469 | 
470 | 							newColliderHandle = RapierBindings.AddMeshCollider(
471 | 								(float*)verticesFlat.GetUnsafeReadOnlyPtr(), (UIntPtr)vertices.Length,
472 | 								(uint*)indicesFlat.GetUnsafeReadOnlyPtr(), (UIntPtr)(triangles.Length / 3),
473 | 								potentialRigidbody == null ? 0 : potentialRigidbody.mass,
474 | 								meshCollider.isTrigger);
475 | 						}
476 | 
477 | 						colliderToHandle[collider] = newColliderHandle;
478 | 						handleToCollider[newColliderHandle] = collider;
479 | 						break;
480 | 					}
481 | 			}
482 | 
483 | 			// Add events for collider
484 | 			EventsForCollider eventsForCollider = new EventsForCollider();
485 | 
486 | 			eventsForCollider.onTriggerEnter = new List<BasicEvent<Collider>>();
487 | 			eventsForCollider.onTriggerExit = new List<BasicEvent<Collider>>();
488 | 			eventsForCollider.onTriggerStay = new List<BasicEvent<Collider>>();
489 | 
490 | 			eventsForCollider.onCollisionEnter = new List<BasicEvent<Collision>>();
491 | 			eventsForCollider.onCollisionExit = new List<BasicEvent<Collision>>();
492 | 			eventsForCollider.onCollisionStay = new List<BasicEvent<Collision>>();
493 | 
494 | 			MonoBehaviour[] components = collider.gameObject.GetComponents<MonoBehaviour>();
495 | 			foreach (MonoBehaviour component in components)
496 | 			{
497 | 				// Lookup events for MonoBehaviour, create if they don't exist
498 | 				if (!monoBehaviourEvents.TryGetValue(component, out EventsForMonoBehaviour eventsForMonoBehaviour))
499 | 				{
500 | 					eventsForMonoBehaviour.onTriggerEnter = new BasicEvent<Collider>(component, "OnTriggerEnter");
501 | 					eventsForMonoBehaviour.onTriggerExit = new BasicEvent<Collider>(component, "OnTriggerExit");
502 | 					eventsForMonoBehaviour.onTriggerStay = new BasicEvent<Collider>(component, "OnTriggerStay");
503 | 
504 | 					eventsForMonoBehaviour.onCollisionEnter = new BasicEvent<Collision>(component, "OnCollisionEnter");
505 | 					eventsForMonoBehaviour.onCollisionExit = new BasicEvent<Collision>(component, "OnCollisionExit");
506 | 					eventsForMonoBehaviour.onCollisionStay = new BasicEvent<Collision>(component, "OnCollisionStay");
507 | 
508 | 					monoBehaviourEvents[component] = eventsForMonoBehaviour;
509 | 				}
510 | 
511 | 				// Add events for collider
512 | 				if (eventsForMonoBehaviour.onTriggerEnter.IsValid)
513 | 					eventsForCollider.onTriggerEnter.Add(eventsForMonoBehaviour.onTriggerEnter);
514 | 				if (eventsForMonoBehaviour.onTriggerExit.IsValid)
515 | 					eventsForCollider.onTriggerExit.Add(eventsForMonoBehaviour.onTriggerExit);
516 | 				if (eventsForMonoBehaviour.onTriggerStay.IsValid)
517 | 					eventsForCollider.onTriggerStay.Add(eventsForMonoBehaviour.onTriggerStay);
518 | 
519 | 				if (eventsForMonoBehaviour.onCollisionEnter.IsValid)
520 | 					eventsForCollider.onCollisionEnter.Add(eventsForMonoBehaviour.onCollisionEnter);
521 | 				if (eventsForMonoBehaviour.onCollisionExit.IsValid)
522 | 					eventsForCollider.onCollisionExit.Add(eventsForMonoBehaviour.onCollisionExit);
523 | 				if (eventsForMonoBehaviour.onCollisionStay.IsValid)
524 | 					eventsForCollider.onCollisionStay.Add(eventsForMonoBehaviour.onCollisionStay);
525 | 			}
526 | 
527 | 			physicsEvents[collider] = eventsForCollider;
528 | 
529 | 			// In Unity if an object doesn't have a rigidbody, it's considered static
530 | 			// In Rapier, we need to add a fixed rigidbody, so we can simulate dynamic object interacting with static objects
531 | 			if (potentialRigidbody == null && colliderToHandle.TryGetValue(collider, out ColliderHandle colliderHandle))
532 | 			{
533 | 				fixedRigidbodies[collider] = RapierBindings.AddRigidBody(
534 | 					colliderHandle,
535 | 					RigidBodyType.Fixed,
536 | 					collider.transform.position.x,
537 | 					collider.transform.position.y,
538 | 					collider.transform.position.z,
539 | 					collider.transform.rotation.x,
540 | 					collider.transform.rotation.y,
541 | 					collider.transform.rotation.z,
542 | 					collider.transform.rotation.w);
543 | 			}
544 | 		}
545 | 	}
546 | 
547 | 	private static RigidBodyHandle CreateOrGetRigidBodyHandle(Rigidbody rigidbody, RigidBodyType type = RigidBodyType.Dynamic)
548 | 	{
549 | 		// Try to get the handle from the dictionary first
550 | 		if (rigidbodyToHandle.TryGetValue(rigidbody, out RigidBodyHandle handle))
551 | 		{
552 | 			return handle;
553 | 		}
554 | 
555 | 		// Handle doesn't exist, create a new one
556 | 		Collider[] colliders = rigidbody.GetComponents<Collider>();
557 | 		Assert.AreEqual(colliders.Length, 1, "Rigidbody must have exactly one collider for the moment");
558 | 
559 | 		// Try to add a collider in case we don't have one yet
560 | 		AddCollider(colliders[0]);
561 | 		ColliderHandle colliderHandle = colliderToHandle[colliders[0]];
562 | 		Transform trs = rigidbody.transform;
563 | 		RigidBodyHandle rigidBodyHandle = RapierBindings.AddRigidBody(
564 | 			colliderHandle,
565 | 			type,
566 | 			trs.position.x,
567 | 			trs.position.y,
568 | 			trs.position.z,
569 | 			trs.rotation.x,
570 | 			trs.rotation.y,
571 | 			trs.rotation.z,
572 | 			trs.rotation.w);
573 | 
574 | 		rigidbodyToHandle[rigidbody] = rigidBodyHandle;
575 | 		return rigidBodyHandle;
576 | 	}
577 | 
578 | 	private static void UpdateRigidBody(Rigidbody rigidbody, RigidBodyHandle handle)
579 | 	{
580 | 		// TODO Determine what other kinds of properties might need to update per frame. 
581 | 		RapierBindings.UpdateRigidBodyProperties(handle,
582 | 		rigidbody.isKinematic ? RigidBodyType.KinematicPositionBased : RigidBodyType.Dynamic,
583 | 		rigidbody.collisionDetectionMode == CollisionDetectionMode.Continuous,
584 | 		(uint)rigidbody.constraints,
585 | 		rigidbody.linearDamping,
586 | 		rigidbody.angularDamping);
587 | 	}
588 | 
589 | 	// Called at the end of the FixedUpdate loop
590 | 	// This is where we solve physics and get collision events
591 | 	// After that we update the GameObject positions of GameObjects with RigidBody component
592 | 	public static void FixedUpdate()
593 | 	{
594 | 		// Only run in play mode
595 | 		if (!Application.isPlaying || !RapierBindings.IsAvailable)
596 | 			return;
597 | 
598 | 		unsafe
599 | 		{
600 | 			// Solve physics and get collision events
601 | 			RawArray<CollisionEvent>* eventsPtrToArray = RapierBindings.Solve();
602 | 			if (eventsPtrToArray == null)
603 | 				return;
604 | 
605 | 			// Handle collision events
606 | 			for (int i = 0; i < eventsPtrToArray->length; i++)
607 | 			{
608 | 				CollisionEvent @event = (*eventsPtrToArray)[i];
609 | 				Collider collider1 = handleToCollider[@event.collider1];
610 | 				Collider collider2 = handleToCollider[@event.collider2];
611 | 				EventsForCollider eventsForCollider1 = physicsEvents[collider1];
612 | 				EventsForCollider eventsForCollider2 = physicsEvents[collider2];
613 | 				if (@event.is_started)
614 | 				{
615 | 					if (collider1.isTrigger || collider2.isTrigger)
616 | 					{
617 | 						foreach (BasicEvent<Collider> enter in eventsForCollider1.onTriggerEnter)
618 | 							enter.Invoke(collider2);
619 | 						foreach (BasicEvent<Collider> enter in eventsForCollider2.onTriggerEnter)
620 | 							enter.Invoke(collider1);
621 | 					}
622 | 
623 | 					activeTriggerPairs.Add((collider1, collider2));
624 | 				}
625 | 				else
626 | 				{
627 | 					if (collider1.isTrigger || collider2.isTrigger)
628 | 					{
629 | 						foreach (BasicEvent<Collider> exit in eventsForCollider1.onTriggerExit)
630 | 							exit.Invoke(collider2);
631 | 						foreach (BasicEvent<Collider> exit in eventsForCollider2.onTriggerExit)
632 | 							exit.Invoke(collider1);
633 | 					}
634 | 					activeTriggerPairs.Remove((collider1, collider2));
635 | 				}
636 | 			}
637 | 
638 | 			// Handle trigger stay
639 | 			foreach ((Collider, Collider) activeTriggerPair in activeTriggerPairs)
640 | 			{
641 | 				(Collider collider1, Collider collider2) = activeTriggerPair;
642 | 				EventsForCollider eventsForCollider1 = physicsEvents[collider1];
643 | 				EventsForCollider eventsForCollider2 = physicsEvents[collider2];
644 | 				if (collider1.isTrigger || collider2.isTrigger)
645 | 				{
646 | 					foreach (BasicEvent<Collider> stay in eventsForCollider1.onTriggerStay)
647 | 						stay.Invoke(collider2);
648 | 					foreach (BasicEvent<Collider> stay in eventsForCollider2.onTriggerStay)
649 | 						stay.Invoke(collider1);
650 | 				}
651 | 			}
652 | 			RapierBindings.FreeCollisionEvents(eventsPtrToArray);
653 | 		}
654 | 
655 | 		// Update GameObject positions of GameObjects with RigidBody component
656 | 		foreach (Rigidbody rigidbody in Object.FindObjectsByType<Rigidbody>(FindObjectsSortMode.None))
657 | 		{
658 | 			RigidBodyHandle handle = rigidbodyToHandle[rigidbody];
659 | 			RapierTransform position = RapierBindings.GetTransform(handle);
660 | 			rigidbody.transform.SetPositionAndRotation(position.position, position.rotation);
661 | 		}
662 | 
663 | 		// Update fixed rigidbodies
664 | 		foreach ((Collider collider, RigidBodyHandle rbhandle) in fixedRigidbodies)
665 | 		{
666 | 		}
667 | 	}
668 | }


--------------------------------------------------------------------------------
/Runtime/PhysicsEventWrapper.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 370ec36fea664f858657b26d8032779f
3 | timeCreated: 1741962393


--------------------------------------------------------------------------------
/Runtime/RapierBindings.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Runtime.InteropServices;
  3 | using Unity.Mathematics;
  4 | using UnityEngine;
  5 | 
  6 | namespace Packages.rapier4unity.Runtime
  7 | {
  8 | 	public struct RapierRaycastHit
  9 | 	{
 10 | 		internal Vector3 m_Point;
 11 | 		internal Vector3 m_Normal;
 12 | 		internal uint m_FaceID;
 13 | 		internal float m_Distance;
 14 | 		internal Vector2 m_UV;
 15 | 		internal ColliderHandle m_Collider;
 16 | 	}
 17 | 
 18 | 	internal static class BindingExtensions
 19 | 	{
 20 | 		public static bool CastRay(float from_x, float from_y, float from_z, float dir_x, float dir_y, float dir_z, out RapierRaycastHit hit)
 21 | 		{
 22 | 			unsafe
 23 | 			{
 24 | 				RapierRaycastHit* hitPtr = stackalloc RapierRaycastHit[1];
 25 | 				var did_hit = RapierBindings.CastRay(from_x, from_y, from_z, dir_x, dir_y, dir_z, hitPtr);
 26 | 				hit = *hitPtr;
 27 | 				return did_hit;
 28 | 			}
 29 | 		}
 30 | 	}
 31 | 
 32 | 	[StructLayout(LayoutKind.Sequential)]
 33 | 	public struct CollisionEvent
 34 | 	{
 35 | 		public ColliderHandle collider1;
 36 | 		public ColliderHandle collider2;
 37 | 		public bool is_started;
 38 | 	}
 39 | 
 40 | 	public struct RawArray<T> where T : unmanaged
 41 | 	{
 42 | 		public IntPtr data;
 43 | 		public int length;
 44 | 		public int capacity;
 45 | 
 46 | 		public T this[int index]
 47 | 		{
 48 | 			get
 49 | 			{
 50 | 				unsafe
 51 | 				{
 52 | 					if (index < 0 || index >= length)
 53 | 						throw new IndexOutOfRangeException($"Index {index} is out of range [0, {length})");
 54 | 					if ((T*)data == null)
 55 | 						throw new NullReferenceException("The array is not initialized");
 56 | 					return ((T*)data)[index];
 57 | 				}
 58 | 			}
 59 | 		}
 60 | 	}
 61 | 
 62 | 	public struct ColliderHandle
 63 | 	{
 64 | 		uint index;
 65 | 		uint generation;
 66 | 
 67 | 		public override string ToString() => $"Index: {index}, Generation: {generation}";
 68 | 	}
 69 | 
 70 | 	public struct RigidBodyHandle
 71 | 	{
 72 | 		uint index;
 73 | 		uint generation;
 74 | 
 75 | 		public override string ToString() => $"Index: {index}, Generation: {generation}";
 76 | 	}
 77 | 
 78 | 	public enum RigidBodyType
 79 | 	{
 80 | 		Dynamic = 0,
 81 | 		Fixed = 1,
 82 | 		KinematicPositionBased = 2,
 83 | 		KinematicVelocityBased = 3,
 84 | 	}
 85 | 
 86 | 	[StructLayout(LayoutKind.Sequential)]
 87 | 	public struct RapierTransform
 88 | 	{
 89 | 		public quaternion rotation;
 90 | 		public float3 position;
 91 | 
 92 | 		public override string ToString() => $"Rotation: {rotation}, Position: {position}";
 93 | 	}
 94 | 
 95 | 	public struct ImpulseJointHandle
 96 | 	{
 97 | 		public uint index;
 98 | 		public uint generation;
 99 | 
100 | 		public override string ToString() => $"Index: {index}, Generation: {generation}";
101 | 	}
102 | }


--------------------------------------------------------------------------------
/Runtime/RapierBindings.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 8540ece7808e45508c7db4b4e78d10d8
3 | timeCreated: 1741966105


--------------------------------------------------------------------------------
/Runtime/RapierBinds.cs:
--------------------------------------------------------------------------------
  1 | //#define DISABLE_DYNAMIC_RAPIER_LOAD
  2 | 
  3 | using System;
  4 | using System.IO;
  5 | using System.Runtime.InteropServices;
  6 | using Packages.rapier4unity.Runtime;
  7 | using Unity.Collections.LowLevel.Unsafe;
  8 | using Unity.Burst;
  9 | using UnityEngine;
 10 | using Unity.Mathematics;
 11 | 
 12 | #if UNITY_EDITOR && !DISABLE_DYNAMIC_RAPIER_LOAD
 13 | [UnityEditor.InitializeOnLoad]
 14 | #endif
 15 | 
 16 | [BurstCompile]
 17 | internal static unsafe class RapierBindings
 18 | {
 19 | 
 20 | #if !UNITY_EDITOR && (UNITY_IOS || UNITY_WEBGL)
 21 | 	private const string DllName = "__Internal";
 22 | #else
 23 | 	private const string DllName = "rapier_c_bind";
 24 | 
 25 | #if UNITY_EDITOR_OSX
 26 | 	const string k_DLLPath = "Packages/rapier4unity/build_bin/macOS/rapier_c_bind.bundle";
 27 | #else
 28 | 	const string k_DLLPath = "Packages/rapier4unity/build_bin/Windows/rapier_c_bind.dll";
 29 | #endif
 30 | #endif
 31 | 	private const CallingConvention Convention = CallingConvention.Cdecl;
 32 | #if UNITY_EDITOR && !DISABLE_DYNAMIC_RAPIER_LOAD
 33 | 	public static void Init(FunctionsToCallFromRust* funcs) => ((delegate* unmanaged[Cdecl]<FunctionsToCallFromRust*, void>) data.Data.init)(funcs);
 34 | 	public static void HelloWorld() => ((delegate* unmanaged[Cdecl]<void>) data.Data.helloWorld)();
 35 | 	public static void Teardown() => ((delegate* unmanaged[Cdecl]<void>) data.Data.teardown)();
 36 | 	public static RawArray<CollisionEvent>* Solve() => ((delegate* unmanaged[Cdecl]<RawArray<CollisionEvent>*>) data.Data.solve)();
 37 | 	public static void FreeCollisionEvents(RawArray<CollisionEvent>* ptr) => ((delegate* unmanaged[Cdecl]<RawArray<CollisionEvent>*, void>) data.Data.freeCollisionEvents)(ptr);
 38 | 	public static void SetGravity(float x, float y, float z) => ((delegate* unmanaged[Cdecl]<float, float, float, void>) data.Data.setGravity)(x, y, z);
 39 | 	public static void SetTimeStep(float dt) => ((delegate* unmanaged[Cdecl]<float, void>) data.Data.setTimeStep)(dt);
 40 | 	public static ColliderHandle AddCuboidCollider(float halfExtentsX, float halfExtentsY, float halfExtentsZ, float mass, bool isSensor) => ((delegate* unmanaged[Cdecl]<float, float, float, float, bool, ColliderHandle>) data.Data.addCuboidCollider)(halfExtentsX, halfExtentsY, halfExtentsZ, mass, isSensor);
 41 | 	public static ColliderHandle AddSphereCollider(float radius, float mass, bool isSensor) => ((delegate* unmanaged[Cdecl]<float, float, bool, ColliderHandle>) data.Data.addSphereCollider)(radius, mass, isSensor);
 42 | 	public static ColliderHandle AddCapsuleCollider(float halfHeight, float radius, float mass, bool isSensor) => ((delegate* unmanaged[Cdecl]<float, float, float, bool, ColliderHandle>) data.Data.addCapsuleCollider)(halfHeight, radius, mass, isSensor);
 43 | 	public static ColliderHandle AddMeshCollider(float* verticesPtr, UIntPtr verticesCount, uint* indicesPtr, UIntPtr indicesCount, float mass, bool isSensor) => ((delegate* unmanaged[Cdecl]<float*, UIntPtr, uint*, UIntPtr, float, bool, ColliderHandle>) data.Data.addMeshCollider)(verticesPtr, verticesCount, indicesPtr, indicesCount, mass, isSensor);
 44 | 	public static ColliderHandle AddConvexMeshCollider(float* verticesPtr, UIntPtr verticesCount, float mass, bool isSensor) => ((delegate* unmanaged[Cdecl]<float*, UIntPtr, float, bool, ColliderHandle>) data.Data.addConvexMeshCollider)(verticesPtr, verticesCount, mass, isSensor);
 45 | 	public static RigidBodyHandle AddRigidBody(ColliderHandle collider, RigidBodyType rbType, float positionX, float positionY, float positionZ, float rotationX, float rotationY, float rotationZ, float rotationW) => ((delegate* unmanaged[Cdecl]<ColliderHandle, RigidBodyType, float, float, float, float, float, float, float, RigidBodyHandle>) data.Data.addRigidBody)(collider, rbType, positionX, positionY, positionZ, rotationX, rotationY, rotationZ, rotationW);
 46 | 	public static void RemoveRigidBody(RigidBodyHandle rbHandle) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, void>) data.Data.removeRigidBody)(rbHandle);
 47 | 	public static void UpdateRigidBodyProperties(RigidBodyHandle rbHandle, RigidBodyType rbType, bool enableCcd, uint constraints, float linearDrag, float angularDrag) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, RigidBodyType, bool, uint, float, float, void>) data.Data.updateRigidBodyProperties)(rbHandle, rbType, enableCcd, constraints, linearDrag, angularDrag);
 48 | 	public static ImpulseJointHandle AddFixedJoint(RigidBodyHandle rb1Handle, RigidBodyHandle rb2Handle, float localFrame1X, float localFrame1Y, float localFrame1Z, float localFrame2X, float localFrame2Y, float localFrame2Z, bool selfCollision) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, RigidBodyHandle, float, float, float, float, float, float, bool, ImpulseJointHandle>) data.Data.addFixedJoint)(rb1Handle, rb2Handle, localFrame1X, localFrame1Y, localFrame1Z, localFrame2X, localFrame2Y, localFrame2Z, selfCollision);
 49 | 	public static ImpulseJointHandle AddSphericalJoint(RigidBodyHandle rb1Handle, RigidBodyHandle rb2Handle, float localFrame1X, float localFrame1Y, float localFrame1Z, float localFrame2X, float localFrame2Y, float localFrame2Z, bool selfCollision) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, RigidBodyHandle, float, float, float, float, float, float, bool, ImpulseJointHandle>) data.Data.addSphericalJoint)(rb1Handle, rb2Handle, localFrame1X, localFrame1Y, localFrame1Z, localFrame2X, localFrame2Y, localFrame2Z, selfCollision);
 50 | 	public static ImpulseJointHandle AddRevoluteJoint(RigidBodyHandle rb1Handle, RigidBodyHandle rb2Handle, float axisX, float axisY, float axisZ, float localFrame1X, float localFrame1Y, float localFrame1Z, float localFrame2X, float localFrame2Y, float localFrame2Z, bool selfCollision) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, RigidBodyHandle, float, float, float, float, float, float, float, float, float, bool, ImpulseJointHandle>) data.Data.addRevoluteJoint)(rb1Handle, rb2Handle, axisX, axisY, axisZ, localFrame1X, localFrame1Y, localFrame1Z, localFrame2X, localFrame2Y, localFrame2Z, selfCollision);
 51 | 	public static ImpulseJointHandle AddPrismaticJoint(RigidBodyHandle rb1Handle, RigidBodyHandle rb2Handle, float axisX, float axisY, float axisZ, float localFrame1X, float localFrame1Y, float localFrame1Z, float localFrame2X, float localFrame2Y, float localFrame2Z, float limitMin, float limitMax, bool selfCollision) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, RigidBodyHandle, float, float, float, float, float, float, float, float, float, float, float, bool, ImpulseJointHandle>) data.Data.addPrismaticJoint)(rb1Handle, rb2Handle, axisX, axisY, axisZ, localFrame1X, localFrame1Y, localFrame1Z, localFrame2X, localFrame2Y, localFrame2Z, limitMin, limitMax, selfCollision);
 52 | 	public static void RemoveJoint(ImpulseJointHandle handle) => ((delegate* unmanaged[Cdecl]<ImpulseJointHandle, void>) data.Data.removeJoint)(handle);
 53 | 	public static RapierTransform GetTransform(RigidBodyHandle rbHandle) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, RapierTransform>) data.Data.getTransform)(rbHandle);
 54 | 	public static void SetTransformPosition(RigidBodyHandle rbHandle, float positionX, float positionY, float positionZ) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float, float, float, void>) data.Data.setTransformPosition)(rbHandle, positionX, positionY, positionZ);
 55 | 	public static void SetTransformRotation(RigidBodyHandle rbHandle, float rotationX, float rotationY, float rotationZ, float rotationW) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float, float, float, float, void>) data.Data.setTransformRotation)(rbHandle, rotationX, rotationY, rotationZ, rotationW);
 56 | 	public static void SetTransform(RigidBodyHandle rbHandle, float positionX, float positionY, float positionZ, float rotationX, float rotationY, float rotationZ, float rotationW) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float, float, float, float, float, float, float, void>) data.Data.setTransform)(rbHandle, positionX, positionY, positionZ, rotationX, rotationY, rotationZ, rotationW);
 57 | 	public static void SetLinearVelocity(RigidBodyHandle rbHandle, float velocityX, float velocityY, float velocityZ) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float, float, float, void>) data.Data.setLinearVelocity)(rbHandle, velocityX, velocityY, velocityZ);
 58 | 	public static void SetAngularVelocity(RigidBodyHandle rbHandle, float velocityX, float velocityY, float velocityZ) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float, float, float, void>) data.Data.setAngularVelocity)(rbHandle, velocityX, velocityY, velocityZ);
 59 | 	public static float3 GetLinearVelocity(RigidBodyHandle rbHandle) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float3>) data.Data.getLinearVelocity)(rbHandle);
 60 | 	public static float3 GetAngularVelocity(RigidBodyHandle rbHandle) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float3>) data.Data.getAngularVelocity)(rbHandle);
 61 | 	public static void AddForce(RigidBodyHandle rbHandle, float forceX, float forceY, float forceZ, ForceMode mode) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float, float, float, ForceMode, void>) data.Data.addForce)(rbHandle, forceX, forceY, forceZ, mode);
 62 | 	public static void AddTorque(RigidBodyHandle rbHandle, float torqueX, float torqueY, float torqueZ, ForceMode mode) => ((delegate* unmanaged[Cdecl]<RigidBodyHandle, float, float, float, ForceMode, void>) data.Data.addTorque)(rbHandle, torqueX, torqueY, torqueZ, mode);
 63 | 	public static void SetIntegrationParameters(float dt, UIntPtr solverIterations, UIntPtr solverPgsIterations, UIntPtr solverAdditionalFrictionIterations, UIntPtr solverStabilizationIterations, UIntPtr ccdSubsteps, float contactDampingRatio, float jointDampingRatio, float contactFrequency, float jointFrequency, float predictionDistance, float maxCorrectiveVelocity, float lengthUnit) => ((delegate* unmanaged[Cdecl]<float, UIntPtr, UIntPtr, UIntPtr, UIntPtr, UIntPtr, float, float, float, float, float, float, float, void>) data.Data.setIntegrationParameters)(dt, solverIterations, solverPgsIterations, solverAdditionalFrictionIterations, solverStabilizationIterations, ccdSubsteps, contactDampingRatio, jointDampingRatio, contactFrequency, jointFrequency, predictionDistance, maxCorrectiveVelocity, lengthUnit);
 64 | 	public static bool CastRay(float fromX, float fromY, float fromZ, float dirX, float dirY, float dirZ, RapierRaycastHit* outHit) => ((delegate* unmanaged[Cdecl]<float, float, float, float, float, float, RapierRaycastHit*, bool>) data.Data.castRay)(fromX, fromY, fromZ, dirX, dirY, dirZ, outHit);
 65 | #else
 66 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="init")]
 67 | 	public static extern unsafe void Init(FunctionsToCallFromRust* funcs);
 68 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="hello_world")]
 69 | 	public static extern unsafe void HelloWorld();
 70 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="teardown")]
 71 | 	public static extern unsafe void Teardown();
 72 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="solve")]
 73 | 	public static extern unsafe RawArray<CollisionEvent>* Solve();
 74 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="free_collision_events")]
 75 | 	public static extern unsafe void FreeCollisionEvents(RawArray<CollisionEvent>* ptr);
 76 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="set_gravity")]
 77 | 	public static extern unsafe void SetGravity(float x, float y, float z);
 78 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="set_time_step")]
 79 | 	public static extern unsafe void SetTimeStep(float dt);
 80 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_cuboid_collider")]
 81 | 	public static extern unsafe ColliderHandle AddCuboidCollider(float halfExtentsX, float halfExtentsY, float halfExtentsZ, float mass, bool isSensor);
 82 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_sphere_collider")]
 83 | 	public static extern unsafe ColliderHandle AddSphereCollider(float radius, float mass, bool isSensor);
 84 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_capsule_collider")]
 85 | 	public static extern unsafe ColliderHandle AddCapsuleCollider(float halfHeight, float radius, float mass, bool isSensor);
 86 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_mesh_collider")]
 87 | 	public static extern unsafe ColliderHandle AddMeshCollider(float* verticesPtr, UIntPtr verticesCount, uint* indicesPtr, UIntPtr indicesCount, float mass, bool isSensor);
 88 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_convex_mesh_collider")]
 89 | 	public static extern unsafe ColliderHandle AddConvexMeshCollider(float* verticesPtr, UIntPtr verticesCount, float mass, bool isSensor);
 90 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_rigid_body")]
 91 | 	public static extern unsafe RigidBodyHandle AddRigidBody(ColliderHandle collider, RigidBodyType rbType, float positionX, float positionY, float positionZ, float rotationX, float rotationY, float rotationZ, float rotationW);
 92 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="remove_rigid_body")]
 93 | 	public static extern unsafe void RemoveRigidBody(RigidBodyHandle rbHandle);
 94 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="update_rigid_body_properties")]
 95 | 	public static extern unsafe void UpdateRigidBodyProperties(RigidBodyHandle rbHandle, RigidBodyType rbType, bool enableCcd, uint constraints, float linearDrag, float angularDrag);
 96 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_fixed_joint")]
 97 | 	public static extern unsafe ImpulseJointHandle AddFixedJoint(RigidBodyHandle rb1Handle, RigidBodyHandle rb2Handle, float localFrame1X, float localFrame1Y, float localFrame1Z, float localFrame2X, float localFrame2Y, float localFrame2Z, bool selfCollision);
 98 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_spherical_joint")]
 99 | 	public static extern unsafe ImpulseJointHandle AddSphericalJoint(RigidBodyHandle rb1Handle, RigidBodyHandle rb2Handle, float localFrame1X, float localFrame1Y, float localFrame1Z, float localFrame2X, float localFrame2Y, float localFrame2Z, bool selfCollision);
100 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_revolute_joint")]
101 | 	public static extern unsafe ImpulseJointHandle AddRevoluteJoint(RigidBodyHandle rb1Handle, RigidBodyHandle rb2Handle, float axisX, float axisY, float axisZ, float localFrame1X, float localFrame1Y, float localFrame1Z, float localFrame2X, float localFrame2Y, float localFrame2Z, bool selfCollision);
102 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_prismatic_joint")]
103 | 	public static extern unsafe ImpulseJointHandle AddPrismaticJoint(RigidBodyHandle rb1Handle, RigidBodyHandle rb2Handle, float axisX, float axisY, float axisZ, float localFrame1X, float localFrame1Y, float localFrame1Z, float localFrame2X, float localFrame2Y, float localFrame2Z, float limitMin, float limitMax, bool selfCollision);
104 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="remove_joint")]
105 | 	public static extern unsafe void RemoveJoint(ImpulseJointHandle handle);
106 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="get_transform")]
107 | 	public static extern unsafe RapierTransform GetTransform(RigidBodyHandle rbHandle);
108 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="set_transform_position")]
109 | 	public static extern unsafe void SetTransformPosition(RigidBodyHandle rbHandle, float positionX, float positionY, float positionZ);
110 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="set_transform_rotation")]
111 | 	public static extern unsafe void SetTransformRotation(RigidBodyHandle rbHandle, float rotationX, float rotationY, float rotationZ, float rotationW);
112 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="set_transform")]
113 | 	public static extern unsafe void SetTransform(RigidBodyHandle rbHandle, float positionX, float positionY, float positionZ, float rotationX, float rotationY, float rotationZ, float rotationW);
114 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="set_linear_velocity")]
115 | 	public static extern unsafe void SetLinearVelocity(RigidBodyHandle rbHandle, float velocityX, float velocityY, float velocityZ);
116 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="set_angular_velocity")]
117 | 	public static extern unsafe void SetAngularVelocity(RigidBodyHandle rbHandle, float velocityX, float velocityY, float velocityZ);
118 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="get_linear_velocity")]
119 | 	public static extern unsafe float3 GetLinearVelocity(RigidBodyHandle rbHandle);
120 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="get_angular_velocity")]
121 | 	public static extern unsafe float3 GetAngularVelocity(RigidBodyHandle rbHandle);
122 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_force")]
123 | 	public static extern unsafe void AddForce(RigidBodyHandle rbHandle, float forceX, float forceY, float forceZ, ForceMode mode);
124 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="add_torque")]
125 | 	public static extern unsafe void AddTorque(RigidBodyHandle rbHandle, float torqueX, float torqueY, float torqueZ, ForceMode mode);
126 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="set_integration_parameters")]
127 | 	public static extern unsafe void SetIntegrationParameters(float dt, UIntPtr solverIterations, UIntPtr solverPgsIterations, UIntPtr solverAdditionalFrictionIterations, UIntPtr solverStabilizationIterations, UIntPtr ccdSubsteps, float contactDampingRatio, float jointDampingRatio, float contactFrequency, float jointFrequency, float predictionDistance, float maxCorrectiveVelocity, float lengthUnit);
128 | 	[DllImport(DllName, CallingConvention = Convention, EntryPoint="cast_ray")]
129 | 	public static extern unsafe bool CastRay(float fromX, float fromY, float fromZ, float dirX, float dirY, float dirZ, RapierRaycastHit* outHit);
130 | #endif
131 | 
132 | #if UNITY_EDITOR && !DISABLE_DYNAMIC_RAPIER_LOAD
133 |     // C# -> Rust
134 |     [StructLayout(LayoutKind.Sequential, Size=sizeof(ulong) * 512)]
135 |     struct UnmanagedData
136 |     {
137 |         IntPtr loaded_lib;
138 |         public void load_calls()
139 |         {
140 |             if (loaded_lib==IntPtr.Zero)
141 |             {
142 |                 loaded_lib = NativeLoader.LoadLibrary(Path.GetFullPath(k_DLLPath));
143 |                 if (loaded_lib == IntPtr.Zero)
144 |                 {
145 |                     var errorMsg = NativeLoader.GetLastErrorString();
146 |                     Console.WriteLine($"Failed to load library: {errorMsg}");
147 |                     return;
148 |                 }
149 |             }
150 | 
151 |             // Load function pointers
152 |             init = NativeLoader.GetFunction(loaded_lib, "init");
153 | 			helloWorld = NativeLoader.GetFunction(loaded_lib, "hello_world");
154 | 			teardown = NativeLoader.GetFunction(loaded_lib, "teardown");
155 | 			solve = NativeLoader.GetFunction(loaded_lib, "solve");
156 | 			freeCollisionEvents = NativeLoader.GetFunction(loaded_lib, "free_collision_events");
157 | 			setGravity = NativeLoader.GetFunction(loaded_lib, "set_gravity");
158 | 			setTimeStep = NativeLoader.GetFunction(loaded_lib, "set_time_step");
159 | 			addCuboidCollider = NativeLoader.GetFunction(loaded_lib, "add_cuboid_collider");
160 | 			addSphereCollider = NativeLoader.GetFunction(loaded_lib, "add_sphere_collider");
161 | 			addCapsuleCollider = NativeLoader.GetFunction(loaded_lib, "add_capsule_collider");
162 | 			addMeshCollider = NativeLoader.GetFunction(loaded_lib, "add_mesh_collider");
163 | 			addConvexMeshCollider = NativeLoader.GetFunction(loaded_lib, "add_convex_mesh_collider");
164 | 			addRigidBody = NativeLoader.GetFunction(loaded_lib, "add_rigid_body");
165 | 			removeRigidBody = NativeLoader.GetFunction(loaded_lib, "remove_rigid_body");
166 | 			updateRigidBodyProperties = NativeLoader.GetFunction(loaded_lib, "update_rigid_body_properties");
167 | 			addFixedJoint = NativeLoader.GetFunction(loaded_lib, "add_fixed_joint");
168 | 			addSphericalJoint = NativeLoader.GetFunction(loaded_lib, "add_spherical_joint");
169 | 			addRevoluteJoint = NativeLoader.GetFunction(loaded_lib, "add_revolute_joint");
170 | 			addPrismaticJoint = NativeLoader.GetFunction(loaded_lib, "add_prismatic_joint");
171 | 			removeJoint = NativeLoader.GetFunction(loaded_lib, "remove_joint");
172 | 			getTransform = NativeLoader.GetFunction(loaded_lib, "get_transform");
173 | 			setTransformPosition = NativeLoader.GetFunction(loaded_lib, "set_transform_position");
174 | 			setTransformRotation = NativeLoader.GetFunction(loaded_lib, "set_transform_rotation");
175 | 			setTransform = NativeLoader.GetFunction(loaded_lib, "set_transform");
176 | 			setLinearVelocity = NativeLoader.GetFunction(loaded_lib, "set_linear_velocity");
177 | 			setAngularVelocity = NativeLoader.GetFunction(loaded_lib, "set_angular_velocity");
178 | 			getLinearVelocity = NativeLoader.GetFunction(loaded_lib, "get_linear_velocity");
179 | 			getAngularVelocity = NativeLoader.GetFunction(loaded_lib, "get_angular_velocity");
180 | 			addForce = NativeLoader.GetFunction(loaded_lib, "add_force");
181 | 			addTorque = NativeLoader.GetFunction(loaded_lib, "add_torque");
182 | 			setIntegrationParameters = NativeLoader.GetFunction(loaded_lib, "set_integration_parameters");
183 | 			castRay = NativeLoader.GetFunction(loaded_lib, "cast_ray");
184 |         }
185 | 
186 |         // Raw function pointers
187 |         public IntPtr init;
188 | 		public IntPtr helloWorld;
189 | 		public IntPtr teardown;
190 | 		public IntPtr solve;
191 | 		public IntPtr freeCollisionEvents;
192 | 		public IntPtr setGravity;
193 | 		public IntPtr setTimeStep;
194 | 		public IntPtr addCuboidCollider;
195 | 		public IntPtr addSphereCollider;
196 | 		public IntPtr addCapsuleCollider;
197 | 		public IntPtr addMeshCollider;
198 | 		public IntPtr addConvexMeshCollider;
199 | 		public IntPtr addRigidBody;
200 | 		public IntPtr removeRigidBody;
201 | 		public IntPtr updateRigidBodyProperties;
202 | 		public IntPtr addFixedJoint;
203 | 		public IntPtr addSphericalJoint;
204 | 		public IntPtr addRevoluteJoint;
205 | 		public IntPtr addPrismaticJoint;
206 | 		public IntPtr removeJoint;
207 | 		public IntPtr getTransform;
208 | 		public IntPtr setTransformPosition;
209 | 		public IntPtr setTransformRotation;
210 | 		public IntPtr setTransform;
211 | 		public IntPtr setLinearVelocity;
212 | 		public IntPtr setAngularVelocity;
213 | 		public IntPtr getLinearVelocity;
214 | 		public IntPtr getAngularVelocity;
215 | 		public IntPtr addForce;
216 | 		public IntPtr addTorque;
217 | 		public IntPtr setIntegrationParameters;
218 | 		public IntPtr castRay;
219 | 
220 |         // Rust -> C# data
221 |         public FunctionsToCallFromRust functionsToCallFromRust;
222 | 
223 |         public void unload_calls()
224 |         {
225 |             if (loaded_lib != IntPtr.Zero)
226 |                 NativeLoader.FreeLibrary(loaded_lib);
227 |             loaded_lib = IntPtr.Zero;
228 |             Debug.Log($"RapierBindingCalls Unloaded");
229 |         }
230 |         public bool IsLoaded => loaded_lib != IntPtr.Zero;
231 |     }
232 |     public static bool IsAvailable => data.Data.IsLoaded;
233 |     public static void LoadCalls()
234 |     {
235 |         data.Data.load_calls();
236 |         init_rapier4unity();
237 |         Debug.Log($"RapierBindingCalls Loaded");
238 |     }
239 | 
240 |     [BurstCompile]
241 |     static void init_rapier4unity(){
242 |         data.Data.functionsToCallFromRust.Init();
243 |         Init((FunctionsToCallFromRust*)UnsafeUtility.AddressOf(ref data.Data.functionsToCallFromRust));
244 |     }
245 | 
246 |     public static void UnloadCalls() => data.Data.unload_calls();
247 | 
248 |     struct SpecialKey {}
249 |     static readonly SharedStatic<UnmanagedData> data = SharedStatic<UnmanagedData>.GetOrCreate<SpecialKey>();
250 | #else
251 |     // No dynamic loading, empty functions
252 |     public static bool IsAvailable => true;
253 |     public static void LoadCalls(){}
254 |     public static void UnloadCalls(){}
255 | 
256 |     // Called during InitializeOnLoad
257 | 	static RapierBindings()
258 | 	{
259 | 		var functionsToCallFromRust = new FunctionsToCallFromRust();
260 | 		functionsToCallFromRust.Init();
261 | 		Init(&functionsToCallFromRust);
262 | 	}
263 | #endif
264 | 
265 |     // Rust -> C#
266 |     [BurstCompile]
267 |     [StructLayout(LayoutKind.Sequential)]
268 |     public struct FunctionsToCallFromRust {
269 |         public IntPtr unityLogPtr;
270 | 
271 |         public void Init()
272 |         {
273 |             unityLogPtr = UnityRapierBridge.GetDefaultUnityLogger();
274 |         }
275 |     }
276 | 
277 | }
278 | 


--------------------------------------------------------------------------------
/Runtime/RapierBinds.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: b044ee038e724944b8e50f02b12af196


--------------------------------------------------------------------------------
/Unity.Rapier4Unity.CodeGen.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: e258f164cea9490c895ca75b54be7518
3 | timeCreated: 1742067993


--------------------------------------------------------------------------------
/Unity.Rapier4Unity.CodeGen/ILPPHelpers.cs:
--------------------------------------------------------------------------------
  1 | /// THIS CODE IS ORIGINALLY FROM COM.UNITY.ENTITIES AND THEREFOR SHOULD ALWAYS BE SHIPPED WITH A VALID UNITY LICENSE
  2 | 
  3 | using System;
  4 | using System.Collections.Generic;
  5 | using System.IO;
  6 | using System.Linq;
  7 | using System.Reflection;
  8 | using System.Threading;
  9 | using Mono.Cecil;
 10 | using Mono.Cecil.Cil;
 11 | using Unity.CompilationPipeline.Common.ILPostProcessing;
 12 | 
 13 | namespace Unity.Rapier4Unity.CodeGen
 14 | {
 15 |     public static class ILPPHelpers
 16 |     {
 17 |         internal static AssemblyDefinition GetAssemblyDefinition(this ICompiledAssembly compiledAssembly)
 18 |         {
 19 |             var resolver = new PostProcessorAssemblyResolver(compiledAssembly);
 20 |             var readerParameters = new ReaderParameters
 21 |             {
 22 |                 SymbolStream = new MemoryStream(compiledAssembly.InMemoryAssembly.PdbData.ToArray()),
 23 |                 SymbolReaderProvider = new PortablePdbReaderProvider(),
 24 |                 AssemblyResolver = resolver,
 25 |                 ReflectionImporterProvider = new PostProcessorReflectionImporterProvider(),
 26 |                 ReadingMode = ReadingMode.Immediate
 27 |             };
 28 | 
 29 |             var peStream = new MemoryStream(compiledAssembly.InMemoryAssembly.PeData.ToArray());
 30 |             var assemblyDefinition = AssemblyDefinition.ReadAssembly(peStream, readerParameters);
 31 | 
 32 |             //apparently, it will happen that when we ask to resolve a type that lives inside Unity.Entities, and we
 33 |             //are also postprocessing Unity.Entities, type resolving will fail, because we do not actually try to resolve
 34 |             //inside the assembly we are processing. Let's make sure we do that, so that we can use postprocessor features inside
 35 |             //unity.entities itself as well.
 36 |             resolver.AddAssemblyDefinitionBeingOperatedOn(assemblyDefinition);
 37 | 
 38 |             return assemblyDefinition;
 39 |         }
 40 |     }
 41 |     
 42 |     class PostProcessorAssemblyResolver : Mono.Cecil.IAssemblyResolver
 43 |         {
 44 |             private readonly string[] _referenceDirectories;
 45 |             private Dictionary<string, HashSet<string>> _referenceToPathMap;
 46 |             Dictionary<string, AssemblyDefinition> _cache = new Dictionary<string, AssemblyDefinition>();
 47 |             private ICompiledAssembly _compiledAssembly;
 48 |             private AssemblyDefinition _selfAssembly;
 49 | 
 50 |             public PostProcessorAssemblyResolver(ICompiledAssembly compiledAssembly)
 51 |             {
 52 |                 _compiledAssembly = compiledAssembly;
 53 |                 _referenceToPathMap = new Dictionary<string, HashSet<string>>();
 54 |                 foreach (var reference in compiledAssembly.References)
 55 |                 {
 56 |                     var assemblyName = Path.GetFileNameWithoutExtension(reference);
 57 |                     if (!_referenceToPathMap.TryGetValue(assemblyName, out var fileList))
 58 |                     {
 59 |                         fileList = new HashSet<string>();
 60 |                         _referenceToPathMap.Add(assemblyName, fileList);
 61 |                     }
 62 |                     fileList.Add(reference);
 63 |                 }
 64 | 
 65 |                 _referenceDirectories = _referenceToPathMap.Values.SelectMany(pathSet => pathSet.Select(Path.GetDirectoryName)).Distinct().ToArray();
 66 |             }
 67 | 
 68 |             public void Dispose()
 69 |             {
 70 |             }
 71 | 
 72 |             public AssemblyDefinition Resolve(AssemblyNameReference name)
 73 |             {
 74 |                 return Resolve(name, new ReaderParameters(ReadingMode.Deferred));
 75 |             }
 76 | 
 77 |             public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
 78 |             {
 79 |                 {
 80 |                     if (name.Name == _compiledAssembly.Name)
 81 |                         return _selfAssembly;
 82 | 
 83 |                     var fileName = FindFile(name);
 84 |                     if (fileName == null)
 85 |                         return null;
 86 | 
 87 |                     var cacheKey = fileName;
 88 | 
 89 |                     if (_cache.TryGetValue(cacheKey, out var result))
 90 |                         return result;
 91 | 
 92 |                     parameters.AssemblyResolver = this;
 93 | 
 94 |                     var ms = MemoryStreamFor(fileName);
 95 | 
 96 |                     var pdb = fileName + ".pdb";
 97 |                     if (File.Exists(pdb))
 98 |                         parameters.SymbolStream = MemoryStreamFor(pdb);
 99 | 
100 |                     var assemblyDefinition = AssemblyDefinition.ReadAssembly(ms, parameters);
101 |                     _cache.Add(cacheKey, assemblyDefinition);
102 |                     return assemblyDefinition;
103 |                 }
104 |             }
105 | 
106 |             private string FindFile(AssemblyNameReference name)
107 |             {
108 |                 if (_referenceToPathMap.TryGetValue(name.Name, out var paths))
109 |                 {
110 |                     if (paths.Count == 1)
111 |                         return paths.First();
112 | 
113 |                     // If we have more than one assembly with the same name loaded we now need to figure out which one
114 |                     // is being requested based on the AssemblyNameReference
115 |                     foreach (var path in paths)
116 |                     {
117 |                         var onDiskAssemblyName = AssemblyName.GetAssemblyName(path);
118 |                         if (onDiskAssemblyName.FullName == name.FullName)
119 |                             return path;
120 |                     }
121 |                     throw new ArgumentException($"Tried to resolve a reference in assembly '{name.FullName}' however the assembly could not be found. Known references which did not match: \n{string.Join("\n", paths)}");
122 |                 }
123 | 
124 |                 // Unfortunately the current ICompiledAssembly API only provides direct references.
125 |                 // It is very much possible that a postprocessor ends up investigating a type in a directly
126 |                 // referenced assembly, that contains a field that is not in a directly referenced assembly.
127 |                 // if we don't do anything special for that situation, it will fail to resolve.  We should fix this
128 |                 // in the ILPostProcessing api. As a workaround, we rely on the fact here that the indirect references
129 |                 // are always located next to direct references, so we search in all directories of direct references we
130 |                 // got passed, and if we find the file in there, we resolve to it.
131 |                 foreach (var parentDir in _referenceDirectories)
132 |                 {
133 |                     var candidate = Path.Combine(parentDir, name.Name + ".dll");
134 |                     if (File.Exists(candidate))
135 |                     {
136 |                         if (!_referenceToPathMap.TryGetValue(candidate, out var referencePaths))
137 |                         {
138 |                             referencePaths = new HashSet<string>();
139 |                             _referenceToPathMap.Add(candidate, referencePaths);
140 |                         }
141 |                         referencePaths.Add(candidate);
142 | 
143 |                         return candidate;
144 |                     }
145 |                 }
146 | 
147 |                 return null;
148 |             }
149 | 
150 |             static MemoryStream MemoryStreamFor(string fileName)
151 |             {
152 |                 return Retry(10, TimeSpan.FromSeconds(1), () => {
153 |                     byte[] byteArray;
154 |                     using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
155 |                     {
156 |                         byteArray = new byte[fs.Length];
157 |                         var readLength = fs.Read(byteArray, 0, (int)fs.Length);
158 |                         if (readLength != fs.Length)
159 |                             throw new InvalidOperationException("File read length is not full length of file.");
160 |                     }
161 | 
162 |                     return new MemoryStream(byteArray);
163 |                 });
164 |             }
165 | 
166 |             private static MemoryStream Retry(int retryCount, TimeSpan waitTime, Func<MemoryStream> func)
167 |             {
168 |                 try
169 |                 {
170 |                     return func();
171 |                 }
172 |                 catch (IOException)
173 |                 {
174 |                     if (retryCount == 0)
175 |                         throw;
176 |                     Console.WriteLine($"Caught IO Exception, trying {retryCount} more times");
177 |                     Thread.Sleep(waitTime);
178 |                     return Retry(retryCount - 1, waitTime, func);
179 |                 }
180 |             }
181 | 
182 |             public void AddAssemblyDefinitionBeingOperatedOn(AssemblyDefinition assemblyDefinition)
183 |             {
184 |                 _selfAssembly = assemblyDefinition;
185 | 
186 |             }
187 |         }
188 |     internal class PostProcessorReflectionImporterProvider : IReflectionImporterProvider
189 |     {
190 |         public IReflectionImporter GetReflectionImporter(ModuleDefinition module)
191 |         {
192 |             return new PostProcessorReflectionImporter(module);
193 |         }
194 |     }
195 |     
196 |     internal class PostProcessorReflectionImporter : DefaultReflectionImporter
197 |     {
198 |         private const string SystemPrivateCoreLib = "System.Private.CoreLib";
199 |         private AssemblyNameReference _correctCorlib;
200 | 
201 |         public PostProcessorReflectionImporter(ModuleDefinition module) : base(module)
202 |         {
203 |             _correctCorlib = module.AssemblyReferences.FirstOrDefault(a => a.Name == "mscorlib" || a.Name == "netstandard" || a.Name == SystemPrivateCoreLib);
204 |         }
205 | 
206 |         public override AssemblyNameReference ImportReference(AssemblyName reference)
207 |         {
208 |             if (_correctCorlib != null && reference.Name == SystemPrivateCoreLib)
209 |                 return _correctCorlib;
210 | 
211 |             return base.ImportReference(reference);
212 |         }
213 |     }
214 | }
215 | 


--------------------------------------------------------------------------------
/Unity.Rapier4Unity.CodeGen/ILPPHelpers.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 1962120e330944cb8d979c00cc577b55
3 | timeCreated: 1742076290


--------------------------------------------------------------------------------
/Unity.Rapier4Unity.CodeGen/PhysicsPostProcessor.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.IO;
  5 | using System.Linq;
  6 | using System.Reflection;
  7 | using Mono.Cecil;
  8 | using Mono.Cecil.Cil;
  9 | using Unity.CompilationPipeline.Common.ILPostProcessing;
 10 | using Unity.Rapier4Unity.CodeGen;
 11 | 
 12 | public class Patch : ILPostProcessor
 13 | {
 14 |     [Conditional("DEBUG")]
 15 |     public static void OutputDebugString(string message)
 16 |     {
 17 |         //File.AppendAllTextAsync("./Temp/rapier4unity.log", message + "\n");
 18 |     }
 19 |     public override ILPostProcessor GetInstance() => new Patch();
 20 | 
 21 |     public override bool WillProcess(ICompiledAssembly compiledAssembly)
 22 |     {
 23 |         string name = compiledAssembly.Name;
 24 |         if (name.StartsWith("Unity.") || name.StartsWith("UnityEngine.") || name.StartsWith("UnityEditor."))
 25 |             return false;
 26 | 
 27 |         OutputDebugString($"{compiledAssembly.Name}: WillProcess");
 28 |         return true;
 29 |     }
 30 | 
 31 |     public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
 32 |     {
 33 |         OutputDebugString($"{compiledAssembly.Name}: Start patching...");
 34 | 
 35 |         var msgs = new System.Collections.Generic.List<Unity.CompilationPipeline.Common.Diagnostics.DiagnosticMessage>();
 36 | 
 37 |         try
 38 |         {
 39 |             var assembly = compiledAssembly.GetAssemblyDefinition();
 40 |             var rpcProcessor = new PhysicsPostProcessor(assembly.MainModule);
 41 |             var anythingChanged = rpcProcessor.Process(assembly.MainModule);
 42 |             if (!anythingChanged)
 43 |             {
 44 |                 OutputDebugString($"{compiledAssembly.Name}: NOTHING CHANGED");
 45 |                 return new ILPostProcessResult(compiledAssembly.InMemoryAssembly);
 46 |             }
 47 | 
 48 |             var pe = new MemoryStream();
 49 |             var pdb = new MemoryStream();
 50 |             var writerParameters = new WriterParameters
 51 |             {
 52 |                 SymbolWriterProvider = new PortablePdbWriterProvider(),
 53 |                 SymbolStream = pdb,
 54 |                 WriteSymbols = true
 55 |             };
 56 | 
 57 |             assembly.Write(pe, writerParameters);
 58 |             return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), msgs);
 59 |         }
 60 |         catch (System.Exception e)
 61 |         {
 62 |             var msg = new Unity.CompilationPipeline.Common.Diagnostics.DiagnosticMessage();
 63 |             msg.DiagnosticType = Unity.CompilationPipeline.Common.Diagnostics.DiagnosticType.Error;
 64 |             msg.MessageData = e.Message;
 65 |             msgs.Add(msg);
 66 | 
 67 |             OutputDebugString($"{compiledAssembly.Name}: FAILED {e.Message}");
 68 |             return new ILPostProcessResult(null, msgs);
 69 |         }
 70 |     }
 71 | }
 72 | 
 73 | public class PhysicsPostProcessor
 74 | {
 75 |     ModuleDefinition m_AssemblyMainModule;
 76 |     Type m_Rapier = typeof(RapierLoop);
 77 |     BindingFlags m_DefaultBindingFlags = BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public;
 78 | 
 79 |     // Rigidbody replacements
 80 |     readonly Dictionary<(string MethodName, int ParameterCount), string> m_RigidbodyReplacements = new()
 81 |     {
 82 |         { ("AddForce", 1), "AddForce" },
 83 |         { ("AddForce", 2), "AddForceWithMode" },
 84 |         { ("AddTorque", 1), "AddTorque" },
 85 |         { ("AddTorque", 2), "AddTorqueWithMode" },
 86 |         { ("AddRelativeTorque", 1), "AddRelativeTorque" },
 87 |         { ("AddRelativeTorque", 2), "AddRelativeTorqueWithMode" },
 88 |         { ("AddRelativeForce", 1), "AddRelativeForce" },
 89 |         { ("AddRelativeForce", 2), "AddRelativeForceWithMode" },
 90 |         { ("MovePosition", 1), "MovePosition" },
 91 |         { ("MoveRotation", 1), "MoveRotation" },
 92 |         { ("Move", 2), "Move" },
 93 |     };
 94 | 
 95 |     // Physics replacements
 96 |     readonly Dictionary<(string MethodName, int ParameterCount), string> m_PhysicsReplacements = new()
 97 |     {
 98 |         { ("Raycast", 2), "Raycast" },
 99 |     };
100 | 
101 | 
102 |     public PhysicsPostProcessor(ModuleDefinition assemblyMainModule)
103 |     {
104 |         m_AssemblyMainModule = assemblyMainModule;
105 |     }
106 | 
107 |     // Replaces Calls to Physics Apis with Rapier Physics Apis
108 |     public bool Process(ModuleDefinition assemblyMainModule)
109 |     {
110 |         bool anythingChanged = false;
111 | 
112 |         foreach (var type in assemblyMainModule.Types)
113 |         {
114 |             foreach (var method in type.Methods)
115 |             {
116 |                 if (!method.HasBody)
117 |                     continue;
118 | 
119 |                 var instructions = method.Body.Instructions;
120 |                 for (int i = 0; i < instructions.Count; i++)
121 |                 {
122 |                     var instruction = instructions[i];
123 | 
124 |                     if (instruction.OpCode == OpCodes.Callvirt)
125 |                     {
126 |                         if (instruction.Operand is not MethodReference methodReference)
127 |                             continue;
128 | 
129 |                         if (methodReference.DeclaringType.FullName == "UnityEngine.Rigidbody")
130 |                         {
131 |                             var methodName = methodReference.Name;
132 |                             var paramCount = methodReference.Parameters.Count;
133 | 
134 |                             if (m_RigidbodyReplacements.TryGetValue((methodName, paramCount), out var replacementMethod))
135 |                             {
136 |                                 InjectFunction(replacementMethod, ref instruction);
137 |                                 anythingChanged = true;
138 |                             }
139 |                         }
140 |                     }
141 |                     else if (instruction.OpCode == OpCodes.Call)
142 |                     {
143 |                         if (instruction.Operand is not MethodReference methodReference)
144 |                             continue;
145 | 
146 |                         if (methodReference.DeclaringType.FullName == "UnityEngine.Physics")
147 |                         {
148 |                             if (m_PhysicsReplacements.TryGetValue((methodReference.Name, methodReference.Parameters.Count), out var replacementMethod))
149 |                             {
150 |                                 InjectFunction(replacementMethod, ref instruction);
151 |                                 anythingChanged = true;
152 |                             }
153 |                         }
154 |                     }
155 |                 }
156 |             }
157 |         }
158 | 
159 |         return anythingChanged;
160 |     }
161 | 
162 |     private void InjectFunction(string functionToInjectName, ref Instruction instruction)
163 |     {
164 |         var method = m_Rapier.GetMethod(functionToInjectName, m_DefaultBindingFlags);
165 |         var newMethodReference = m_AssemblyMainModule.ImportReference(method);
166 |         instruction.Operand = newMethodReference;
167 |         instruction.OpCode = OpCodes.Call;
168 |         Patch.OutputDebugString($"Method: {GetMethodSignature((MethodReference)instruction.Operand)} -> {GetMethodSignature(newMethodReference)}");
169 |     }
170 | 
171 |     public static string GetMethodSignature(MethodReference methodReference)
172 |         => $"{methodReference.DeclaringType.FullName}.{methodReference.Name}({string.Join(", ", methodReference.Parameters.Select(p => p.ParameterType.FullName))})";
173 | }


--------------------------------------------------------------------------------
/Unity.Rapier4Unity.CodeGen/PhysicsPostProcessor.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 69231cb55db04c3d82569e8727c66a3a
3 | timeCreated: 1742069110


--------------------------------------------------------------------------------
/Unity.Rapier4Unity.CodeGen/Unity.Rapier4Unity.CodeGen.asmdef:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "Unity.Rapier4Unity.CodeGen",
 3 |     "rootNamespace": "",
 4 |     "references": [
 5 |         "Runtime"
 6 |     ],
 7 |     "includePlatforms": [
 8 |         "Editor"
 9 |     ],
10 |     "excludePlatforms": [],
11 |     "allowUnsafeCode": true,
12 |     "overrideReferences": true,
13 |     "precompiledReferences": [
14 |         "Mono.Cecil.dll",
15 |         "Mono.Cecil.Rocks.dll",
16 |         "Mono.Cecil.Pdb.dll",
17 |         "Mono.Cecil.Mdb.dll"
18 |     ],
19 |     "autoReferenced": false,
20 |     "defineConstraints": [],
21 |     "versionDefines": [],
22 |     "noEngineReferences": false
23 | }


--------------------------------------------------------------------------------
/Unity.Rapier4Unity.CodeGen/Unity.Rapier4Unity.CodeGen.asmdef.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: be7639e0699b42c780a659944e8a82b5
3 | timeCreated: 1742067993


--------------------------------------------------------------------------------
/build_bin.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 66b6e32412cf44696838fe46526bf3f3
3 | folderAsset: yes
4 | DefaultImporter:
5 |   externalObjects: {}
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/build_bin/Android.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 0d0d46c19b71a44a5b80bebaaf179d0b
3 | folderAsset: yes
4 | DefaultImporter:
5 |   externalObjects: {}
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/build_bin/Android/librapier_c_bind.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/Android/librapier_c_bind.so


--------------------------------------------------------------------------------
/build_bin/Android/librapier_c_bind.so.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 28a325f2ee97e4c98a8ced036258ba4e


--------------------------------------------------------------------------------
/build_bin/Android/libunitybridge.so:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/Android/libunitybridge.so


--------------------------------------------------------------------------------
/build_bin/Android/libunitybridge.so.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 0f9fd5a12d4784e1f9c4346f6a36808f


--------------------------------------------------------------------------------
/build_bin/Windows.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 080c21644a7c045ee82c232669ed737b
3 | folderAsset: yes
4 | DefaultImporter:
5 |   externalObjects: {}
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/build_bin/Windows/rapier_c_bind.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/Windows/rapier_c_bind.dll


--------------------------------------------------------------------------------
/build_bin/Windows/rapier_c_bind.dll.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: c6b422db3648648db964adac5ac6598d


--------------------------------------------------------------------------------
/build_bin/Windows/rapier_c_bind.pdb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/Windows/rapier_c_bind.pdb


--------------------------------------------------------------------------------
/build_bin/Windows/rapier_c_bind.pdb.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 9fe4717bf95c64403b9ebd840a33599a
3 | DefaultImporter:
4 |   externalObjects: {}
5 |   userData: 
6 |   assetBundleName: 
7 |   assetBundleVariant: 
8 | 


--------------------------------------------------------------------------------
/build_bin/Windows/unitybridge.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/Windows/unitybridge.dll


--------------------------------------------------------------------------------
/build_bin/Windows/unitybridge.dll.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 7439f3733c37f4b3fa2e74a85083a160


--------------------------------------------------------------------------------
/build_bin/Windows/unitybridge.pdb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/Windows/unitybridge.pdb


--------------------------------------------------------------------------------
/build_bin/Windows/unitybridge.pdb.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: d03cebb1928a447b0a9d63e2c81297b3
3 | DefaultImporter:
4 |   externalObjects: {}
5 |   userData: 
6 |   assetBundleName: 
7 |   assetBundleVariant: 
8 | 


--------------------------------------------------------------------------------
/build_bin/iOS.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 0bc9ee4dfb8ac46bdad17dd859eba36b
3 | folderAsset: yes
4 | DefaultImporter:
5 |   externalObjects: {}
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/build_bin/iOS/librapier_c_bind.a:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/iOS/librapier_c_bind.a


--------------------------------------------------------------------------------
/build_bin/iOS/librapier_c_bind.a.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: c911ae55986b941f1a57863bc96ff93d


--------------------------------------------------------------------------------
/build_bin/iOS/libunitybridge.a:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/iOS/libunitybridge.a


--------------------------------------------------------------------------------
/build_bin/iOS/libunitybridge.a.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 0323a6618f6ca450291ec04ad045bd3d


--------------------------------------------------------------------------------
/build_bin/macOS.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: a531cb527057642349306ff7cf30a8af
3 | folderAsset: yes
4 | DefaultImporter:
5 |   externalObjects: {}
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/build_bin/macOS/rapier_c_bind.bundle:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/macOS/rapier_c_bind.bundle


--------------------------------------------------------------------------------
/build_bin/macOS/rapier_c_bind.bundle.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 9f984a344520048c5bcebce8da4e7158


--------------------------------------------------------------------------------
/build_bin/macOS/unitybridge.bundle:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/build_bin/macOS/unitybridge.bundle


--------------------------------------------------------------------------------
/build_bin/macOS/unitybridge.bundle.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 7e60bd8e8a8da45c9a22dbb8c4926d0f


--------------------------------------------------------------------------------
/docs~/overview.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/docs~/overview.mp4


--------------------------------------------------------------------------------
/docs~/raycast.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Daxode/rapier4unity/2b003d02039f7c7702f8a4b3aded7c3f21030705/docs~/raycast.mp4


--------------------------------------------------------------------------------
/docs~/readme.md:
--------------------------------------------------------------------------------
1 | PLACEHOLDER FOR FUTURE DUCKS 🦆
2 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "com.daxode.rapier4unity",
 3 |   "displayName": "Rapier for Unity",
 4 |   "version": "0.1.0",
 5 |   "description": "This let's you simulate physics in Unity using Rapier (useful if your server only can run webasm standalone compatible physics)",
 6 |   "keywords": [],
 7 |   "author": {
 8 |     "name": "Daniel Kierkegaard Andersen",
 9 |     "url": "https://daxode.com"
10 |   },
11 |   "repository": {
12 |     "type": "git",
13 |     "url": "https://github.com/daxode/com.daxode.rapier4unity"
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/package.json.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: d6d1b6f31570d4f22856b4278b0efc9a
3 | PackageManifestImporter:
4 |   externalObjects: {}
5 |   userData: 
6 |   assetBundleName: 
7 |   assetBundleVariant: 
8 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/.gitignore:
--------------------------------------------------------------------------------
 1 | # Generated by Cargo
 2 | # will have compiled files and executables
 3 | debug/
 4 | target/
 5 | 
 6 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 7 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 8 | Cargo.lock
 9 | 
10 | # These are backup files generated by rustfmt
11 | **/*.rs.bk
12 | 
13 | # MSVC Windows builds of rustc generate these, which store debugging information
14 | *.pdb
15 | 
16 | # Spacetime ignore
17 | /.spacetime


--------------------------------------------------------------------------------
/source~/rapier-c-bind/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Editor-based HTTP Client requests
5 | /httpRequests/
6 | # Datasource local storage ignored files
7 | /dataSources/
8 | /dataSources.local.xml
9 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/.idea/encodings.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="Encoding" addBOMForNewFiles="with BOM under Windows, with no BOM otherwise" />
4 | </project>


--------------------------------------------------------------------------------
/source~/rapier-c-bind/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/.idea/rapier-c-bind.iml" filepath="$PROJECT_DIR$/.idea/rapier-c-bind.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/source~/rapier-c-bind/.idea/rapier-c-bind.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module type="EMPTY_MODULE" version="4">
 3 |   <component name="NewModuleRootManager">
 4 |     <content url="file://$MODULE_DIR$">
 5 |       <sourceFolder url="file://$MODULE_DIR$/rapierbind/src" isTestSource="false" />
 6 |       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
 7 |       <sourceFolder url="file://$MODULE_DIR$/unitybridge/src" isTestSource="false" />
 8 |       <sourceFolder url="file://$MODULE_DIR$/export-to-unity-dynamic-binder/src" isTestSource="false" />
 9 |       <excludeFolder url="file://$MODULE_DIR$/target" />
10 |     </content>
11 |     <orderEntry type="inheritedJdk" />
12 |     <orderEntry type="sourceFolder" forTests="false" />
13 |   </component>
14 | </module>


--------------------------------------------------------------------------------
/source~/rapier-c-bind/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="$PROJECT_DIR$/../../../.." vcs="Git" />
5 |     <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
6 |   </component>
7 | </project>


--------------------------------------------------------------------------------
/source~/rapier-c-bind/Cargo.toml:
--------------------------------------------------------------------------------
1 | [workspace]
2 | resolver = "2"
3 | members = ["unitybridge", "rapierbind", "export-to-unity-dynamic-binder"]
4 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/android_linker.ld:
--------------------------------------------------------------------------------
1 | /* android_linker.ld */
2 | SECTIONS {
3 |   . = ALIGN(16384); /* 16KB alignment */
4 |   .text : { *(.text .text.*) }
5 |   .data : { *(.data .data.*) }
6 |   .bss : { *(.bss .bss.*) }
7 |   /* Add other sections as needed */
8 | }


--------------------------------------------------------------------------------
/source~/rapier-c-bind/build-debug.bat:
--------------------------------------------------------------------------------
 1 | @echo off
 2 | REM Build Windows DLLs
 3 | cargo build
 4 | IF NOT EXIST "..\..\build_bin" mkdir "..\..\build_bin"
 5 | IF NOT EXIST "..\..\build_bin\Windows" mkdir "..\..\build_bin\Windows"
 6 | copy /Y "target\debug\rapier_c_bind.dll" "..\..\build_bin\Windows\"
 7 | copy /Y "target\debug\rapier_c_bind.pdb" "..\..\build_bin\Windows\"
 8 | copy /Y "target\debug\unitybridge.dll" "..\..\build_bin\Windows\"
 9 | copy /Y "target\debug\unitybridge.pdb" "..\..\build_bin\Windows\"
10 | cargo run -- ./rapierbind/src
11 | 
12 | echo Windows debug build completed.
13 | echo Note: For macOS builds, run the shell scripts on a Mac system.
14 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/build-debug.sh:
--------------------------------------------------------------------------------
 1 | # Build MacOS dylibs
 2 | LIB="rapier_c_bind"
 3 | UNITY_LIB="unitybridge"
 4 | 
 5 | # Build MacOS dylibs
 6 | TARGET_ARM="aarch64-apple-darwin"
 7 | TARGET_X86="x86_64-apple-darwin"
 8 | cargo build --target=$TARGET_ARM
 9 | cargo build --target=$TARGET_X86
10 | lipo -create -output ${LIB}.bundle \
11 |   target/${TARGET_ARM}/debug/lib${LIB}.dylib \
12 |   target/${TARGET_X86}/debug/lib${LIB}.dylib
13 | lipo -create -output ${UNITY_LIB}.bundle \
14 |   target/${TARGET_ARM}/debug/lib${UNITY_LIB}.dylib \
15 |   target/${TARGET_X86}/debug/lib${UNITY_LIB}.dylib
16 | mkdir ../../build_bin/macOS
17 | cp ${LIB}.bundle ../../build_bin/macOS/
18 | cp ${UNITY_LIB}.bundle ../../build_bin/macOS/
19 | 
20 | # Build IOS libs
21 | TARGET_IOS="aarch64-apple-ios"
22 | cargo build --target=$TARGET_IOS
23 | mkdir ../../build_bin/iOS
24 | cp target/${TARGET_IOS}/debug/lib${LIB}.a ../../build_bin/iOS/
25 | cp target/${TARGET_IOS}/debug/lib${UNITY_LIB}.a ../../build_bin/iOS/
26 | 
27 | # Build Windows DLLs
28 | TARGET_WINDOWS="x86_64-pc-windows-msvc"
29 | cargo xwin build --target $TARGET_WINDOWS
30 | mkdir ../../build_bin/Windows
31 | cp target/$TARGET_WINDOWS/debug/$LIB.dll ../../build_bin/Windows
32 | cp target/$TARGET_WINDOWS/debug/$LIB.pdb ../../build_bin/Windows
33 | cp target/$TARGET_WINDOWS/debug/$UNITY_LIB.dll ../../build_bin/Windows
34 | cp target/$TARGET_WINDOWS/debug/$UNITY_LIB.pdb ../../build_bin/Windows
35 | 
36 | # Build Android
37 | TARGET_ANDROID="aarch64-linux-android"
38 | ANDROID_NDK="/Applications/Unity/Hub/Editor/6000.0.40f1/PlaybackEngines/AndroidPlayer/NDK"
39 | if [ -z "$ANDROID_NDK" ]; then
40 |     echo "** Android build error: $ANDROID_NDK is not defined."
41 |     exit 1
42 | fi
43 | export CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER="${ANDROID_NDK}/toolchains/llvm/prebuilt/darwin-x86_64/bin/aarch64-linux-android35-clang"
44 | cargo build --target=$TARGET_ANDROID
45 | mkdir ../../build_bin/Android
46 | cp target/${TARGET_ANDROID}/debug/lib${LIB}.so ../../build_bin/Android/
47 | cp target/${TARGET_ANDROID}/debug/lib${UNITY_LIB}.so ../../build_bin/Android/
48 | 
49 | # Generate C# bindings
50 | cargo run -- ./rapierbind/src


--------------------------------------------------------------------------------
/source~/rapier-c-bind/build-release.bat:
--------------------------------------------------------------------------------
 1 | @echo off
 2 | REM Build Windows DLLs in release mode
 3 | cargo build --release
 4 | IF NOT EXIST "..\..\build_bin" mkdir "..\..\build_bin"
 5 | IF NOT EXIST "..\..\build_bin\Windows" mkdir "..\..\build_bin\Windows"
 6 | copy /Y "target\release\rapier_c_bind.dll" "..\..\build_bin\Windows\"
 7 | copy /Y "target\release\rapier_c_bind.pdb" "..\..\build_bin\Windows\"
 8 | copy /Y "target\release\unitybridge.dll" "..\..\build_bin\Windows\"
 9 | copy /Y "target\release\unitybridge.pdb" "..\..\build_bin\Windows\"
10 | cargo run -- ./rapierbind/src
11 | 
12 | echo Windows release build completed.
13 | echo Note: For macOS builds, run the shell scripts on a Mac system.
14 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/build-release.sh:
--------------------------------------------------------------------------------
 1 | # Build MacOS dylibs
 2 | LIB="rapier_c_bind"
 3 | UNITY_LIB="unitybridge"
 4 | 
 5 | # Build MacOS dylibs
 6 | TARGET_ARM="aarch64-apple-darwin"
 7 | TARGET_X86="x86_64-apple-darwin"
 8 | cargo build -r --target=$TARGET_ARM
 9 | cargo build -r --target=$TARGET_X86
10 | lipo -create -output ${LIB}.bundle \
11 |   target/${TARGET_ARM}/release/lib${LIB}.dylib \
12 |   target/${TARGET_X86}/release/lib${LIB}.dylib
13 | lipo -create -output ${UNITY_LIB}.bundle \
14 |   target/${TARGET_ARM}/release/lib${UNITY_LIB}.dylib \
15 |   target/${TARGET_X86}/release/lib${UNITY_LIB}.dylib
16 | mkdir ../../build_bin/macOS
17 | cp ${LIB}.bundle ../../build_bin/macOS/
18 | cp ${UNITY_LIB}.bundle ../../build_bin/macOS/
19 | 
20 | # Build IOS libs
21 | TARGET_IOS="aarch64-apple-ios"
22 | cargo build -r --target=$TARGET_IOS
23 | mkdir ../../build_bin/iOS
24 | cp target/${TARGET_IOS}/release/lib${LIB}.a ../../build_bin/iOS/
25 | cp target/${TARGET_IOS}/release/lib${UNITY_LIB}.a ../../build_bin/iOS/
26 | 
27 | # Build Windows DLLs
28 | TARGET_WINDOWS="x86_64-pc-windows-msvc"
29 | cargo xwin build -r --target $TARGET_WINDOWS
30 | mkdir ../../build_bin/Windows
31 | cp target/$TARGET_WINDOWS/release/$LIB.dll ../../build_bin/Windows
32 | cp target/$TARGET_WINDOWS/release/$LIB.pdb ../../build_bin/Windows
33 | cp target/$TARGET_WINDOWS/release/$UNITY_LIB.dll ../../build_bin/Windows
34 | cp target/$TARGET_WINDOWS/release/$UNITY_LIB.pdb ../../build_bin/Windows
35 | 
36 | # Build Android
37 | TARGET_ANDROID="aarch64-linux-android"
38 | ANDROID_NDK="/Applications/Unity/Hub/Editor/6000.0.40f1/PlaybackEngines/AndroidPlayer/NDK"
39 | if [ -z "$ANDROID_NDK" ]; then
40 |     echo "** Android build error: $ANDROID_NDK is not defined."
41 |     exit 1
42 | fi
43 | export CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER="${ANDROID_NDK}/toolchains/llvm/prebuilt/darwin-x86_64/bin/aarch64-linux-android35-clang"
44 | cargo build -r --target=$TARGET_ANDROID
45 | mkdir ../../build_bin/Android
46 | cp target/${TARGET_ANDROID}/release/lib${LIB}.so ../../build_bin/Android/
47 | cp target/${TARGET_ANDROID}/release/lib${UNITY_LIB}.so ../../build_bin/Android/
48 | 
49 | # Generate C# bindings
50 | cargo run -- ./rapierbind/src


--------------------------------------------------------------------------------
/source~/rapier-c-bind/export-to-unity-dynamic-binder/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "export-to-unity-dynamic-binder"
 3 | version = "0.1.0"
 4 | edition = "2024"
 5 | 
 6 | [dependencies]
 7 | syn = { version = "2.0.100", features = ["full", "visit"] }
 8 | quote = "1.0"
 9 | anyhow = "1.0"
10 | proc-macro2 = "1.0.94"
11 | phf = { version = "0.11.3", features = ["macros"] }


--------------------------------------------------------------------------------
/source~/rapier-c-bind/export-to-unity-dynamic-binder/src/main.rs:
--------------------------------------------------------------------------------
  1 | use anyhow::Result;
  2 | use phf::{Map, phf_map};
  3 | use proc_macro2::TokenTree::{Ident, Punct};
  4 | use quote::ToTokens;
  5 | use std::env::args;
  6 | use std::fs::OpenOptions;
  7 | use std::io::{BufWriter, Write};
  8 | use syn::visit::Visit;
  9 | 
 10 | // static type translation hashmap
 11 | static RUST_TYPE_TO_CSHARP: Map<&'static str, &'static str> = phf_map! {
 12 |     "SerializableColliderHandle" => "ColliderHandle",
 13 |     "SerializableRigidBodyType" => "RigidBodyType",
 14 |     "SerializableRigidBodyHandle" => "RigidBodyHandle",
 15 |     "SerializableImpulseJointHandle" => "ImpulseJointHandle",
 16 |     "SerializableCollisionEvent" => "CollisionEvent",
 17 |     "RaycastHit" => "RapierRaycastHit",
 18 |     "Vector3<float>" => "float3",
 19 |     "Vector2<float>" => "float2",
 20 |     "u32" => "uint",
 21 |     "f32" => "float",
 22 |     "i32" => "int",
 23 |     "usize" => "UIntPtr",
 24 |     // Add more entries
 25 | };
 26 | 
 27 | fn main() -> Result<()> {
 28 |     // find input folder
 29 |     let folder = args().nth(1).expect("Please provide an input folder.");
 30 |     let files = get_rust_files(&folder)?;
 31 | 
 32 |     let path = std::path::Path::new("../../Runtime/RapierBinds.cs");
 33 | 
 34 |     // Delete and recreate the file
 35 |     if path.exists() {
 36 |         std::fs::remove_file(path)?;
 37 |         std::fs::File::create(path)?;
 38 |     }
 39 | 
 40 |     // open file to write or create if it doesn't exist
 41 |     let file = OpenOptions::new()
 42 |         .append(false)
 43 |         .write(true)
 44 |         .open(path)
 45 |         .or_else(|err| Err(err));
 46 | 
 47 |     let mut writer = BufWriter::new(file?);
 48 |     // write to file
 49 |     writeln!(&mut writer, "//#define DISABLE_DYNAMIC_RAPIER_LOAD")?;
 50 |     writeln!(&mut writer, "")?;
 51 |     writeln!(&mut writer, "using System;")?;
 52 |     writeln!(&mut writer, "using System.IO;")?;
 53 |     writeln!(&mut writer, "using System.Runtime.InteropServices;")?;
 54 |     writeln!(&mut writer, "using Packages.rapier4unity.Runtime;")?;
 55 |     writeln!(&mut writer, "using Unity.Collections.LowLevel.Unsafe;")?;
 56 |     writeln!(&mut writer, "using Unity.Burst;")?;
 57 |     writeln!(&mut writer, "using UnityEngine;")?;
 58 |     writeln!(&mut writer, "using Unity.Mathematics;")?;
 59 |     writeln!(&mut writer, "")?;
 60 | 
 61 |     writeln!(
 62 |         &mut writer,
 63 |         "#if UNITY_EDITOR && !DISABLE_DYNAMIC_RAPIER_LOAD"
 64 |     )?;
 65 |     writeln!(&mut writer, "[UnityEditor.InitializeOnLoad]")?;
 66 |     writeln!(&mut writer, "#endif")?;
 67 | 
 68 |     writeln!(&mut writer, "")?;
 69 |     writeln!(&mut writer, "[BurstCompile]")?;
 70 |     writeln!(&mut writer, "internal static unsafe class RapierBindings")?;
 71 |     writeln!(&mut writer, "{{")?;
 72 |     writeln!(&mut writer, r#"
 73 | #if !UNITY_EDITOR && (UNITY_IOS || UNITY_WEBGL)
 74 | 	private const string DllName = "__Internal";
 75 | #else
 76 | 	private const string DllName = "rapier_c_bind";
 77 | 
 78 | #if UNITY_EDITOR_OSX
 79 | 	const string k_DLLPath = "Packages/rapier4unity/build_bin/macOS/rapier_c_bind.bundle";
 80 | #else
 81 | 	const string k_DLLPath = "Packages/rapier4unity/build_bin/Windows/rapier_c_bind.dll";
 82 | #endif
 83 | #endif
 84 | 	private const CallingConvention Convention = CallingConvention.Cdecl;"#)?;
 85 | 
 86 |     let mut raw_function_ptrs = Vec::new();
 87 |     let mut load_calls = Vec::new();
 88 | 
 89 |     for file in files {
 90 |         println!("reading file: {}", file);
 91 | 
 92 |         // Read the Rust source file
 93 |         let code = std::fs::read_to_string(file)?;
 94 | 
 95 |         // Parse the code into an AST
 96 |         let ast = syn::parse_file(&code)?;
 97 | 
 98 |         // Visitor to find the target function and its arguments
 99 |         let mut visitor = FunctionVisitor {
100 |             function_names: Vec::new(),
101 |             function_ptr_signatures: Vec::new(),
102 |             extern_function_signatures: Vec::new(),
103 |         };
104 |         visitor.visit_file(&ast);
105 |         if visitor.function_names.is_empty() {
106 |             continue;
107 |         }
108 | 
109 |         for i in 0..visitor.function_names.len() {
110 |             load_calls.push(format!(
111 |                 "{} = NativeLoader.GetFunction(loaded_lib, \"{}\");",
112 |                 to_camel_case(&visitor.function_names[i]),
113 |                 visitor.function_names[i]
114 |             ));
115 |             raw_function_ptrs.push(format!(
116 |                 "public IntPtr {};",
117 |                 to_camel_case(&visitor.function_names[i])
118 |             ));
119 |         }
120 | 
121 |         writeln!(
122 |             &mut writer,
123 |             "#if UNITY_EDITOR && !DISABLE_DYNAMIC_RAPIER_LOAD"
124 |         )?;
125 |         for i in 0..visitor.function_names.len() {
126 |             writeln!(&mut writer, "\t{}", visitor.function_ptr_signatures[i])?;
127 |         }
128 |         writeln!(&mut writer, "#else")?;
129 |         for i in 0..visitor.function_names.len() {
130 |             writeln!(&mut writer, "\t{}", visitor.extern_function_signatures[i])?;
131 |         }
132 |         writeln!(&mut writer, "#endif")?;
133 |     }
134 |     // stuff
135 |     writeln!(
136 |         &mut writer,
137 |         r#"
138 | #if UNITY_EDITOR && !DISABLE_DYNAMIC_RAPIER_LOAD
139 |     // C# -> Rust
140 |     [StructLayout(LayoutKind.Sequential, Size=sizeof(ulong) * 512)]
141 |     struct UnmanagedData
142 |     {{
143 |         IntPtr loaded_lib;
144 |         public void load_calls()
145 |         {{
146 |             if (loaded_lib==IntPtr.Zero)
147 |             {{
148 |                 loaded_lib = NativeLoader.LoadLibrary(Path.GetFullPath(k_DLLPath));
149 |                 if (loaded_lib == IntPtr.Zero)
150 |                 {{
151 |                     var errorMsg = NativeLoader.GetLastErrorString();
152 |                     Console.WriteLine($"Failed to load library: {{errorMsg}}");
153 |                     return;
154 |                 }}
155 |             }}
156 | 
157 |             // Load function pointers
158 |             {}
159 |         }}
160 | 
161 |         // Raw function pointers
162 |         {}
163 | 
164 |         // Rust -> C# data
165 |         public FunctionsToCallFromRust functionsToCallFromRust;
166 | 
167 |         public void unload_calls()
168 |         {{
169 |             if (loaded_lib != IntPtr.Zero)
170 |                 NativeLoader.FreeLibrary(loaded_lib);
171 |             loaded_lib = IntPtr.Zero;
172 |             Debug.Log($"RapierBindingCalls Unloaded");
173 |         }}
174 |         public bool IsLoaded => loaded_lib != IntPtr.Zero;
175 |     }}
176 |     public static bool IsAvailable => data.Data.IsLoaded;
177 |     public static void LoadCalls()
178 |     {{
179 |         data.Data.load_calls();
180 |         init_rapier4unity();
181 |         Debug.Log($"RapierBindingCalls Loaded");
182 |     }}
183 | 
184 |     [BurstCompile]
185 |     static void init_rapier4unity(){{
186 |         data.Data.functionsToCallFromRust.Init();
187 |         Init((FunctionsToCallFromRust*)UnsafeUtility.AddressOf(ref data.Data.functionsToCallFromRust));
188 |     }}
189 | 
190 |     public static void UnloadCalls() => data.Data.unload_calls();
191 | 
192 |     struct SpecialKey {{}}
193 |     static readonly SharedStatic<UnmanagedData> data = SharedStatic<UnmanagedData>.GetOrCreate<SpecialKey>();
194 | #else
195 |     // No dynamic loading, empty functions
196 |     public static bool IsAvailable => true;
197 |     public static void LoadCalls(){{}}
198 |     public static void UnloadCalls(){{}}
199 | 
200 |     // Called during InitializeOnLoad
201 | 	static RapierBindings()
202 | 	{{
203 | 		var functionsToCallFromRust = new FunctionsToCallFromRust();
204 | 		functionsToCallFromRust.Init();
205 | 		Init(&functionsToCallFromRust);
206 | 	}}
207 | #endif
208 | 
209 |     // Rust -> C#
210 |     [BurstCompile]
211 |     [StructLayout(LayoutKind.Sequential)]
212 |     public struct FunctionsToCallFromRust {{
213 |         public IntPtr unityLogPtr;
214 | 
215 |         public void Init()
216 |         {{
217 |             unityLogPtr = UnityRapierBridge.GetDefaultUnityLogger();
218 |         }}
219 |     }}
220 | "#,
221 |         load_calls.join("\n\t\t\t"),
222 |         raw_function_ptrs.join("\n\t\t")
223 |     )?;
224 |     writeln!(&mut writer, "}}")?;
225 |     writer.flush()?;
226 | 
227 |     Ok(())
228 | }
229 | 
230 | // turn snake_case to PascalCase
231 | fn to_pascal_case(name: &str) -> String {
232 |     let mut result = String::new();
233 |     let mut capitalize = true;
234 |     for c in name.chars() {
235 |         if c == '_' {
236 |             capitalize = true;
237 |         } else if capitalize {
238 |             result.push(c.to_ascii_uppercase());
239 |             capitalize = false;
240 |         } else {
241 |             result.push(c);
242 |         }
243 |     }
244 |     result
245 | }
246 | 
247 | // turn snake_case to camelCase
248 | fn to_camel_case(name: &str) -> String {
249 |     let mut result = String::new();
250 |     let mut capitalize = false;
251 |     for c in name.chars() {
252 |         if c == '_' {
253 |             capitalize = true;
254 |         } else if capitalize {
255 |             result.push(c.to_ascii_uppercase());
256 |             capitalize = false;
257 |         } else {
258 |             result.push(c);
259 |         }
260 |     }
261 |     result
262 | }
263 | 
264 | struct FunctionVisitor {
265 |     function_names: Vec<String>,
266 |     function_ptr_signatures: Vec<String>,
267 |     extern_function_signatures: Vec<String>,
268 | }
269 | 
270 | fn is_extern_c(sig: &syn::Signature) -> bool {
271 |     sig.abi
272 |         .as_ref()
273 |         .and_then(|abi| abi.name.as_ref())
274 |         .map(|lit_str| lit_str.value() == "C")
275 |         .unwrap_or(false)
276 | }
277 | 
278 | impl<'a> Visit<'_> for FunctionVisitor {
279 |     fn visit_item_fn(&mut self, node: &syn::ItemFn) {
280 |         // Check if this is the target function
281 |         //self.function_name = node.sig.ident.to_string();
282 | 
283 |         if !is_extern_c(&node.sig) {
284 |             syn::visit::visit_item_fn(self, node);
285 |             return;
286 |         }
287 | 
288 |         // Extract each argument's name and type
289 |         let pascal_cased_name = to_pascal_case(&node.sig.ident.to_string());
290 |         let camel_cased_name = to_camel_case(&node.sig.ident.to_string());
291 |         let mut types = Vec::new();
292 |         let mut parameter_list = Vec::new();
293 |         let mut names = Vec::new();
294 |         let mut return_type = String::new();
295 |         if let syn::ReturnType::Type(_, return_typee) = &node.sig.output {
296 |             return_type.push_str(get_typename(return_typee).as_str());
297 |         } else {
298 |             return_type.push_str("void");
299 |         }
300 | 
301 |         for arg in &node.sig.inputs {
302 |             if let syn::FnArg::Typed(pat_type) = arg {
303 |                 // Get argument name
304 |                 let name = match &*pat_type.pat {
305 |                     syn::Pat::Ident(ident) => ident.ident.to_string(),
306 |                     _ => "<unnamed>".to_string(),
307 |                 };
308 | 
309 |                 // Get argument type as a string
310 |                 let some_type = get_typename(&pat_type.ty);
311 | 
312 |                 //println!("{:?}", some_type);
313 |                 types.push(format!("{}", some_type));
314 |                 let param_name = to_camel_case(name.as_str());
315 |                 parameter_list.push(format!("{} {}", some_type, param_name));
316 |                 names.push(param_name);
317 |             }
318 |         }
319 |         types.push(return_type.to_string());
320 | 
321 |         self.function_names.push(node.sig.ident.to_string());
322 |         self.function_ptr_signatures.push(format!(
323 |             "public static {} {}({}) => ((delegate* unmanaged[Cdecl]<{}>) data.Data.{})({});",
324 |             return_type,
325 |             pascal_cased_name,
326 |             parameter_list.join(", "),
327 |             types.join(", "),
328 |             camel_cased_name,
329 |             names.join(", ")
330 |         ));
331 |         self.extern_function_signatures.push(format!("[DllImport(DllName, CallingConvention = Convention, EntryPoint=\"{}\")]\n\tpublic static extern unsafe {} {}({});", node.sig.ident, return_type, pascal_cased_name, parameter_list.join(", ")));
332 |         // Output the result
333 |         // println!(
334 |         //     "found '{}', with argument(s): {}",
335 |         //     node.sig.ident,
336 |         //     self.args.join(", ")
337 |         // );
338 | 
339 |         // Continue traversing the AST
340 |         syn::visit::visit_item_fn(self, node);
341 |     }
342 | }
343 | 
344 | fn get_typename(ty: &syn::Type) -> String {
345 |     let mut some_type = String::new();
346 |     let mut is_parsing_pointer = false;
347 |     //let mut is_parsing_typearg = false;
348 |     let mut pending_pointers = 0;
349 |     for token in ty.to_token_stream() {
350 |         if let Punct(punct) = token {
351 |             if punct.as_char() == '*' {
352 |                 is_parsing_pointer = true;
353 |             } else if punct.as_char() == '<' || punct.as_char() == '>' {
354 |                 some_type.push(punct.as_char());
355 |             }
356 |         } else if let Ident(punct) = token {
357 |             if is_parsing_pointer {
358 |                 assert!(punct == "mut" || punct == "const");
359 |                 pending_pointers += 1;
360 |                 is_parsing_pointer = false;
361 |             } else {
362 |                 if let Some(csharp_type) = RUST_TYPE_TO_CSHARP.get(&punct.to_string().as_str()) {
363 |                     some_type.push_str(csharp_type);
364 |                 } else {
365 |                     some_type.push_str(&format!("{}", punct));
366 |                 }
367 |             }
368 |         }
369 | 
370 |         //some_type.push_str(&format!("{}", token));
371 |     }
372 | 
373 |     if let Some(csharp_type) = RUST_TYPE_TO_CSHARP.get(&some_type) {
374 |         some_type = csharp_type.to_string();
375 |     }
376 | 
377 |     if pending_pointers > 0 {
378 |         for _ in 0..pending_pointers {
379 |             some_type.push_str("*");
380 |         }
381 |     }
382 | 
383 |     some_type
384 | }
385 | 
386 | // get all rust files in the input folder
387 | fn get_rust_files(folder: &str) -> Result<Vec<String>> {
388 |     let mut files = Vec::new();
389 |     for entry in std::fs::read_dir(folder)? {
390 |         let entry = entry?;
391 |         let path = entry.path();
392 |         if path.is_file() && path.extension() == Some("rs".as_ref()) {
393 |             // get absolute path from relative path
394 |             let path = path.canonicalize()?;
395 |             files.push(path.to_string_lossy().to_string());
396 |         }
397 |     }
398 |     Ok(files)
399 | }
400 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/get-build-dependencies.bat:
--------------------------------------------------------------------------------
1 | @echo off
2 | REM Description: Install build dependencies for Windows
3 | 
4 | REM Install Rust targets
5 | rustup target add x86_64-pc-windows-msvc
6 | 
7 | REM Note: For building macOS binaries, you'll need to use the original shell scripts on a Mac
8 | echo Windows build dependencies have been installed.


--------------------------------------------------------------------------------
/source~/rapier-c-bind/get-build-dependencies.sh:
--------------------------------------------------------------------------------
1 | # Description: Install build dependencies for Windows. This script is meant to be run on MacOS.
2 | cargo install cargo-xwin
3 | rustup target add x86_64-pc-windows-msvc


--------------------------------------------------------------------------------
/source~/rapier-c-bind/rapierbind/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "rapier-c-bind"
 3 | version = "0.1.0"
 4 | edition = "2024"
 5 | 
 6 | [lib]
 7 | crate-type = ["staticlib", "cdylib"]
 8 | 
 9 | [dependencies]
10 | log = "0.4.27"
11 | rapier3d = { version = "0.23.1", features = [ "simd-stable" ] }
12 | unitybridge = { path = "../unitybridge" }
13 | 
14 | [target.aarch64-linux-android]
15 | rustflags = [
16 |     "-Clink-args=-Wl,-z,max-page-size=16384",
17 |     "-Clink-args=-Wl,-z,common-page-size=16384",
18 |     "-Clink-args=-Wl,--script=./android_linker.ld"
19 | ]


--------------------------------------------------------------------------------
/source~/rapier-c-bind/rapierbind/src/handles.rs:
--------------------------------------------------------------------------------
  1 | use rapier3d::prelude::*;
  2 | 
  3 | // CollHandle is a handle to a collider.
  4 | #[derive(Debug, Clone, Copy)]
  5 | #[repr(C)] // Keep the structure of the memory layout the same as in C
  6 | pub struct SerializableColliderHandle {
  7 |     index: u32,
  8 |     generation: u32,
  9 | }
 10 | 
 11 | impl From<ColliderHandle> for SerializableColliderHandle {
 12 |     fn from(value: ColliderHandle) -> Self {
 13 |         let val = value.into_raw_parts();
 14 |         SerializableColliderHandle {
 15 |             index: val.0,
 16 |             generation: val.1,
 17 |         }
 18 |     }
 19 | }
 20 | 
 21 | impl From<SerializableColliderHandle> for ColliderHandle {
 22 |     fn from(value: SerializableColliderHandle) -> Self {
 23 |         ColliderHandle::from_raw_parts(value.index, value.generation)
 24 |     }
 25 | }
 26 | 
 27 | // RigidBodyHandle is a handle to a rigid body.
 28 | #[derive(Debug, Clone, Copy)]
 29 | #[repr(C)]
 30 | pub struct SerializableRigidBodyHandle {
 31 |     index: u32,
 32 |     generation: u32,
 33 | }
 34 | 
 35 | impl From<RigidBodyHandle> for SerializableRigidBodyHandle {
 36 |     fn from(value: RigidBodyHandle) -> Self {
 37 |         let val = value.into_raw_parts();
 38 |         SerializableRigidBodyHandle {
 39 |             index: val.0,
 40 |             generation: val.1,
 41 |         }
 42 |     }
 43 | }
 44 | 
 45 | impl From<SerializableRigidBodyHandle> for RigidBodyHandle {
 46 |     fn from(value: SerializableRigidBodyHandle) -> Self {
 47 |         RigidBodyHandle::from_raw_parts(value.index, value.generation)
 48 |     }
 49 | }
 50 | 
 51 | #[derive(Debug, Clone, Copy)]
 52 | #[repr(C)]
 53 | pub enum SerializableRigidBodyType {
 54 |     Dynamic = 0,
 55 |     Fixed = 1,
 56 |     KinematicPositionBased = 2,
 57 |     KinematicVelocityBased = 3,
 58 | }
 59 | 
 60 | impl From<RigidBodyType> for SerializableRigidBodyType {
 61 |     fn from(value: RigidBodyType) -> Self {
 62 |         match value {
 63 |             RigidBodyType::Dynamic => SerializableRigidBodyType::Dynamic,
 64 |             RigidBodyType::Fixed => SerializableRigidBodyType::Fixed,
 65 |             RigidBodyType::KinematicPositionBased => {
 66 |                 SerializableRigidBodyType::KinematicPositionBased
 67 |             }
 68 |             RigidBodyType::KinematicVelocityBased => {
 69 |                 SerializableRigidBodyType::KinematicVelocityBased
 70 |             }
 71 |         }
 72 |     }
 73 | }
 74 | 
 75 | impl From<SerializableRigidBodyType> for RigidBodyType {
 76 |     fn from(value: SerializableRigidBodyType) -> Self {
 77 |         match value {
 78 |             SerializableRigidBodyType::Dynamic => RigidBodyType::Dynamic,
 79 |             SerializableRigidBodyType::Fixed => RigidBodyType::Fixed,
 80 |             SerializableRigidBodyType::KinematicPositionBased => {
 81 |                 RigidBodyType::KinematicPositionBased
 82 |             }
 83 |             SerializableRigidBodyType::KinematicVelocityBased => {
 84 |                 RigidBodyType::KinematicVelocityBased
 85 |             }
 86 |         }
 87 |     }
 88 | }
 89 | 
 90 | // SerializableImpulseJointHandle
 91 | #[derive(Debug, Clone, Copy)]
 92 | #[repr(C)]
 93 | pub struct SerializableImpulseJointHandle {
 94 |     index: u32,
 95 |     generation: u32,
 96 | }
 97 | 
 98 | impl From<ImpulseJointHandle> for SerializableImpulseJointHandle {
 99 |     fn from(value: ImpulseJointHandle) -> Self {
100 |         let val = value.into_raw_parts();
101 |         SerializableImpulseJointHandle {
102 |             index: val.0,
103 |             generation: val.1,
104 |         }
105 |     }
106 | }
107 | 
108 | impl From<SerializableImpulseJointHandle> for ImpulseJointHandle {
109 |     fn from(value: SerializableImpulseJointHandle) -> Self {
110 |         ImpulseJointHandle::from_raw_parts(value.index, value.generation)
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/rapierbind/src/lib.rs:
--------------------------------------------------------------------------------
  1 | mod handles;
  2 | mod utils;
  3 | use crate::handles::{
  4 |     SerializableColliderHandle, SerializableRigidBodyHandle, SerializableRigidBodyType,
  5 | };
  6 | use handles::SerializableImpulseJointHandle;
  7 | use rapier3d::crossbeam;
  8 | use rapier3d::na::{Isometry, Quaternion, UnitQuaternion, Vector2, Vector3, Vector4};
  9 | use rapier3d::prelude::*;
 10 | use std::mem;
 11 | use unitybridge::{AssignUnityLogger, IUnityLog};
 12 | use utils::{
 13 |     cancel_axis_velocity, locked_axes_to_unity_constraints, unity_constraints_to_locked_axes,
 14 | };
 15 | 
 16 | static mut PHYSIC_SOLVER_DATA: Option<PhysicsSolverData> = None;
 17 | 
 18 | #[allow(static_mut_refs)]
 19 | fn get_mutable_physics_solver() -> &'static mut PhysicsSolverData<'static> {
 20 |     unsafe { PHYSIC_SOLVER_DATA.as_mut().unwrap() }
 21 | }
 22 | 
 23 | #[repr(C)]
 24 | struct FunctionsToCallFromRust {
 25 |     unity_log_ptr: *const IUnityLog,
 26 | }
 27 | 
 28 | #[unsafe(no_mangle)]
 29 | extern "C" fn init(funcs: *const FunctionsToCallFromRust) {
 30 |     unsafe {
 31 |         PHYSIC_SOLVER_DATA = Some(PhysicsSolverData::default());
 32 |         AssignUnityLogger((*funcs).unity_log_ptr);
 33 |     }
 34 | }
 35 | 
 36 | #[unsafe(no_mangle)]
 37 | extern "C" fn hello_world() {
 38 |     log::info!("Hello, cake!");
 39 | }
 40 | 
 41 | // teardown
 42 | #[unsafe(no_mangle)]
 43 | extern "C" fn teardown() {
 44 |     unsafe {
 45 |         PHYSIC_SOLVER_DATA = None;
 46 |     }
 47 | }
 48 | 
 49 | #[repr(C)]
 50 | struct RawArray<T> {
 51 |     ptr: *mut T,
 52 |     len: usize,
 53 |     capacity: usize,
 54 | }
 55 | 
 56 | #[unsafe(no_mangle)]
 57 | #[allow(static_mut_refs)]
 58 | extern "C" fn solve() -> *const RawArray<SerializableCollisionEvent> {
 59 |     unsafe {
 60 |         if PHYSIC_SOLVER_DATA.is_none() {
 61 |             log::warn!("Physics solver data is not initialized");
 62 |             return std::ptr::null();
 63 |         }
 64 |     }
 65 | 
 66 |     let mut collision_events = get_mutable_physics_solver().solve();
 67 |     // box the vector to prevent it from being deallocated
 68 |     let ptr = collision_events.as_mut_ptr();
 69 |     let len = collision_events.len();
 70 |     let capacity = collision_events.capacity();
 71 |     let val = Box::new(RawArray { ptr, len, capacity });
 72 |     mem::forget(collision_events);
 73 |     Box::into_raw(val)
 74 | }
 75 | 
 76 | #[unsafe(no_mangle)]
 77 | extern "C" fn free_collision_events(ptr: *mut RawArray<SerializableCollisionEvent>) {
 78 |     unsafe {
 79 |         let info = Box::from_raw(ptr);
 80 |         let _ = Vec::from_raw_parts(info.ptr, info.len, info.capacity);
 81 |     }
 82 | }
 83 | 
 84 | // Settings
 85 | 
 86 | #[unsafe(no_mangle)]
 87 | extern "C" fn set_gravity(x: f32, y: f32, z: f32) {
 88 |     get_mutable_physics_solver().gravity = vector![x, y, z];
 89 | }
 90 | 
 91 | #[unsafe(no_mangle)]
 92 | extern "C" fn set_time_step(dt: f32) {
 93 |     get_mutable_physics_solver().integration_parameters.dt = dt;
 94 |     get_mutable_physics_solver()
 95 |         .integration_parameters
 96 |         .min_ccd_dt = dt / 100.0;
 97 | }
 98 | 
 99 | // Collider
100 | 
101 | #[unsafe(no_mangle)]
102 | extern "C" fn add_cuboid_collider(
103 |     half_extents_x: f32,
104 |     half_extents_y: f32,
105 |     half_extents_z: f32,
106 |     mass: f32,
107 |     is_sensor: bool,
108 | ) -> SerializableColliderHandle {
109 |     let psd = get_mutable_physics_solver();
110 |     let collider = ColliderBuilder::cuboid(half_extents_x, half_extents_y, half_extents_z)
111 |         .active_events(ActiveEvents::COLLISION_EVENTS)
112 |         .density(mass)
113 |         .sensor(is_sensor)
114 |         .build();
115 |     psd.collider_set.insert(collider).into()
116 | }
117 | 
118 | #[unsafe(no_mangle)]
119 | extern "C" fn add_sphere_collider(
120 |     radius: f32,
121 |     mass: f32,
122 |     is_sensor: bool,
123 | ) -> SerializableColliderHandle {
124 |     let psd = get_mutable_physics_solver();
125 |     let collider = ColliderBuilder::ball(radius)
126 |         .density(mass)
127 |         .active_events(ActiveEvents::COLLISION_EVENTS)
128 |         .sensor(is_sensor)
129 |         .build();
130 |     psd.collider_set.insert(collider).into()
131 | }
132 | 
133 | #[unsafe(no_mangle)]
134 | extern "C" fn add_capsule_collider(
135 |     half_height: f32,
136 |     radius: f32,
137 |     mass: f32,
138 |     is_sensor: bool,
139 | ) -> SerializableColliderHandle {
140 |     let psd = get_mutable_physics_solver();
141 |     let collider = ColliderBuilder::capsule_y(half_height, radius)
142 |         .density(mass)
143 |         .active_events(ActiveEvents::COLLISION_EVENTS)
144 |         .sensor(is_sensor)
145 |         .build();
146 |     psd.collider_set.insert(collider).into()
147 | }
148 | 
149 | // TODO Investigate optimizing this a bit
150 | #[unsafe(no_mangle)]
151 | extern "C" fn add_mesh_collider(
152 |     vertices_ptr: *const f32,
153 |     vertices_count: usize,
154 |     indices_ptr: *const u32,
155 |     indices_count: usize,
156 |     mass: f32,
157 |     is_sensor: bool,
158 | ) -> SerializableColliderHandle {
159 |     let psd = get_mutable_physics_solver();
160 | 
161 |     // Convert C arrays to Rust slices
162 |     let vertices_flat = unsafe { std::slice::from_raw_parts(vertices_ptr, vertices_count * 3) };
163 |     let indices_flat = unsafe { std::slice::from_raw_parts(indices_ptr, indices_count * 3) };
164 | 
165 |     // Convert flat arrays to points
166 |     let mut vertices = Vec::with_capacity(vertices_count);
167 |     for i in 0..vertices_count {
168 |         vertices.push(point![
169 |             vertices_flat[i * 3],
170 |             vertices_flat[i * 3 + 1],
171 |             vertices_flat[i * 3 + 2]
172 |         ]);
173 |     }
174 | 
175 |     // Convert flat indices to triangle indices
176 |     let mut indices = Vec::with_capacity(indices_count);
177 |     for i in 0..indices_count {
178 |         indices.push([
179 |             indices_flat[i * 3],
180 |             indices_flat[i * 3 + 1],
181 |             indices_flat[i * 3 + 2],
182 |         ]);
183 |     }
184 | 
185 |     // Build the trimesh collider
186 |     if let Ok(collider_builder) = ColliderBuilder::trimesh(vertices, indices) {
187 |         let collider = collider_builder
188 |             .active_events(ActiveEvents::COLLISION_EVENTS)
189 |             .density(mass)
190 |             .sensor(is_sensor)
191 |             .build();
192 |         psd.collider_set.insert(collider).into()
193 |     } else {
194 |         log::warn!("Failed to create mesh collider");
195 |         ColliderHandle::invalid().into()
196 |     }
197 | }
198 | 
199 | // TODO Investigate optimizing this a bit
200 | // In practice we may only want to use this option as opposed to full mesh collision
201 | #[unsafe(no_mangle)]
202 | extern "C" fn add_convex_mesh_collider(
203 |     vertices_ptr: *const f32,
204 |     vertices_count: usize,
205 |     mass: f32,
206 |     is_sensor: bool,
207 | ) -> SerializableColliderHandle {
208 |     let psd = get_mutable_physics_solver();
209 | 
210 |     // Convert C arrays to Rust slices
211 |     let vertices_flat = unsafe { std::slice::from_raw_parts(vertices_ptr, vertices_count * 3) };
212 | 
213 |     // Convert flat arrays to points
214 |     let mut points = Vec::with_capacity(vertices_count);
215 |     for i in 0..vertices_count {
216 |         points.push(point![
217 |             vertices_flat[i * 3],
218 |             vertices_flat[i * 3 + 1],
219 |             vertices_flat[i * 3 + 2]
220 |         ]);
221 |     }
222 | 
223 |     // Build the convex hull collider
224 |     if let Some(collider_builder) = ColliderBuilder::convex_hull(&points) {
225 |         let collider = collider_builder
226 |             .active_events(ActiveEvents::COLLISION_EVENTS)
227 |             .density(mass)
228 |             .sensor(is_sensor)
229 |             .build();
230 |         psd.collider_set.insert(collider).into()
231 |     } else {
232 |         log::warn!("Failed to create convex hull collider");
233 |         ColliderHandle::invalid().into()
234 |     }
235 | }
236 | 
237 | // RigidBody
238 | 
239 | #[unsafe(no_mangle)]
240 | extern "C" fn add_rigid_body(
241 |     collider: SerializableColliderHandle,
242 |     rb_type: SerializableRigidBodyType,
243 |     position_x: f32,
244 |     position_y: f32,
245 |     position_z: f32,
246 |     rotation_x: f32,
247 |     rotation_y: f32,
248 |     rotation_z: f32,
249 |     rotation_w: f32,
250 | ) -> SerializableRigidBodyHandle {
251 |     let psd = get_mutable_physics_solver();
252 |     let quat = Quaternion::new(rotation_w, rotation_x, rotation_y, rotation_z);
253 | 
254 |     // Convert to unit quaternion
255 |     let unit_quat = UnitQuaternion::from_quaternion(quat);
256 | 
257 |     // Extract the rotation angle and axis
258 |     let angle = unit_quat.angle();
259 |     let axis = unit_quat.axis().unwrap_or(Vector3::z_axis());
260 | 
261 |     // Create the AngVector (axis-angle representation)
262 |     let ang_vector = axis.into_inner() * angle;
263 | 
264 |     // Build with the AngVector
265 |     let rigid_body = RigidBodyBuilder::new(rb_type.into())
266 |         .translation(vector![position_x, position_y, position_z])
267 |         .rotation(ang_vector)
268 |         .build();
269 | 
270 |     let rb_handle = psd.rigid_body_set.insert(rigid_body);
271 |     psd.collider_set
272 |         .set_parent(collider.into(), Some(rb_handle), &mut psd.rigid_body_set);
273 |     rb_handle.into()
274 | }
275 | 
276 | #[unsafe(no_mangle)]
277 | extern "C" fn remove_rigid_body(rb_handle: SerializableRigidBodyHandle) {
278 |     let psd = get_mutable_physics_solver();
279 |     psd.rigid_body_set.remove(
280 |         rb_handle.into(),
281 |         &mut psd.island_manager,
282 |         &mut psd.collider_set,
283 |         &mut psd.impulse_joint_set,
284 |         &mut psd.multibody_joint_set,
285 |         true,
286 |     );
287 | }
288 | 
289 | #[unsafe(no_mangle)]
290 | extern "C" fn update_rigid_body_properties(
291 |     rb_handle: SerializableRigidBodyHandle,
292 |     rb_type: SerializableRigidBodyType,
293 |     enable_ccd: bool,
294 |     constraints: u32,
295 |     linear_drag: f32,
296 |     angular_drag: f32,
297 | ) {
298 |     let psd = get_mutable_physics_solver();
299 |     let rb = psd.rigid_body_set.get_mut(rb_handle.into()).unwrap();
300 | 
301 |     // Update body type if different
302 |     let rb_type_enum: RigidBodyType = rb_type.into();
303 |     if rb.body_type() != rb_type_enum {
304 |         rb.set_body_type(rb_type_enum, true);
305 |     }
306 | 
307 |     // Set CCD
308 |     rb.enable_ccd(enable_ccd);
309 | 
310 |     // Update constraints if different
311 |     if locked_axes_to_unity_constraints(rb.locked_axes()) != constraints {
312 |         let locks = unity_constraints_to_locked_axes(constraints);
313 |         rb.set_locked_axes(locks, false);
314 |         cancel_axis_velocity(locks, rb);
315 |     }
316 | 
317 |     // Set drag values
318 |     rb.set_linear_damping(linear_drag);
319 |     rb.set_angular_damping(angular_drag);
320 | }
321 | 
322 | #[unsafe(no_mangle)]
323 | extern "C" fn add_fixed_joint(
324 |     rb1_handle: SerializableRigidBodyHandle,
325 |     rb2_handle: SerializableRigidBodyHandle,
326 |     local_frame1_x: f32,
327 |     local_frame1_y: f32,
328 |     local_frame1_z: f32,
329 |     local_frame2_x: f32,
330 |     local_frame2_y: f32,
331 |     local_frame2_z: f32,
332 |     self_collision: bool,
333 | ) -> SerializableImpulseJointHandle {
334 |     let psd = get_mutable_physics_solver();
335 |     let point1: Point<Real> = point![local_frame1_x, local_frame1_y, local_frame1_z];
336 |     let point2: Point<Real> = point![local_frame2_x, local_frame2_y, local_frame2_z];
337 |     let anchor_rb = psd.rigid_body_set.get(rb1_handle.into()).unwrap();
338 |     let mover_rb = psd.rigid_body_set.get(rb2_handle.into()).unwrap();
339 |     // Construct the local_frame for the first body
340 |     let local_frame1 =
341 |         Isometry::from_parts(Translation::from(point1), anchor_rb.position().rotation);
342 |     // Construct the local_frame for the second body
343 |     let local_frame2 =
344 |         Isometry::from_parts(Translation::from(point2), mover_rb.position().rotation);
345 |     let joint = FixedJointBuilder::new()
346 |         .local_frame1(local_frame1)
347 |         .local_frame2(local_frame2)
348 |         .contacts_enabled(self_collision);
349 | 
350 |     psd.impulse_joint_set
351 |         .insert(rb1_handle.into(), rb2_handle.into(), joint, false)
352 |         .into()
353 | }
354 | 
355 | #[unsafe(no_mangle)]
356 | extern "C" fn add_spherical_joint(
357 |     rb1_handle: SerializableRigidBodyHandle,
358 |     rb2_handle: SerializableRigidBodyHandle,
359 |     local_frame1_x: f32,
360 |     local_frame1_y: f32,
361 |     local_frame1_z: f32,
362 |     local_frame2_x: f32,
363 |     local_frame2_y: f32,
364 |     local_frame2_z: f32,
365 |     self_collision: bool,
366 | ) -> SerializableImpulseJointHandle {
367 |     let psd = get_mutable_physics_solver();
368 |     let point1: Point<Real> = point![local_frame1_x, local_frame1_y, local_frame1_z];
369 |     let point2: Point<Real> = point![local_frame2_x, local_frame2_y, local_frame2_z];
370 |     let anchor_rb = psd.rigid_body_set.get(rb1_handle.into()).unwrap();
371 |     let mover_rb = psd.rigid_body_set.get(rb2_handle.into()).unwrap();
372 |     // Construct the local_frame for the first body
373 |     let local_frame1 =
374 |         Isometry::from_parts(Translation::from(point1), anchor_rb.position().rotation);
375 |     // Construct the local_frame for the second body
376 |     let local_frame2 =
377 |         Isometry::from_parts(Translation::from(point2), mover_rb.position().rotation);
378 |     let joint = SphericalJointBuilder::new()
379 |         // .local_anchor1(point1)
380 |         // .local_anchor2(point2)
381 |         .local_frame1(local_frame1)
382 |         .local_frame2(local_frame2)
383 |         .contacts_enabled(self_collision);
384 | 
385 |     psd.impulse_joint_set
386 |         .insert(rb1_handle.into(), rb2_handle.into(), joint, false)
387 |         .into()
388 | }
389 | 
390 | #[unsafe(no_mangle)]
391 | extern "C" fn add_revolute_joint(
392 |     rb1_handle: SerializableRigidBodyHandle,
393 |     rb2_handle: SerializableRigidBodyHandle,
394 |     axis_x: f32,
395 |     axis_y: f32,
396 |     axis_z: f32,
397 |     local_frame1_x: f32,
398 |     local_frame1_y: f32,
399 |     local_frame1_z: f32,
400 |     local_frame2_x: f32,
401 |     local_frame2_y: f32,
402 |     local_frame2_z: f32,
403 |     self_collision: bool,
404 | ) -> SerializableImpulseJointHandle {
405 |     let psd = get_mutable_physics_solver();
406 |     let point1: Point<Real> = point![local_frame1_x, local_frame1_y, local_frame1_z];
407 |     let point2: Point<Real> = point![local_frame2_x, local_frame2_y, local_frame2_z];
408 |     let axis: UnitVector<Real> = UnitVector::new_normalize(vector![axis_x, axis_y, axis_z]);
409 |     let joint = RevoluteJointBuilder::new(axis)
410 |         .local_anchor1(point1)
411 |         .local_anchor2(point2)
412 |         .contacts_enabled(self_collision);
413 | 
414 |     psd.impulse_joint_set
415 |         .insert(rb1_handle.into(), rb2_handle.into(), joint, false)
416 |         .into()
417 | }
418 | 
419 | #[unsafe(no_mangle)]
420 | extern "C" fn add_prismatic_joint(
421 |     rb1_handle: SerializableRigidBodyHandle,
422 |     rb2_handle: SerializableRigidBodyHandle,
423 |     axis_x: f32,
424 |     axis_y: f32,
425 |     axis_z: f32,
426 |     local_frame1_x: f32,
427 |     local_frame1_y: f32,
428 |     local_frame1_z: f32,
429 |     local_frame2_x: f32,
430 |     local_frame2_y: f32,
431 |     local_frame2_z: f32,
432 |     limit_min: f32,
433 |     limit_max: f32,
434 |     self_collision: bool,
435 | ) -> SerializableImpulseJointHandle {
436 |     let psd = get_mutable_physics_solver();
437 |     let point1: Point<Real> = point![local_frame1_x, local_frame1_y, local_frame1_z];
438 |     let point2: Point<Real> = point![local_frame2_x, local_frame2_y, local_frame2_z];
439 |     let axis: UnitVector<Real> = UnitVector::new_normalize(vector![axis_x, axis_y, axis_z]);
440 |     let joint = PrismaticJointBuilder::new(axis)
441 |         .local_anchor1(point1)
442 |         .local_anchor2(point2)
443 |         .limits([limit_min, limit_max])
444 |         // If the anchor is kinematic, then don't collide with the other body
445 |         .contacts_enabled(self_collision);
446 | 
447 |     psd.impulse_joint_set
448 |         .insert(rb1_handle.into(), rb2_handle.into(), joint, false)
449 |         .into()
450 | }
451 | 
452 | #[unsafe(no_mangle)]
453 | extern "C" fn remove_joint(handle: SerializableImpulseJointHandle) {
454 |     let psd = get_mutable_physics_solver();
455 |     psd.impulse_joint_set.remove(handle.into(), true);
456 | }
457 | 
458 | #[unsafe(no_mangle)]
459 | extern "C" fn get_transform(rb_handle: SerializableRigidBodyHandle) -> RapierTransform {
460 |     let psd = get_mutable_physics_solver();
461 |     let rb = psd.rigid_body_set.get(rb_handle.into()).unwrap();
462 |     let pos = rb.position();
463 |     RapierTransform {
464 |         rotation: pos.rotation.coords,
465 |         position: pos.translation.vector,
466 |     }
467 | }
468 | 
469 | #[unsafe(no_mangle)]
470 | extern "C" fn set_transform_position(
471 |     rb_handle: SerializableRigidBodyHandle,
472 |     position_x: f32,
473 |     position_y: f32,
474 |     position_z: f32,
475 | ) {
476 |     let psd = get_mutable_physics_solver();
477 |     let rb = psd.rigid_body_set.get_mut(rb_handle.into()).unwrap();
478 |     let iso = Isometry::from_parts(
479 |         Translation::from(vector![position_x, position_y, position_z]),
480 |         // This is a trick to make sure the order of the position versus rotation will work in either order
481 |         rb.next_position().rotation,
482 |     );
483 |     rb.set_next_kinematic_position(iso);
484 | }
485 | 
486 | #[unsafe(no_mangle)]
487 | extern "C" fn set_transform_rotation(
488 |     rb_handle: SerializableRigidBodyHandle,
489 |     rotation_x: f32,
490 |     rotation_y: f32,
491 |     rotation_z: f32,
492 |     rotation_w: f32,
493 | ) {
494 |     let psd = get_mutable_physics_solver();
495 |     let rb: &mut RigidBody = psd.rigid_body_set.get_mut(rb_handle.into()).unwrap();
496 |     rb.set_next_kinematic_rotation(UnitQuaternion::new_normalize(Quaternion::new(
497 |         rotation_w, rotation_x, rotation_y, rotation_z,
498 |     )));
499 | }
500 | 
501 | #[unsafe(no_mangle)]
502 | extern "C" fn set_transform(
503 |     rb_handle: SerializableRigidBodyHandle,
504 |     position_x: f32,
505 |     position_y: f32,
506 |     position_z: f32,
507 |     rotation_x: f32,
508 |     rotation_y: f32,
509 |     rotation_z: f32,
510 |     rotation_w: f32,
511 | ) {
512 |     let psd = get_mutable_physics_solver();
513 |     let rb = psd.rigid_body_set.get_mut(rb_handle.into()).unwrap();
514 |     let iso = Isometry::from_parts(
515 |         Translation::from(vector![position_x, position_y, position_z]),
516 |         UnitQuaternion::new_normalize(Quaternion::new(
517 |             rotation_w, rotation_x, rotation_y, rotation_z,
518 |         )),
519 |     );
520 |     rb.set_next_kinematic_position(iso);
521 | }
522 | 
523 | #[unsafe(no_mangle)]
524 | extern "C" fn set_linear_velocity(
525 |     rb_handle: SerializableRigidBodyHandle,
526 |     velocity_x: f32,
527 |     velocity_y: f32,
528 |     velocity_z: f32,
529 | ) {
530 |     let psd = get_mutable_physics_solver();
531 |     let rb = psd.rigid_body_set.get_mut(rb_handle.into()).unwrap();
532 |     rb.set_linvel(vector![velocity_x, velocity_y, velocity_z], true);
533 | }
534 | 
535 | #[unsafe(no_mangle)]
536 | extern "C" fn set_angular_velocity(
537 |     rb_handle: SerializableRigidBodyHandle,
538 |     velocity_x: f32,
539 |     velocity_y: f32,
540 |     velocity_z: f32,
541 | ) {
542 |     let psd = get_mutable_physics_solver();
543 |     let rb = psd.rigid_body_set.get_mut(rb_handle.into()).unwrap();
544 |     rb.set_angvel(vector![velocity_x, velocity_y, velocity_z], true);
545 | }
546 | 
547 | #[unsafe(no_mangle)]
548 | extern "C" fn get_linear_velocity(rb_handle: SerializableRigidBodyHandle) -> Vector3<f32> {
549 |     let psd = get_mutable_physics_solver();
550 |     let rb = psd.rigid_body_set.get(rb_handle.into()).unwrap();
551 |     rb.linvel().clone()
552 | }
553 | 
554 | #[unsafe(no_mangle)]
555 | extern "C" fn get_angular_velocity(rb_handle: SerializableRigidBodyHandle) -> Vector3<f32> {
556 |     let psd = get_mutable_physics_solver();
557 |     let rb = psd.rigid_body_set.get(rb_handle.into()).unwrap();
558 |     rb.angvel().clone()
559 | }
560 | 
561 | // Add Force
562 | #[unsafe(no_mangle)]
563 | extern "C" fn add_force(
564 |     rb_handle: SerializableRigidBodyHandle,
565 |     force_x: f32,
566 |     force_y: f32,
567 |     force_z: f32,
568 |     mode: ForceMode,
569 | ) {
570 |     let psd = get_mutable_physics_solver();
571 |     let rb = psd.rigid_body_set.get_mut(rb_handle.into()).unwrap();
572 |     let mut linvel = rb.linvel().clone();
573 |     match mode {
574 |         ForceMode::Force => {
575 |             linvel +=
576 |                 vector![force_x, force_y, force_z] * psd.integration_parameters.dt / rb.mass();
577 |         }
578 |         ForceMode::Impulse => {
579 |             linvel += vector![force_x, force_y, force_z] / rb.mass();
580 |         }
581 |         ForceMode::VelocityChange => {
582 |             linvel += vector![force_x, force_y, force_z];
583 |         }
584 |         ForceMode::Acceleration => {
585 |             linvel += vector![force_x, force_y, force_z] * psd.integration_parameters.dt;
586 |         }
587 |     }
588 |     // log::info!("linvel: {:?}, mode: {:?}", linvel, mode);
589 |     rb.set_linvel(linvel, true);
590 | }
591 | 
592 | #[unsafe(no_mangle)]
593 | extern "C" fn add_torque(
594 |     rb_handle: SerializableRigidBodyHandle,
595 |     torque_x: f32,
596 |     torque_y: f32,
597 |     torque_z: f32,
598 |     mode: ForceMode,
599 | ) {
600 |     let psd = get_mutable_physics_solver();
601 |     let rb = psd.rigid_body_set.get_mut(rb_handle.into()).unwrap();
602 |     let mut angvel = rb.angvel().clone();
603 |     match mode {
604 |         ForceMode::Force => {
605 |             angvel +=
606 |                 vector![torque_x, torque_y, torque_z] * psd.integration_parameters.dt / rb.mass();
607 |         }
608 |         ForceMode::Impulse => {
609 |             angvel += vector![torque_x, torque_y, torque_z] / rb.mass();
610 |         }
611 |         ForceMode::VelocityChange => {
612 |             angvel += vector![torque_x, torque_y, torque_z];
613 |         }
614 |         ForceMode::Acceleration => {
615 |             angvel += vector![torque_x, torque_y, torque_z] * psd.integration_parameters.dt;
616 |         }
617 |     }
618 |     rb.set_angvel(angvel, true);
619 | }
620 | 
621 | #[unsafe(no_mangle)]
622 | pub extern "C" fn set_integration_parameters(
623 |     // Time step
624 |     dt: f32,
625 |     // Solver parameters
626 |     solver_iterations: usize,
627 |     solver_pgs_iterations: usize,
628 |     solver_additional_friction_iterations: usize,
629 |     solver_stabilization_iterations: usize,
630 |     ccd_substeps: usize,
631 |     // Damping parameters
632 |     contact_damping_ratio: f32,
633 |     joint_damping_ratio: f32,
634 |     // Frequency parameters
635 |     contact_frequency: f32,
636 |     joint_frequency: f32,
637 |     // Prediction parameters
638 |     prediction_distance: f32,
639 |     max_corrective_velocity: f32,
640 |     // Length unit
641 |     length_unit: f32,
642 | ) {
643 |     use std::num::NonZeroUsize;
644 | 
645 |     let psd = get_mutable_physics_solver();
646 |     psd.integration_parameters.dt = dt;
647 |     psd.integration_parameters.min_ccd_dt = dt / 100.0;
648 |     psd.integration_parameters.num_solver_iterations =
649 |         NonZeroUsize::new(solver_iterations as usize).unwrap_or(NonZeroUsize::new(4).unwrap());
650 |     psd.integration_parameters.num_internal_pgs_iterations = solver_pgs_iterations;
651 |     psd.integration_parameters
652 |         .num_additional_friction_iterations = solver_additional_friction_iterations;
653 |     psd.integration_parameters
654 |         .num_internal_stabilization_iterations = solver_stabilization_iterations;
655 |     psd.integration_parameters.max_ccd_substeps = ccd_substeps;
656 |     psd.integration_parameters.contact_damping_ratio = contact_damping_ratio;
657 |     psd.integration_parameters.joint_damping_ratio = joint_damping_ratio;
658 |     psd.integration_parameters.contact_natural_frequency = contact_frequency;
659 |     psd.integration_parameters.joint_natural_frequency = joint_frequency;
660 |     psd.integration_parameters.normalized_prediction_distance = prediction_distance;
661 |     psd.integration_parameters
662 |         .normalized_max_corrective_velocity = max_corrective_velocity;
663 |     psd.integration_parameters.length_unit = length_unit;
664 | }
665 | 
666 | // Scene Query
667 | #[repr(C)]
668 | #[derive(Debug, Clone, Copy)]
669 | struct RaycastHit {
670 |     m_point: Vector3<f32>,
671 |     m_normal: Vector3<f32>,
672 |     m_face_id: u32,
673 |     m_distance: f32,
674 |     m_uv: Vector2<f32>,
675 |     m_collider: SerializableColliderHandle,
676 | }
677 | 
678 | #[unsafe(no_mangle)]
679 | extern "C" fn cast_ray(
680 |     from_x: f32,
681 |     from_y: f32,
682 |     from_z: f32,
683 |     dir_x: f32,
684 |     dir_y: f32,
685 |     dir_z: f32,
686 |     out_hit: *mut RaycastHit,
687 | ) -> bool {
688 |     let psd = get_mutable_physics_solver();
689 |     let ray = Ray::new(point![from_x, from_y, from_z], vector![dir_x, dir_y, dir_z]);
690 |     if let Some((handle, intersection)) = psd.query_pipeline.cast_ray_and_get_normal(
691 |         &psd.rigid_body_set,
692 |         &psd.collider_set,
693 |         &ray,
694 |         4.0,
695 |         true,
696 |         QueryFilter::default(),
697 |     ) {
698 |         let point = ray.point_at(intersection.time_of_impact);
699 |         let normal = intersection.normal;
700 |         let face_id = match intersection.feature {
701 |             FeatureId::Face(id) => id,
702 |             FeatureId::Vertex(id) => id,
703 |             FeatureId::Edge(id) => id,
704 |             _ => 0,
705 |         };
706 |         let distance = intersection.time_of_impact;
707 |         let uv = vector![0.0, 0.0];
708 |         let hit = RaycastHit {
709 |             m_point: point.coords,
710 |             m_normal: normal,
711 |             m_face_id: face_id,
712 |             m_distance: distance,
713 |             m_uv: uv,
714 |             m_collider: handle.into(),
715 |         };
716 |         unsafe {
717 |             *out_hit = hit;
718 |         }
719 |         true
720 |     } else {
721 |         false
722 |     }
723 | }
724 | 
725 | #[repr(C)]
726 | #[derive(Debug, Clone, Copy)]
727 | pub enum ForceMode {
728 |     Force = 0,
729 |     Impulse = 1,
730 |     VelocityChange = 2,
731 |     Acceleration = 5,
732 | }
733 | 
734 | #[repr(C)]
735 | #[derive(Debug, Clone, Copy)]
736 | struct RapierTransform {
737 |     rotation: Vector4<f32>,
738 |     position: Vector<f32>,
739 | }
740 | 
741 | // PhysicsSolverData is a struct that holds all the data needed to solve physics.
742 | pub struct PhysicsSolverData<'a> {
743 |     pub gravity: Vector<f32>,
744 |     pub integration_parameters: IntegrationParameters,
745 |     pub physics_pipeline: PhysicsPipeline,
746 |     pub island_manager: IslandManager,
747 |     pub broad_phase: DefaultBroadPhase,
748 |     pub narrow_phase: NarrowPhase,
749 |     pub impulse_joint_set: ImpulseJointSet,
750 |     pub multibody_joint_set: MultibodyJointSet,
751 |     pub ccd_solver: CCDSolver,
752 |     pub query_pipeline: QueryPipeline,
753 |     pub physics_hooks: &'a dyn PhysicsHooks,
754 |     pub event_handler: &'a dyn EventHandler,
755 | 
756 |     pub rigid_body_set: RigidBodySet,
757 |     pub collider_set: ColliderSet,
758 | }
759 | 
760 | impl Default for PhysicsSolverData<'_> {
761 |     fn default() -> Self {
762 |         let mut integration_parameters = IntegrationParameters::default();
763 |         integration_parameters.dt = 1.0 / 50.0;
764 |         integration_parameters.min_ccd_dt = 1.0 / 50.0 / 100.0;
765 |         PhysicsSolverData {
766 |             gravity: vector![0.0, -9.81, 0.0],
767 |             integration_parameters,
768 |             physics_pipeline: PhysicsPipeline::new(),
769 |             island_manager: IslandManager::new(),
770 |             broad_phase: DefaultBroadPhase::new(),
771 |             narrow_phase: NarrowPhase::new(),
772 |             impulse_joint_set: ImpulseJointSet::new(),
773 |             multibody_joint_set: MultibodyJointSet::new(),
774 |             ccd_solver: CCDSolver::new(),
775 |             query_pipeline: QueryPipeline::new(),
776 |             physics_hooks: &(),
777 |             event_handler: &(),
778 | 
779 |             rigid_body_set: RigidBodySet::new(),
780 |             collider_set: ColliderSet::new(),
781 |         }
782 |     }
783 | }
784 | 
785 | #[repr(C)]
786 | #[derive(Debug, Clone, Copy)]
787 | struct SerializableCollisionEvent {
788 |     collider1: SerializableColliderHandle,
789 |     collider2: SerializableColliderHandle,
790 |     is_started: bool,
791 | }
792 | 
793 | impl PhysicsSolverData<'_> {
794 |     fn solve(&mut self) -> Vec<SerializableCollisionEvent> {
795 |         let (collision_send, collision_recv) = crossbeam::channel::unbounded();
796 |         let (contact_force_send, _contact_force_recv) = crossbeam::channel::unbounded();
797 |         let event_handler = ChannelEventCollector::new(collision_send, contact_force_send);
798 | 
799 |         self.physics_pipeline.step(
800 |             &self.gravity,
801 |             &self.integration_parameters,
802 |             &mut self.island_manager,
803 |             &mut self.broad_phase,
804 |             &mut self.narrow_phase,
805 |             &mut self.rigid_body_set,
806 |             &mut self.collider_set,
807 |             &mut self.impulse_joint_set,
808 |             &mut self.multibody_joint_set,
809 |             &mut self.ccd_solver,
810 |             Some(&mut self.query_pipeline),
811 |             &(),
812 |             &event_handler,
813 |         );
814 | 
815 |         let mut collision_events = Vec::new();
816 |         while let Ok(collision_event) = collision_recv.try_recv() {
817 |             if collision_event.started() {
818 |                 collision_events.push(SerializableCollisionEvent {
819 |                     collider1: collision_event.collider1().into(),
820 |                     collider2: collision_event.collider2().into(),
821 |                     is_started: true,
822 |                 });
823 |             } else if collision_event.stopped() {
824 |                 collision_events.push(SerializableCollisionEvent {
825 |                     collider1: collision_event.collider1().into(),
826 |                     collider2: collision_event.collider2().into(),
827 |                     is_started: false,
828 |                 });
829 |             } else {
830 |                 log::warn!("Unknown collision event: {:?}", collision_event);
831 |             }
832 |         }
833 | 
834 |         collision_events
835 |     }
836 | }
837 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/rapierbind/src/utils.rs:
--------------------------------------------------------------------------------
 1 | use rapier3d::prelude::{LockedAxes, RigidBody};
 2 | 
 3 | /// Converts Unity RigidbodyConstraints enum value to Rapier LockedAxes
 4 | pub fn unity_constraints_to_locked_axes(constraints: u32) -> LockedAxes {
 5 |     // Unity's constraints are shifted 1 bit left compared to our LockedAxes
 6 |     // We need to map:
 7 |     // - bits 1,2,3 (positions) → 0,1,2
 8 |     // - bits 4,5,6 (rotations) → 3,4,5
 9 | 
10 |     // Extract the position flags (bits 1-3) and shift right
11 |     let pos_flags = (constraints & 0b1110) >> 1;
12 | 
13 |     // Extract the rotation flags (bits 4-6) and shift right
14 |     let rot_flags = (constraints & 0b1111000) >> 1;
15 | 
16 |     // Combine the flags
17 |     LockedAxes::from_bits_truncate((pos_flags | rot_flags) as u8)
18 | }
19 | 
20 | /// Converts Rapier LockedAxes to Unity RigidbodyConstraints enum value
21 | pub fn locked_axes_to_unity_constraints(locked_axes: LockedAxes) -> u32 {
22 |     // Convert LockedAxes to Unity constraints by shifting left
23 |     // - bits 0,1,2 (translation) → 1,2,3
24 |     // - bits 3,4,5 (rotation) → 4,5,6
25 | 
26 |     // Get the raw bits
27 |     let bits = locked_axes.bits() as u32;
28 | 
29 |     // Shift left by 1 to match Unity's bit positions
30 |     bits << 1
31 | }
32 | 
33 | pub fn cancel_axis_velocity(current_locks: LockedAxes, rigidbody: &mut RigidBody) {
34 |     // Cancel the velocity for locked translation axes
35 |     let mut linvel = *rigidbody.linvel();
36 | 
37 |     if current_locks.contains(LockedAxes::TRANSLATION_LOCKED_X) {
38 |         linvel[0] = 0.0;
39 |     }
40 |     if current_locks.contains(LockedAxes::TRANSLATION_LOCKED_Y) {
41 |         linvel[1] = 0.0;
42 |     }
43 |     if current_locks.contains(LockedAxes::TRANSLATION_LOCKED_Z) {
44 |         linvel[2] = 0.0;
45 |     }
46 |     rigidbody.set_linvel(linvel, false);
47 | 
48 |     // Cancel the velocity for locked rotation axes
49 |     let mut angvel = *rigidbody.angvel();
50 |     if current_locks.contains(LockedAxes::ROTATION_LOCKED_X) {
51 |         angvel[0] = 0.0;
52 |     }
53 |     if current_locks.contains(LockedAxes::ROTATION_LOCKED_Y) {
54 |         angvel[1] = 0.0;
55 |     }
56 |     if current_locks.contains(LockedAxes::ROTATION_LOCKED_Z) {
57 |         angvel[2] = 0.0;
58 |     }
59 |     rigidbody.set_angvel(angvel, false);
60 | }
61 | 


--------------------------------------------------------------------------------
/source~/rapier-c-bind/readme.md:
--------------------------------------------------------------------------------
 1 | 
 2 | Release Build the dylib file and move it to the build_bin folder
 3 | ```shell
 4 | cargo build -r
 5 | mkdir ../../build_bin
 6 | mv target/release/librapier_c_bind.dylib ../../build_bin/
 7 | ```
 8 | 
 9 | Debug Build the dylib file and move it to the build_bin folder
10 | ```shell
11 | cargo build
12 | mv target/debug/librapier_c_bind.dylib ../../build_bin/
13 | mv target/debug/librapier_c_bind.d ../../build_bin/
14 | ```
15 | 
16 | Find the symbols in the dylib file
17 | ```shell
18 | nm -gU target/release/librapier_c_bind.dylib
19 | ```


--------------------------------------------------------------------------------
/source~/rapier-c-bind/unitybridge/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "unitybridge"
 3 | version = "0.1.0"
 4 | edition = "2024"
 5 | 
 6 | [lib]
 7 | crate-type = ["staticlib", "cdylib", "rlib"]
 8 | 
 9 | [dependencies]
10 | log = "0.4.27"
11 | 
12 | [target.aarch64-linux-android]
13 | rustflags = [
14 |     "-Clink-args=-Wl,-z,max-page-size=16384",
15 |     "-Clink-args=-Wl,-z,common-page-size=16384",
16 |     "-Clink-args=-Wl,--script=./android_linker.ld"
17 | ]


--------------------------------------------------------------------------------
/source~/rapier-c-bind/unitybridge/src/lib.rs:
--------------------------------------------------------------------------------
  1 | use std::ffi::{c_char, CString};
  2 | use std::os::raw::c_ulonglong;
  3 | use log::{Level, Metadata, Record};
  4 | 
  5 | #[repr(C,packed)]
  6 | #[allow(non_snake_case)]
  7 | struct IUnityInterfaces
  8 | {
  9 |     pub GetInterface: Option<unsafe extern "system" fn(guid: *const UnityInterfaceGUID) -> *mut IUnityInterface>,
 10 |     pub RegisterInterface: Option<unsafe extern "system" fn(guid: UnityInterfaceGUID, ptr: *mut IUnityInterface)>,
 11 |     pub GetInterfaceSplit: Option<unsafe extern "system" fn(guidHigh: c_ulonglong, guidLow: c_ulonglong) -> *mut IUnityInterface>,
 12 |     pub RegisterInterfaceSplit: Option<unsafe extern "system" fn(guidHigh: c_ulonglong, guidLow:c_ulonglong, ptr: *mut IUnityInterface)>,
 13 | }
 14 | 
 15 | #[repr(C,packed)]
 16 | struct IUnityInterface {
 17 |     pub add: u8,
 18 | }
 19 | 
 20 | #[repr(C,packed)]
 21 | #[derive(Default, Copy, Clone)]
 22 | pub struct UnityInterfaceGUID {
 23 |     pub m_guidhigh: ::std::os::raw::c_ulonglong,
 24 |     pub m_guidlow: ::std::os::raw::c_ulonglong,
 25 | }
 26 | 
 27 | // IUnityLog (0x9E7507fA5B444D5D, 0x92FB979515EA83FC)
 28 | const IUNITY_LOG_GUID: UnityInterfaceGUID =  UnityInterfaceGUID{m_guidhigh:0x9E7507fA5B444D5D_u64, m_guidlow:0x92FB979515EA83FC_u64};
 29 | #[repr(C,packed)]
 30 | #[allow(non_snake_case)]
 31 | pub struct IUnityLog
 32 | {
 33 |     pub(crate) Log: extern "system" fn(ttype: UnityLogType, message: *const c_char, fileName: *const c_char, fileLine: i32),
 34 | }
 35 | 
 36 | #[repr(u32)]
 37 | enum UnityLogType
 38 | {
 39 |     Error = 0,
 40 |     Warning = 2,
 41 |     Log = 3,
 42 |     // Exception = 4,
 43 | }
 44 | 
 45 | pub struct UnityLogger;
 46 | 
 47 | impl log::Log for UnityLogger {
 48 |     fn enabled(&self, metadata: &Metadata) -> bool {
 49 |         metadata.level() <= Level::Info
 50 |     }
 51 | 
 52 |     fn log(&self, record: &Record) {
 53 |         if self.enabled(record.metadata()) {
 54 |             let log_type = match record.metadata().level() {
 55 |                 Level::Error => UnityLogType::Error,
 56 |                 Level::Warn => UnityLogType::Warning,
 57 |                 Level::Info => UnityLogType::Log,
 58 |                 Level::Debug => UnityLogType::Log,
 59 |                 Level::Trace => UnityLogType::Log,
 60 |             };
 61 |             
 62 |             let message = CString::new(record.args().to_string()).unwrap();
 63 |             let file = file!();
 64 |             let line = line!();
 65 |             unsafe {
 66 |                 let log = (*UNITY_LOG_PTR).Log;
 67 |                 let val = CString::new(file).unwrap();
 68 |                 log(log_type, message.as_ptr(), val.as_ptr(), line as i32);
 69 |             }
 70 |         }
 71 |     }
 72 | 
 73 |     fn flush(&self) {}
 74 | }
 75 | 
 76 | static mut UNITY_LOG_PTR: *const IUnityLog = std::ptr::null();
 77 | 
 78 | #[unsafe(no_mangle)]
 79 | #[allow(non_snake_case)]
 80 | extern "system" fn UnityPluginLoad(unityInterfacesPtr: *mut IUnityInterfaces)
 81 | {
 82 |     unsafe {
 83 |         let getInterface = (*unityInterfacesPtr).GetInterface;
 84 |         UNITY_LOG_PTR = getInterface.expect("Couldn't get unity interface log")(&IUNITY_LOG_GUID) as *const IUnityLog;
 85 |         let _ = log::set_logger(&UnityLogger).map(|()| log::set_max_level(Level::Info.to_level_filter()));
 86 |         log::trace!("Unity logger loaded");
 87 |     }
 88 | }
 89 | 
 90 | #[unsafe(no_mangle)]
 91 | #[allow(non_snake_case)]
 92 | extern "C" fn GetDefaultUnityLogger() -> *const IUnityLog
 93 | {
 94 |     unsafe {
 95 |         UNITY_LOG_PTR
 96 |     }
 97 | }
 98 | 
 99 | #[unsafe(no_mangle)]
100 | #[allow(non_snake_case)]
101 | pub fn AssignUnityLogger(logger: *const IUnityLog)
102 | {
103 |     unsafe {
104 |         UNITY_LOG_PTR = logger;
105 |         let _ = log::set_logger(&UnityLogger).map(|()| log::set_max_level(Level::Info.to_level_filter()));
106 |     }
107 | }
108 | 
109 | #[unsafe(no_mangle)]
110 | #[allow(non_snake_case)]
111 | extern "system" fn UnityPluginUnload() {
112 |     log::trace!("Unity logger unloaded");
113 |     unsafe {
114 |         UNITY_LOG_PTR = std::ptr::null();
115 |     }
116 | }


--------------------------------------------------------------------------------