Skip to content

A deterministic physics simulation using Verlet algorithm in Godot 4.0

License

Notifications You must be signed in to change notification settings

svdragster/Godot-Verlet-Solver

Repository files navigation

Godot Verlet Solver

A Verlet Algorithm implemented in Godot 4 with some examples. My long term goal is to create a deterministic physics engine where an equal input always results in the same output.

Example

When running the simulation with the exact same input, the circles will always end up in the same positions with the same rotations:

GodotVerletProject.mp4
GodotVerletProject_3d.webm

Examples can be found in the example directory. (3D solver is currently developed in 3d branch)

How it works

All children are updated in _physics_process with multiple substeps. _physics_process is run with a fixed timestep (default is 60 times per second).

func _physics_process(delta : float) -> void:
	var sub_delta : float = delta / substeps
	for i in range(substeps):
		check_collisions(sub_delta)
		update_constraints(sub_delta)
	update_objects(delta)	

This is the main implementation of the algorithm. The next position is always based on the last position.

func update(delta : float):
  var velocity : Vector2 = (position - last_position) * friction
  var new_position : Vector2 = position + velocity + (acceleration*40) * (delta * delta)
  [...]

Using Godots Shape objects, I implemented a basic collision handling to update velocity and angular velocity.

var contacts := shape_a.collide_and_get_contacts(object_a.transform, shape_b, object_b.transform)
var contact_amount = contacts.size() / 2
if contact_amount >= 1:
  for i in range(0, contacts.size(), 2):
    # Solve collision

Limitations

  1. It's currently not very realistic. Using more realistic equations (friction, intertia, mass) to solve collisions should be pretty easy to implement.
  2. Currently, Godot 64-bit double-precision floats are used for calculations (equal to double in C++). For data structures such as Vector2 and Vector3, Godot uses 32-bit floating-point numbers (Source: https://docs.godotengine.org/de/stable/classes/class_float.html). This could result in different behaviour on different machines. My long term goal is to use fixed point numbers so the calculations will behave the same on all systems.

Goals

These are somwhat in order

  • WIP: support more shapes for collisions (2d currently supports spheres and rectangles, see directory verlet2d/shapes)
  • WIP: 3d implementation (see branch 3d https://github.com/svdragster/GodotVerletSolver/tree/3d/verlet3d)
  • add fixed point numbers
  • use chunk system for collisions
  • multithreading chunks
  • Implement in GDExtension (C++) for better performance

About

A deterministic physics simulation using Verlet algorithm in Godot 4.0

Topics

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published