@zeauro, Iām glad to hear it was indeed the self-collision (I was afraid there was something really bad going on :P), though ideally the self-collisions would perform equally when shrunk, Iāll take a look at that part of the code, to see if I can improve the performance (to at least get linear performance across scales). About the wrinkling, afaik there shouldnāt be an increase in wrinkling at smaller sizes, though I might have overlooked something about mass recalculation when implementing the dynamic mesh feature, Iāll investigate (There should be no need to compensate properties, as they should already be proportional to edge length, but like I said, I might have missed something about mass).
@yii7, tearing is indeed quite compelling, and theoretically quite straight forward. However, it raises several implementation issues, for instance, dynamic splitting might be the obvious choice, but the resulting variable vertex count makes compatibility with things such as motion blur much more complicated. On the other hand if we go with a pre-split mesh, there is the issue of how to pre-compute the splits, or having to propagate them throughout the frames when it happens, or even having user-defined split locations (which to me seems a bit boring). Those, and probably other things, have to be discussed before even starting to work on an implementation, however I am willing to give the tearing thing a shot, as it is indeed quite an exciting feature. I might open a design task at developer.blender.org, to get some feedback on what people think would be the best implementation. Regarding rigid-body collisions, Iām not sure what you mean. You can activate collision on top of the rigid-body, however only the cloth would react to the rigid-body, and not the reverse (Applying cloth forces to rigid body would really straight forward to code, if only the solvers werenāt totally independent, making it pretty much impossible to have their time-steps interact).
@ZedDB, today Iāve played around a bit with implementing a rudimentary cloth solver in python/numpy, and I can say pretty certainly that it would be almost inevitably impractical to get any respectable performance out of it, even with the plainest of explicit solvers. You can copy the mesh data into numpy really quickly, however the processing for the simulation itself is what kills it, as there are just too many operations that simply can not be performed with the efficient vector/matrix functions that numpy provides (implemented in C). I can only assume that Rich Colburn used something like cython to get the performance showed in the video.
Now, regarding the general status of my cloth developments: I am looking into implementing a more proper air resistance model, as the current āair dampingā just applies a uniform resistance force to the vertices, while it should at least be applying forces dependant on the projected area of the faces onto a plane perpendicular to the motion vector (That is, short of implementing a full fledged aerodynamic model).
I am also looking into some papers on better implicit cloth solvers and collision models, which though being quite some work, if implemented, would fix the main issues of the current simulator (bad collisions, performance, and bending). Though I might initially try to do some external implementation (addon) through a python/cython/c interface.
Finally, I would like to say that though I am actively working on improving the cloth simulator, donāt expect new features to be ready really soon, as I have taken this on just as a side project, and canāt work on it all the time. But Iām sure weāll slowly move towards having the greatest cloth simulator of all :evilgrin:
