Recreate physics system

[LeXXik]

I am looking for a proper way to clean the physics system from any user objects. Perhaps even destroying it, and creating a fresh one. I've looked into the physics system interface, but it doesn't seem to have one. What would be a recommendation?

[kutu]

physicsSystem.RemoveStepListener(this.constraintListener);
physicsSystem.RemoveConstraint(this.constraint);
bodyInterface.RemoveBody(this.body.GetID());

[LeXXik]

Will this release memory inside Wasm? I think this would require a subsequent Jolt.destroy(obj) on some, like vectors, and not others? Would be nice to have something like physicsSystem.destroy() or .clear() to do a whole system sweep.

Edit: thinking about it, the physics system will not be able to know about allocated vectors, me thinks, so some bookkeeping would still be required, I suppose.

[kutu]

looking at this example https://github.com/jrouwe/JoltPhysics.js/blob/main/Examples/add_remove_bodies.html
non of the vectors being destroyed

and this is how bodies destroyed

JoltPhysics.js/Examples/js/example.js

Lines 180 to 189 in 7c22d4b

	function removeFromScene(threeObject) {
	let id = threeObject.userData.body.GetID();
	bodyInterface.RemoveBody(id);
	bodyInterface.DestroyBody(id);
	delete threeObject.userData.body;
	scene.remove(threeObject);
	let idx = dynamicObjects.indexOf(threeObject);
	dynamicObjects.splice(idx, 1);
	}

[LeXXik]

I believe it is done for the brevity of example. Also, the examples are structured in a way that the web page is closed when another example is switched, which destroys Wasm and all its contents, so no need for explicit cleaning.

Edit:
Try adding a loop inside your update method that creates a thousand new Jolt.Vec3(). You will get an out of memory crash in a few seconds. This isn't really Jolt related. We have to do this bookkeeping for any Emscripten based library. A rule of thumb - for any new keyword, there must be a subsequent Jolt.destroy(obj) when it is no longer needed (well, based on API, some methods will destroy objects for you, like the DestroyBody you showed). Allocate as little as possible, reuse already allocated as much as possible.

[LeXXik]

Perhaps, examples could be improved, by showing what can be destroyed immediately (e.g. temp vectors), and what should wait until the object is no longer needed.

For example, when we create a mesh shape, it is not immediately clear if we can reuse an allocated material list, should we wait with destroying it until the shape is destroyed first, or will it auto-destroy when the associated shape is destroyed. If implemented as in example, most probably it will keep floating in Wasm space even after shape is destroyed, until we close the webpage.

const shape = new Jolt.MeshShapeSettings(triangles, new Jolt.PhysicsMaterialList()).Create().Get();

Edit:
Given the above example of a mesh shape generation, I would write it this way:

const materials = new Jolt.PhysicsMaterialList();
const settings = new Jolt.MeshShapeSettings(triangles, materials);
const shape = settings.Create().Get();
Jolt.destroy(materials);
Jolt.destroy(settings);

However, I am not very familiar with Jolt yet, so not sure what materials are for or how to use them, and given it is optional parameter, I'd then shorten it to:

const settings = new Jolt.MeshShapeSettings(triangles);
const shape = settings.Create().Get();
Jolt.destroy(settings);

[jrouwe]

Hello,

I tried documenting how this works a bit better and also created an example. Can you take a look at this and tell me if I missed something important?

[LeXXik]

This is great! Thank you very much! The RefTarget comment cleared some of my questions as well and made my setup cleaner. The example is great too.

[LeXXik]

About the compound shape settings in the example. You are destroying it after the body creation settings. Is it specific to compound shape? For example, I destroy convex hull and mesh shape settings right after the shape was created, but before the body creation settings is created. Am I creating some silent errors? It works fine so far at least.

[LeXXik]

Added support for compound shapes, and it seems I can destroy the settings right after the shape is created, without a need to keep it until the body settings are created:

https://playcanv.as/b/9d961054

[jrouwe]

I think that's dangerous as the ShapeSettings object takes a reference to the Shape in the Create function. In C++ you would do:

RefConst<Shape> shape = shapeSettings.Create().Get();

after which you can delete the shape settings object because you now have a reference to the shape. In JavaScript you cannot take a reference (or at least not in the Ref/RefTarget sense), which means that if you do:

let shape = shapeSettings.Create().Get();
Jolt.destroy(shapeSettings);

You effectively removed the one and only reference to the shape so shape now points to freed memory. It may work by chance because the data has not been overwritten yet but it is wrong.

This is where the reference is stored:

https://github.com/jrouwe/JoltPhysics/blob/02939077a1d13d9704b550d847955a53f6b4f235/Jolt/Physics/Collision/Shape/Shape.h#L152

[LeXXik]

Ah, right, that makes sense. Thank you for the explanation! I made sure the cleaning takes place at the right time.

[LeXXik]

I see the example.js now does a better job in cleaning after itself. Nice!
I noticed some spots there, which probably also need some cleaning:

// static methods are allocating new vectors? e.g.:
Jolt.AABox.prototype.sBiggest();
Jolt.Quat.prototype.sIdentity();

// not sure if this allocates a new or not
shape.GetCenterOfMass();

[jrouwe]

This is unfortunately another peculiarity of the webidl_binder.py script. Any function that returns [Value] of something, e.g. [Value] static Vec3 sZero(); is translated to a C++ binder function that uses a static temporary:

Vec3* EMSCRIPTEN_KEEPALIVE emscripten_bind_Vec3_sZero_0(Vec3* self) {
  static Vec3 temp;
  return (temp = self->sZero(), &temp);
}

So you don't have to free these objects. Unfortunately it also means that if you do something like:

let v1 = new Jolt.Vec3(...);
let v2 = new Jolt.Vec3(...);
let v3 = new Jolt.Vec3(...);
let v4 = new Jolt.Vec3(...);
let sum = v1.Add(v2).Add(v3.Add(v4));

v1.Add(v2) is stored in a temporary
v3.Add(v4) overwrites that temporary

so in the end you calculate:

let sum = v3.Add(v4).Add(v3.Add(v4));

What will work is this:

let sum = v1.Add(v2).Add(v3).Add(v4);

[LeXXik]

Ah, this is great! This explained some of the bugs I had, when I tried to use vector math using Jolt vectors. I am now limiting myself to bare minimum. Most of the math is done on the rendering framework side, so I can just read and write final results only. I think I am only using a bit of Jolt math, when calculating the world point for shape cast, but it should be ok.