sorry -_- will fix that in later releases. will need to simulate the fall again )

The node basically simulates (just like cloth simulation) a 1D manifold (a thin cloth if you will) and spits out the simulated mesh (at each frame). What you do with it is up to you. Like in the cover image of this post, i chained a couple more geo nodes to make it into a proper rope.

So for something like a chain, you could add another geo node after the RopeGN (like in the attached image).

Spiderweb is an interesting case, but it won't work with this modifier, because it inherently has internal loops. I think a cloth simulation would be much more feasible for that. And this is deliberate: the whole point of only doing for 1D objects (single loop is ok) is it allows to simplify and speed up the XPBD by quite a lot (for the nerds: the Jacobian is sparse if you only have nearest neighbor connectivity).

For the barbed wire -- I'm actually not sure. You can probably tweak the parameters to get something that resembles it, but I think a barbed wire also has lateral elasticity which normal ropes do not, so it won't properly model their dynamics.

yep ill just post it on the same lemmy instance. can also dm you the link

yep, that's the same idea! i'm happy to share the code once i clean it up a bit, and you should feel free to transfer any of the functionality. there are few features i added which i really like, such as a support for LSP and type hints in an external IDE, plus an ability to write the code outside, while the add-on auto-regenerates the node-group if a file is changed. another cool thing is you can inline functions, i.e.:

# these two are automatically inlined (i.e., nodes added to the active group)
@inline
def foo(x: float, y: bool):
  return x**2 if y else x**3

foo = lambda x, y: x**2 if y else x**3

# while this becomes a reusable node group
def foo(x: float, y: bool):
  return x**2 if y else x**3

reading through the documentation, it's actually very similar!

looks nice! i wanted something more code friendly, so mine actually parses math expressions, if statements, lambda functions, loops etc and decides internally what nodes it needs to put together (hence the horrible looking node sausage). so you literally write a python logic, which it then transpiles and compiles into a node tree. in other words, you never actually have to think in nodes.

:D thanks! i actually already added support for towers and will add other adjacent buildings soon too. the plan is to also have a gatehouse and generative arcs. I'm currently trying to work out the general topology with all the edge cases and then will add decorative elements.

it follows a custom edge which doesn't necessarily lie in a single plane, so it's trivial to add a shrinkwrap or another node to make it follow a terrain. texture input is a good question. uv of this thing might be totally messed up, but a generative material should work ok.

for the battle scene - it does produce a well treated topo, so you could chain another destruct modifier. )

will be happy to share once it's more mature.

agree, the whole advantage of writing this python library is that debugging a code is much easier than a noodle of nodes (especially when doing conditionals, math etc). it also supports factorization into functions. and since it produces ultimately a geometry node group, it's as fast and customizable as if it was made by hands. i'll post the add-on as soon as it's ready if people are interested (free ofc).

believe it or not, it does reuse many nodes. sim/repeat won't be of much help here, there're no repetitions. I'm testing an addon I've been creating which converts regular Python logic into geometry nodes. this is like ~500 lines of Python code converted into nodes. It's making a procedural full-quad wall with crenellations from an edge. unsurprisingly, most of the nodes are to correctly treat edge cases/self intersections, removing stray edges/faces etc.

Blender already supports python and for shader nodes it support OSL.

That's kinda what this is doing : )

It's almost instanteneous. Most of the nodes are math/vector math and read/store attributes.