Another one for the browser: https://oimo.io/works/cloth/
How do people go from web dev/gradle/java knowledge to build something like this.
For me, sometimes I wonder since I never did CS undergrad, I will never understand any of this no matter how many programming langauge I learn. I did dabble a bit with OPENLY, LIBGDX, GODOT, unity but to come to with cloth simulation from scratch, damn
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.
Then you read into things like runge-kutta and implicit methods that make your little simulation not blow up...
Click on the word in front of "Cloth Type" to change it to a Grid for even a cooler interaction
This reminded me of this cool Polygon video examining the incredible cloth design in the game Elden Ring
These cloth simulators always feel somewhat unstable - try generating a Grid cloth, and see it start bouncing and moving randomly. Is this due to accumulating IEEE 754 floating point errors?
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.
I've got a demo[1] where people can play with (my interpretation of) various calculation engines, adjust variables, etc. But seeing this comment made me realise I've never heard of Verlet integration[2] before - not surprising given that I got an F in Maths (and got thrown out of Physics before I could take the exam). So ... how efficient and accurate is Verlet compared to Euler/Runge-Kutte/etc? And what other methods are out there for this sort of calculation?
[1] - https://scrawl-v8.rikweb.org.uk/demo/particles-008.html
Verlet integration became the go-to method for particle effects and soft surfaces back when people wrote their own game engines, mostly thanks to the paper documenting its implementation for the first Hitman game [1]. In fact, I'd say it got cargo-culted by game devs for that purpose and that purpose only, despite it being a general method and competing with others.
[1]: https://www.cs.cmu.edu/afs/cs/academic/class/15462-s13/www/l...
Would be interesting to know what integrator they use. Verlet schemes can be implemented with very little effort and they don't suffer from this issue (see e.g. the leap frog method). But in general you would nearly always add some sort of damping mechanism, particularly for CG applications.
You mean for this submission? The window title says "Verlet simulation test".
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.
I've always loved this sort of cloth animation. I think the first one I saw was dissimulate's tearable cloth demo on Codepen - I can't believe they wrote that code 9 years ago!
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.
Does this mean I can finally get a robot to fold my shirts in ten years?
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:
Yes, but you will have to wear a hinged stainless steel shirt that makes you look as ugly as a CyberTruck.
Is there a simple way to do fluid (air) simulations like this?
So beautiful, robotics simulation can benefit from something like this. The state of cloth simulation in robotics is still pretty pathetic