Jorrit Rouwe

@dzmitryj_ Unfortunately the GPU raycasts never made it because the overhead of going to the GPU and back was too much at the time. Someday they will be back though!

@jrouwe Can't wait to implement the first case of the GPU Solver in UE5. the raytraces are definitely hitting on tick.

Jolt Physics just hit 10K GitHub stars! What started in 2014 as a CPU vs GPU ray casting experiment became a full physics engine in 2021. Seeing what you’re building with it is amazing. Thank you!

@Ademola_4life You might be running out of memory. By default it uses a fixed memory pool which you can configure here: #L30-L37" target="_blank" rel="nofollow noopener">github.com/jrouwe/JoltPhy…

Anyone have good experience with Jolt physics on the web when handling large trimesh (something like sponza)? For me it just crashes, but rapier 3d handles that well

@BattleAxeVR No IK is not part of Jolt (I would categorize it under 'animation' rather than 'physics')

@BattleAxeVR You have to apply gravity, but the ground check is included. It's only a couple of lines of code: #L139-L174" target="_blank" rel="nofollow noopener">github.com/jrouwe/JoltPhy…

@BattleAxeVR Mirroring works too, see all the samples in the ScaledShape folder.

@BattleAxeVR Yes, adding automatic convex decomposition is on my rather large to do list.

@BattleAxeVR It references your original shape, so no triangles are duplicated. If you use non-uniform scale on CompoundShapes then it may create a new CompoundShape, but whatever is in the CompoundShape will not be duplicated.

@BattleAxeVR About the convex hulls: PhysX is using 'convex decomposition' (creating multiple convex hulls). Jolt only creates a single convex hull. You'll need another library to do the decomposition, e.g. github.com/SarahWeiii/CoA…

@BattleAxeVR There is the JoltViewer, but it doesn't connect over a socket like PVD does, it reads from a file that you can produce with DebugRendererRecorder. I usually just draw physics object in the game window using the DebugRenderer.

@BattleAxeVR You wrap a MeshShape in a ScaledShape (which is a tiny class). There's an example of dynamicaly scaling an object here: #L33-L54" target="_blank" rel="nofollow noopener">github.com/jrouwe/JoltPhy…

@BattleAxeVR What's wrong with the convex hull generation code? Send me the points that cause issues and I'll take a look. (Note that I did a tweak to the generator this week)

Early prototype of a real-time, physics-driven car deformation system built in Godot on top of Jolt Physics. All deformation is computed at runtime (no pre-baked damage), and it runs in real time on older mobile hardware. Video: youtu.be/5Msbd0XtCsg

@mannyn83 I have to still make an option for DX12 to directly load compiled shaders instead of compiling hlsl on the fly.

Thanks, one thing I noticed is the Map/Unmap which is not so great for WebGPU. It might be better to do a ReadAsync and WriteAsync that passes a lambda, the buffer is locked for the duration of the callback. Does Jolt want to create the program from it's own shader source? If so it would be good to allow this to be handled externally, eg Jolt requests the creation of a named shader and we can construct internally as we would store in our own packages where the FS is entirely virtual.

A sneak peak of what I've been working on: A strand based hair system for Jolt Physics (WIP): youtu.be/Rl19G0c003o

@mannyn83 > Does Jolt want to create the program from it's own shader source? CreateComputeShader(const char *inName, ...) passes in a name. Where you get the shader from is up to you. The default DX12 implementation uses mShaderLoader to load hlsl, Vulkan/Metal load compiled shaders.

@mannyn83 > Thanks, one thing I noticed is the Map/Unmap which is not so great for WebGPU Ok, I'll think about that.

@mannyn83 I did attempt to make that abstraction in a way that is hopefully easily integrated (with DX12, Vulkan and Metal implementations): github.com/jrouwe/JoltPhy…. Let me know what you think of it.

@jrouwe Nice! Would be great to have a generalized mechanism to dispatch compute, so we can properly integrate with our backend abstractions.

@datgame The 4ms is measured on GPU, the CPU part is about 0.1 ms (broad phase collision detection + setting up compute jobs). And it is indeed one way: physics objects affect the hair, but the hair doesn't affect the physics objects.

@jrouwe Yes :-) I see now the youtube title says "gpu", but i just assumed it to be "cpu" from the tweet. Guessing it makes it harder to measure on gpu? Also, this is for pure vfx? i.e. physics affect the hair, but not the other way around? So, no determinism to worry about either.

@datgame If you're talking about how fast it runs: Currently 4 ms on my 5070 Ti laptop GPU with the sim running at 360 Hz. I have to further optimize it though.

@jrouwe micro seconds counter please :-)

@SubstrataVr I've created support for DX12, Vulkan and Metal. Didn't do OpenGL, but it would certainly be possible.

@jrouwe Awesome. How does the GPU support work? Will it work with OpenGL?