OleK

Here's a fun example for what you can do with Scene Nodes: You can implement even a game! I added comments to the node graph, I hope that helps if you are interested in the example. Here's the C4D file, it requires 2023.1: tetris.c4d tetris.mp4 To play the game, you have to press the usual play button in Cinema, and then either use the arrows for the Move/Rotate/Drop user data of the Keyboard Handler to control the game or install these Python scripts and assign shortcuts to them with the script manager. tetris_scripts.zip For a new round you have to reload the scene.

Yes, I'm one of the scene nodes developers. Basically you can do anything with scene nodes, but for example for particles it's quite low level at this point of time because there are no dedicated nodes for particle simulation yet. Here's a spider web capsule. The "mounting points" are controlled by the capsule's child object. spiderweb.c4d

And here's a forest of minimalistic trees. Each of the trees is different. forest.c4d

Here's one of the first tests I made together with two colleagues, a so-called "binary kite" as a capsule. (Well I think the original meaning of "binary" is "just 2 colors", so in that sense it's not a binary kite.) You can control most of its parameters: kite_capsule.c4d BTW: If you choose "Multi-Instance" in the Generator tab, you'll get much better performance and can easily increase number of clones.

And here's a particle simulation based on this Softimage ICE example: particles.c4d.zip

Some of you may know Conway's Game of Life: https://en.wikipedia.org/wiki/Conway's_Game_of_Life Basically you have a grid of cells where each cell can be either live or dead, and then there are rules when a dead cell becomes live and vice versa. With this simple setup quite interesting patterns can evolve over time. Here's my attempt to implement that game with Neutron: game_of_life_basic.c4d This variant adds some decay to the cell colors. game_of_life_decay.c4d

Let me start a series of scene nodes examples from my side. I posted this L-system example in another thread already: But let's repeat it here for completeness. There's a bug which can happen with splines with more than 1024 points, this will be fixed in service pack 1 of S26. For now make sure to don't reach that limit, or remove the connection for the spline output in my setup. lsystem.c4d

Iterate Collection has much better performance than Get Element, so the two parallel iterators should be preferred where possible.

Unfortunately the index port is still missing for the iterate collection node. You can use a second Index Iterator node, they'll iterate in parallel:

The issue with losing connections on type changes is annoying, true. It will be improved, but I can't give any promise about the "when". Here's a more general solution to the snowflake curve, basically a very simple L-system implementation with scene nodes which I made a while ago. Today I added a spline output. I found a bug in the spline conversion which sometimes happens if there are more than 1024 points. For larger counts you have to disable the spline output by removing the connection to scene root. With initial string F--F--F and replace string F+F--F+F one gets the snowflake curve. Also the angle for +- has to be changed to 60 degrees. You can try and modify other L systems from here (pages 8ff and 25): http://algorithmicbotany.org/papers/abop/abop.pdf The scene nodes setup supports commands F to create a cylinder, f to just move, +- for Z rotation, &^ for X rotation and /\ for Y rotation, and finally [ ] to enclose branches. You can easily add further rotation or move commands. lsystem.c4d

It's true that there's no current way to terminate an LCV. That will definitely be added. For now you have to use your solution with an extra Bool variable which remembers if you have already reached your final state. I did a similar technique to implement the Mandelbrot iteration. For the GCD case you can use 100 as a safe number of iterations, but you can also use a better upper bound for the number of needed iterations. If you look here in the worst case section https://en.wikipedia.org/wiki/Euclidean_algorithm#Worst-case you'll find the formulas N - 1 <= log_phi(b) and N <= 5 * log_10(b) where phi=golden ratio, N = number of required iterations and b = minimum of both values of which you want to compute the GCD. We neither have a log_10 nor a log_phi node (only natural and 2-based logarithm), but you can use log_phi(b) = ln(b)/ln(phi), so you can use ln(b)/ln(phi) + 1 as your number of iterations. Of course that's an "optimization" which is really specific to the GCD case. There are other cases where you can't estimate the number of required iterations, and not having a true while loop is waste of CPU time.