Jolt Physics raylib: trying 3D C++ Game Physics Engine 🎱 # Jolt Physics raylib: trying 3D C++ Game Physics Engine 🎱 #

⚡️ Jolt Learning Resources #

Jolt is a modern, fully featured game physics engine  with cross-platform and WASM support. It uses C++17 and there are also Zig bindings. There is also a Godot drop-in physics engine  replacement extension for Godot 4.2.

The quickest way to get going is probably to build the CMake Jolt hello world sample  . That sample simulates a sphere dropping onto a static surface. It just outputs the sphere velocity and position to the console, which makes it quicker to start on and allows you to bring your own graphics rendering (which is what we do later in this post).

Jolt has fantastic documentation. In fact, even if you are not interested in trying it, but want to learn more about how physics engines work, the docs are worth a read. See the section on how Jolt implements Collision Detection  , for example.

🤔 Other C++ Game Physics Engines #

• Box2D  : 2D engine used in Unity and also earlier versions of Godot. Open source.
• Bullet  : C++ 2003 physics engine available in Godot 3. Open source.
• Havoc  : Physics engine used on Call of Duty games and other well-known games. Proprietary licensing.
• PhysX  : mature C++ physics engine from NVIDIA, used in Unreal Engine and Unity 3D. Open source.

🧱 What I Built #

The Jolt Hello World example is a good starting point. It is stand-alone and outputs the updated positions to the Terminal. I wanted something more visual, so added Jolt to the raylib Dear ImGui demo I built previously. The physics code I wrote is only a small extension on Jolt demo. I added restitution to the sphere, so that it bounces, and changed up the initial velocity a little for a better visual example.

🖥️ Jolt Physics raylib #

I made minimal changes to the Hello World CMake file, and you can follow the link, further down, to see the full code.

To make cleaner code, I abstracted Jolt into a class, then just called the update method from the main game loop. This got an updated ball position from Jolt, ready to render the ball in its new position for the next frame.

    
1 int main()
2 {
3     // ... TRUNCATED
4 
5     spdlog::info("Creating Physics Engine");
6     PhysicsEngine physics_engine{};
7 
8     spdlog::info("Initialising Physics Engine");
9     physics_engine.initialise();
10 
11     spdlog::info("Creating floor");
12     physics_engine.create_floor(floor_dimensions, floor_position);
13 
14     spdlog::info("Creating ball");
15     physics_engine.create_ball(constants::kBallRadius,
16                                sphere_position,
17                                sphere_velocity);
18 
19     spdlog::info("Initiating Pre-simulation Optimisation");
20     physics_engine.start_simulation();
21 
22     SetTargetFPS(constants::kTargetFramerate);
23 
24     spdlog::info("Starting Simulation");
25     while (!WindowShouldClose())
26     {
27         // TRUNCATED...
28         BeginDrawing();
29         draw_scene(camera,
30                     sphere_position,
31                     constants::kSphereColours[static_cast<size_t>(
32                         selected_sphere_colour)],
33                     font);
34         EndDrawing();
35 
36         // advance the physics engine one step and get the updated sphere_position
37         physics_engine.update(frame_time, sphere_position);
38     }
39 
40     spdlog::info("Preparing Physics Engine for Shutdown");
41     physics_engine.cleanup();
42 
43     return 0;
44 }

  

🙌🏽 Jolt Physics raylib: Wrapping Up #

In this Jolt physics raylib post, we had an introduction to the Jolt physics engine and using it with raylib. More specifically, we saw:

• how you can use Jolt with raylib;
• some resources for getting started with Jolt; and
• Hello World C++ code for using Jolt with raylib.

I hope you found this useful. As promised, you can get the full project code on the Rodney Lab GitHub repo  . Of course, we have only looked at the basics here. As a next step, you might want to add some physics introspection and the ability to pause step incrementally, ready for any debugging you might need to do on your game physics. Do let me know how you use this code. Also reach out if there is anything I could improve to provide a better experience for you.

🙏🏽 Jolt Physics raylib: Feedback #

If you have found this post useful, see links below for further related content on this site. Let me know if there are any ways I can improve on it. I hope you will use the code or starter in your own projects. Be sure to share your work on X, giving me a mention, so I can see what you did. Finally, be sure to let me know ideas for other short videos you would like to see. Read on to find ways to get in touch, further below. If you have found this post useful, even though you can only afford even a tiny contribution, please consider supporting me through Buy me a Coffee.

Rodney

@askRodney

Just dropped a new blog post on using Jolt physics with raylib and Dear ImGui in C++.

The post includes:

— CMake config;

— resources for learning Jolt physics; and

— a link to the full project code.

Hope you find it useful!

#askRodneyhttps://t.co/eddSsCUlTD

— Rodney (@askRodney) April 3, 2024

Finally, feel free to share the post on your social media accounts for all your followers who will find it useful. As well as leaving a comment below, you can get in touch via @askRodney on X (previously Twitter) and also, join the #rodney  Element Matrix room. Also, see further ways to get in touch with Rodney Lab. I post regularly on Game Dev as well as Rust and C++ (among other topics). Also, subscribe to the newsletter to keep up-to-date with our latest projects.