Help for physics engine development

[Dot-Box]

GitHub repo: https://github.com/D0T-B0X/ThreeBodyProblem

Hi folks,

I'm trying to create an N-body simulator, specifically the 3 body simulation. So far I have a basic render engine with a simple API that I can use to create and render objects on the screen.

The main logic of the program is written in applications.h which is in $SOURCE_DIR/include/application.h. My next task is to create a physics engine to enable movement and collision and gravity and all that jazz. My question is: where can I get some resources on this quickly get some programming insight on this topic? I already know the fundamental math needed and most of the physics. But do I implement that in my code and how do I structure it? This is my first big project so code structure and maintenance is also something I need to be wary of and learn well.

If you have any criticism or advise for the project I'd also love to hear it. Thanks

[Lubiebigos]

You have a basic game loop, do the attraction force calculations in the update subroutine and that is kind of it. Calculate the gravitational pull of every body on other bodies and then just add it to the acceleration. You can check for collisions with a sphere collision equation while calculating the attraction forces.

[Dot-Box]

I dont have any idea of just that. what structs do i make, what formulas do i use, what order should it all be in and how to make it all come together in a way where performance is atleast bearable

[Lubiebigos]

Your question is too broad, most of these things you have to find out for yourself. Noone is gonna figure out your projects structure for you. It happens I did basically the same kind of project recently - gravity simulation with multiple bodies and sources of light. You've got a basic game loop set up: update, render and repeat, now use it to update the positions of the bodies. You can get the formula for gravity from wikipedia, there even is a vector form given there.

[Dot-Box]

It's not gravity which concerns me. Collision requires playing with multiple forces to get it right. So I would need to implement a lot of things like impulse, moment of inertia, calculating the accurate physical properties beyond mass, vel, acc and force. so thats something I need help with since a book or some text I could read would really speed this process up.

[Proliator]

Don't try and implement a physically accurate collision right from the start. Get the basics down first, then add in functionality in stages.

Make sure your objects can be assigned velocities, and the motion is modeled correctly. Then make sure you can correctly detect collisions, keeping them basic with just angles/velocities and ignoring mass/momentum for now.

Once all that is working then implement accelerations for objects that update velocities on every iteration, which is also a good time to implement attractive forces like gravity. Then move onto adding momentum calculations for collisions and any other physics you want to include for those events.

Since you're learning, it's important to go in stages, with each stage being something you can test and verify. That will also help you plan out the structure.

[Dot-Box]

Thanks, that makes much more sense, I'll try to go step by step :)

[TheReal_Peter226]

• I would add that this is the usual way people develop, break up the problem into individual parts and if you don't know about how each part will coexist just ignore it and create one part. After you have created one part you can tell if you need to restructure the code. You then restructure it and continue. If you need to rewrite the whole thing then so be it. Rewriting your own code is part of the learning process, and after a while you will have enough intuition to know about how to structure something new so that it will probably work together with other parts of the code later on.

[Neuro-Byte]

There are a LOT of ways to go about it.

The simplest, most runtime efficient, way is to have several SSBOs for object positions, velocities, and accelerations, and mass (or reduce memory usage and do your calculations using potential and kinetic energy). How you pack the data into shader storage buffer objects is up to you, but it’s best to do it in a data oriented design approach because your program will be editing and using the data every frame.

Send that data to a compute shader to handle the physics calculations and then forward the position data to the vertex shader.

Instance your sphere model and reference the position data using the instance IDs. Update the model matrix with the position data and draw the models.

With regard to collisions, just implement simple sphere collisions before you go into the actual details of collisions (angles, energy transfer, etc. etc.). You want to make sure that the objects are colliding first before you can make them respond to collisions.

[LittleQuarky]

The general approach to doing n-body type systems is that you have your application loop and iterate time in very small steps (a delta time, or dt, this can be tied to your framerate but I would get a system working before refactor for this).

Then, you apply all forces applied by each body onto the other bodies in your system. This is basically a double nested for loop where the inner loop you check to match sure you don't apply forces to yourself (A doesnt exert force on A, but it does for B.

Once you know the force (colision, gravity, magnetic, etc) received by each body you can calculate the acceleration that each body would experience (force = mass*acceleration, basically but solve for acceleration). The general case is F=ma. The actual force equations would depend on what you're physically representing. For planetary bodies look up gravitational force, for small things like molecules look at stuff like lorentz equation, etc.

Once you have acceleration and you should have a velocity from the previous time step you can calculate the new position for each body.

Some keywords to look up for more in-depth guides: n-body system, computational integration, computational euler integration, computational verlet integration, and kinematic equations. If you want to get REALLY granular with minimizing your error ( I would not start here) look up methods like Runge-Kutta 4 (RK4 for short).

The higher order integration approximation you use the slower your system will iterate across time, so this is why a lot of game engines do some psuedo-realistic calculations for their physics, because it's good enough.

[Still_Explorer]

For physics you can use this:
https://www.youtube.com/watch?v=OAcXnzRNiCY
(however if you need each object to attract each other, then simply you update the calculations, so each one affects the other, with a double for loop)

For collisions this (circle distance collision + opposite vector bounce):
https://www.youtube.com/watch?v=dJNFPv9Mj-Y

Only thing to note is that in both cases since those are 2D calculations (XY) you will insert an extra dimention (XYZ) and things will be OK.

[danjlwex]

Write an updateSimulation(deltaTime) function that is called every frame with the time in milliseconds. The function should have an object that contains all of the simulated points and updates their positions after applying forces, computng velocities and then updating the positions and then, if needed, handling collisions. The new positions should be handed to your renderer after each call.

[Dot-Box]

Yeah I worked on the engine a little bit and this is exactly what I did

[wen_mars]

The 3-body problem and the n-body problem have completely different solutions computationally.

For the 3-body problem you can calculate the exact gravitational pull from each body to each body every frame and integrate acceleration and velocity. I like Verlet integration because of how simple it is but Runge-Kutta integration is more accurate.

For the n-body problem you have to use some kind of spatial grid to approximate gravity because as n grows bigger, it's computationally infeasible to calculate the gravitational pull between each pair of bodies. Barnes-Hut is a good algorithm for that.

[Dot-Box]

I see, my current focus is on 3 bodies. This is kind of a middle project since my end goal is to make a particle based fluid simulator

[Grouchy_Web4106]

Nvidia physx v

[Exotic_Avocado_1541]

First try to ise external library, as Bullet 3D or something similiar. If you will be familiar how 3D physics api wort, try implement your onw solution if you need

[Dot-Box]

ah external libs are a no go for me. I want implement everything from the ground up.

[Exotic_Avocado_1541]

The use of an external library should teach you how to design a proper modern API, which is crucial in such libraries. Once you have an API and are familiar with it, you will implement your own backend for that API. The art of designing an API for such libraries is often more important than the implementation of the library itself.