Access to geometry data

This offer:
is the beginning of the implementation of this feature request:

Now that we have the first working prototype, there is a design challenge.

The purpose of this topic:
Suggestions, designs, use cases
You can also use these Build path or Node Groups version for experiments (but they don’t have Face corner)


In the course of experiments, I realized that this node should be implemented as an attribute transfer node, and not just as an attribute by index

Also, for experiments, I requested a build

After the creation of the first prototype, plans changed. At the moment they look like this:

Mesh.Face[Index].Loop[Number] // Face Corner

Mesh.Loop[Index].V // First - simple
// In loops of single face vertices can repeat, need sorting by loops edges

Mesh.Edge[Index].Connection_Edges[Left/Right] [Number]
Mesh.Edge[Index].Connection_Points[Left/Right] [Number]


The essence of the difference is that now there is a receipt of the loop number, and data on the connection of the polygon is already obtained from it.
Since this may be redundant, a design problem has arisen.
Without it, this possibility will be ignored.

Usage example:
You want to connect 2 boards with a hinge.
You can create these boards on polygons.
Now you want a hinge.
You create it on the edges, and rotate it to the polygon
And in order to know the polygon, this node is needed.

Or another example: You create an effect like this:

You want to know about each vertex its neighbors.
You can convert this to a curve and do index +/-
But it’s long and redundant in some cases.
And with a node, you can know the indices of the neighbors for the vertex.

A fresh example of using these vertices.
In this example, I’ve used a new version of the node where you can enter a data source.
This is a generator of fasteners at the corners of polygons


Some examples of the new design:
Neighbor polygon data for a polygon

And neighboring polygons for the edge

I think the last example is the most understandable in a practical sense.


New progress!
Now there are 2 development paths:

  1. Everything is as before. There is a group of nodes that tells about the number of neighbors A for an element of type B.
    And there is a node that returns the index B by the element index A and the number of the neighbor.

  2. New option: Node receives geometry and returns a point cloud. They have attributes: IndexA and IndexB.
    The points will be copies of the neighbor for each element of A. Each of them will know the index of its original B.
    And also, an attribute will be created for the incoming geometry. Which will be able to use the original. It will report the offset of the first point of its group.
    Now you can accumulate any data about groups of neighbors. Perform any logic with them. You will be able to quickly create any link structure.


  1. We need a huge array of nodes (or 2 nodes with a bunch of switches, also taking over the functions of some of the already created nodes) with data on the number of neighbors.

  2. This node creates many points. You will have to work with them.
    The start offset attribute is too c++ like. But it seems to me, it’s less c++ than

Attribute Index = Capture;
Attribute size = GetSizeFaceConnectFace();
N_Index = FaceConnectFace(Index, Duplicate.Number);
And now use this ...


points, offsets, ia, ib = Geometry.Neighbors(Face, Connection, Face);
And now use this ...

Any ideas or suggestions