Cloth

Cool. When can we get this kind of cloth interaction in games?

such an unbelievably cool website.

simply lovely (like the other stuff on that website)

And another one (Rusty with bevy).. runs better on desktop

I have felt similar, wanting to learn physics sims. I have had to learn over time to separate domains of knowledge like physics from programming tools used to ~manifest them. Especially starting with gamedev, initially it felt like there should be a natural programming idiomatic way to set up each of the major simulations like rigid bodies, cloth, springs, fluids, so the first thought I had was these sims will be naturally encoded in the language, like a fluid sim being somehow setting up a grid, then choosing some update rules per timestep. But really it is modelling a problem as real mathematics and physics, then mapping this to a language/toolset which perhaps can't naturally express it idiomatically.

There are a few algorithms like some cloth sims based on particle positions and springs, which can be coded easily, but that was misleading to me when trying to improve, I had to dig a lot more into physics and numerical analysis then mapping the problem to code, which can end up clunky and with a lot of magic numbers.

At the end of the day, it's all just maths and physics.

You didn't specifically ask about game development, but that domain is where the majority of graphics, mathematics, lighting, physics, etc, knowledge is distributed. And it can be difficult to find information solely about (e.g.) cloth simulation and other niche topics without it being coupled into game development resources.

I happened to read https://alextardif.com/LearningGraphics.html today, which might give you some pointers in various directions. https://learnopengl.com/ gets a consistently good rap, even today when there are newer APIs like Vulkan, Metal and DX12. Consider the API as 5% of the problem to solve though (less tbh, though Vulkan is proving even heavier than I was warned).

If you don't want to learn C/C++, I understand there's a large community around WebGL, so finding their subreddits and other forums could be a good starting point too.

However, again, the API and platform is really just a wrapper around the actual physics simulation (the impressive/novel part).

(Source: I'm a web dev/gradle/java developer who is once again building a game engine in their spare time after a previous attempt many years ago)

They're completely different skillsets. You just have to go from the ground up and grind to learn it all (this demo isn't that hard but generally it could take years). You probably have to unlearn a ton of stuff you adapted to when learning java/web dev.

it's not that difficult. in javascript, you represent each point in (x,y,z), give it a mass, and every frame apply gravity, maybe with some noise added. every time the particle tries to move, you use trigonometry to transmit the forces through the edges to the other points + some damping amount so it doesn't runaway. the mass determines how much each point is affected by subsequent forces.

If you aren't ready for it in 3d, do it in 2d.

Search for "numerical integration" in the context of physics simulation/game engines. You can use https://en.wikipedia.org/wiki/Numerical_methods_for_ordinary... as a starting point.

From what I understand it's not just floating point errors, but due to the nature of approximating continues function as simple discrete steps. Linked wikipedia article has a graph demonstrating that with large steps the error accumulates way before floating point precision is a concern.

There are different numeric integration techniques with different tradeoffs. Stuff like Eulers method, Verlet, Runge-Kutte. In some of them overall energy tends to accumulate in others it gets lost both of which is wrong. Some of the more complex ones tend to behave a bit better, but then you get into the problem whether gains from each individual step being more complex outweighs what you would get from running more iterations of simpler/faster algorithm.

Energy preservation doesn't work by default in physics simulations unless you specifically code for it (e.g. by periodic explicit adjustment).

It's not only the rounding error, it's also quantisation of time and other minor errors coming from the mathematical model itself.

If the error is on the damping side, you get the real life effect of motion eventually stopping due to energy dissipation. If it's on the acceleration side you get a runaway simulation.

Here's mine from 14 years ago https://www.youtube.com/watch?v=G05M_Y6NQVM

It's very simple to implement a basic setup like this, and I agree that the results are super cool.

Video game Hitman from 2000 had cloth. Mirror's Edge from 2008 had tearable cloth. And I am pretty sure they weren't the first.

Simulating cloth for instance with spring/damper models is quite old. Even older than robotics research on folding cloths—and it has progressed pretty far. See for a recent survey:

https://arxiv.org/abs/2407.01361

Yes, but you will have to wear a hinged stainless steel shirt that makes you look as ugly as a CyberTruck.

Are the Foldimate and Laundroid not meeting your needs?

Godot can target the web so it's conceivable

No they are completely different.