How to position random instances one after another with Instance on Points based on the dimensions of the previous Instance WITHOUT OVERLAP? (Fence)

Question

Objective

• I want to create a procedural fence with Geometry Nodes, where the fence may have random plank types.
• The planks must be positioned one after another, without overlap, right after the bounding box of the previous plank.
• The idea is to have dynamic/modular fences, shelves, piles, etc.

Desired output

Different random plank types, perfectly placed one after another without overlap:

My solution for Single Plank Type (Successful)

Using a Mesh Line and a Single Plank Type (Object Info), I managed to set the Mesh Line Offset from the plank object Bounding Box.

The result

Node setup

Multi-Plank Types Problem

• When instances come from a collection, there's no way to know the Bounding Box beforehand, because a object type hasn't still picked from the collection, this way, how could I calculate the Mesh Line offset?
• It's not possible to set the Mesh Line offset after instances are added to the mesh points.
• I managed to create a multi-plank fence, by manually setting the Mesh Line offset with the biggest plank dimension, but then, there's a lot of gap between smaller planks.

The failed result

Node setup for multi-plank without dynamic spacing

What have I tried

• I tried getting the bounding box after Instance on Points, but the Instances output already contains all the planks, not the current instance.
• I tried to think of a way to get the previous instance and then I could get its Bounding Box and set the new plank offset with Set Position.

Question

1. How to position dynamic, random objects, perfectly aligned one after another?
2. How to know the bounding box or attributes of the previous instance?
   • For example, with coding it's a matter of calling instances[curr_index - 1].bounding_box and then I can dynamically position the current instance based on the previous bounding box.
3. Is Mesh Line still the ideal entry point for this?

UPDATE - Accumulate Field Node

@Chris answer that suggests using Accumulated Field Node works considering the planks are also randomly generated cubes. But my planks are customized, so they have to come from a collection.

Possibilities that don't work

• A) Get the Bounding Box of the current instance and then use Accumulate Field
  • I can't find a way to neither of those. In case (A) I don't know how to first pick a random instance from the collection and then feed Instance on Points with the picked instance.
• B) Get the Bounding Box of the Instance on Points geometry so far and then add it to Accumulate Field and set Mesh Line position.
  • It appears that there's no way to get the bounding box of the generated geometry with Instance on Points.
• C) Realize instances, get bounding box and add to accumulate.

A and B possibitilies:

Instead of randomly generating Y, I'd need to get the random instance Y size here:

C:

Answer 1

Capturing Dimensions on Instances

This group automates the manual steps in @AlfredBaudisch 's self-answer.

Using a method based on @Markus von Broady 's answer to another question, (dealing with rotating characters in a string), it captures bounding-box dimension information on an arbitrary indexed collection of instances.

The group works by deleting all but the maximum and minimum vertices of bounding-boxes of the incoming instances, and recording their Positions. Because there is only one vertex per instanced bounding box, the vertex index in the realized geometry corresponds to the instance index, and can be transferred.

I hope, one day, Attribute Statistics and Bounding Box will output fields,not fixed values, so this kind of hack becomes unnecessary?

The group can, for example, be used to pack instances, randomly selected from a collection, along a line in X, when combined with Blender 3.1a's Accumulate Field node:

(While the meshes in this collection are X-symmetrical, they are not all centred on their origins)

The group works with random scaling of instances, but does not yet deal with rotations. It would be possible to calculate the intersection of rotated bounding-boxes with the array-line, to enable instances to be randomly rotated, and still touch? That would be nice, for fences, crooked teeth, etc.

(Blender 3.1a) .. although the 'Capture Dimensions' bit could be tweaked to work with Blender 3.0.

Answer 2

This is an easier setup than you have (just the planks are randomized in scale), but with a little more math you can even rotate them and still equally spaced).

So here is the principle:

result:

The new accumulate field node makes this possible now.

By changing the space value you can change the space between the planks.

Answer 3

Solution

• Add the items into a collection.
• Manually place each item into the geometry node tree (a Object Info for each item of the collection).
• Calculate the bounding box size for each item manually.
• Get a random value, which will be the next instance.
• Go through a flow of switches, depending on the picked item, then accumulate the bounding box of the current instance, with the Accumulate Field node (Blender 3.1 Alpha+).
• In Instance on Points, plug the random value generated.
• For each new item in the collection, a new Switch must be added to the tree.

The process is not 100% automatic, but with this solution it's possible to procedurally generate a line of hand-crafted items, aligned one after another without overlap.

Nodes

Note: the "ETK_Bounding Box" nodes here simply do a Bounding Box calculation using the standard Bounding Box node.

Example

Credits

For two days I tried to solve this, without luck. This solution has been provided to me by Erindale, creator of Erindale Toolkit - Advanced Geometry Nodes Groups (Updated For Fields). Credits to him.