erincatto

Imagine you are playing an open world game, like the Witcher. You ride your beautiful white steed towards the town with your hair blowing in the wind. But now your game hitches because it is loading 50k separate collision shapes for the town into the broad-phase, one-by-one. Your hair is no longer flowing and you quit the game because the stuttering sucks.

Now imagine the physics programmer created a mid-phase for those 50k shapes offline and put them all into one collision asset that gets loaded in the background. Then when you approach the town there is no hitching and your hair continues to nicely blow in the wind and you keep playing the game.

erincatto

Each thread has a bit set called awakeIslandBitSet. Each bit corresponds the awake island index. Before the solve, this bitset is all zeros.

When bodies are finalized, every body that is not sleepy will turn on the corresponding awakeIslandBitSet for the owning island. So this island cannot sleep.

On the other hand, if this body is sleepy and it is the sleepiest body, then it will make the owning island a candidate for splitting if the island has removed constraints.

This is the related code:

erincatto

Solver loop

for each sub step
  apply forces to update velocity (gravity)
  apply warm starting impulses
  apply impulses with position bias
  use velocity to update position
  apply impulses without position bias
end

erincatto

// Pool allocator with block size doubling
// https://danielchasehooper.com/posts/segment_array/

// The first block can hold this many items. Each subsequent block has double capacity.
#define BASE_BLOCK_ITEM_COUNT 32

// With 20 blocks the final block can hold 32 * (20^2 - 1) = 33,554,400 items
#define MAX_POOL_BLOCKS 20

erincatto

Option 1: static bodies

typedef struct b2StaticBodyDef
{
	/// The world position of the body. Avoid creating bodies at the origin
	/// since this can lead to many overlapping shapes.
	b2Vec2 position;

	/// The world angle of the body in radians.
	float angle;

erincatto

% This tests a two particle mass-spring-damper system with particle 1 connect to ground and 
% particle 2 connected to particle 1. Particle 2 is much heavier than particle 1 and the
% simulation can go unstable if the soft constraint is made too stiff.
% Stability is improved by adding a relaxation step that applies the rigid constraint after
% the position update.

% no relax stable up to 13.5 Hz
% with relax stable up to 20.5 Hz
relax = 1;
hertz = 20.5;

erincatto

struct b2CircleShape
{
    // circle stuff
};

struct b2PolygonShape
{
    // polygon stuff
};

erincatto

// SPDX-FileCopyrightText: 2022 Erin Catto
// SPDX-License-Identifier: MIT

#include <stdbool.h>
#include <stdio.h>
#include <assert.h>

#define RUN_TEST(T) \
	do { \
		int result = T(); \

erincatto

struct Foo
{
   int* data;
};

void DoStuff(const Foo& f)
{
   f.data[3] = 10;
}

erincatto

Given J*JT * x = b, solve for x in linear time and space.

J is m by n
x is m by 1
b is m by 1
m < n

J is a rectangular matrix that represents a tree with equal and opposite entries.

For example: