Distribute instances on plane faces, and make Instances face the borders of the mesh using Geometry Nodes

Question

I've been looking for a way to distribute instances on a mesh and align the rotation of each instance to the direction of the border it would be place at. For instance:

On this exemple, "A" is the current result I'm in, a simple "Mesh to Points" > "Instance to Points" distribution. The nodes look like this:

"B" is the result I'm looking for. Where the instances face the border edge of the face they're instanced on.

The final goal of this would be to distribute houses and buildings on a large scale neighborhood in a more accurate way, where they all face the correct direction and using plane meshes for every city block

"C" is a most advanced version of what I would need, where a larger plane can be used as source mesh, and only the faces touching the border of the plane would be instanced on, leaving an empty space in the middle. but don't know if it is possible, so "B" would be fine for now.

I'm not the most advanced user of Geometry Nodes, quite the opposite really. I learn the most I can from tutorials and try to apply the principles learned to my specific problem, but I haven't being able to find any sort of reference on how to create this specific type of alignment. I would appreciate any solution or direction on how to achieve this.

Answer 1

• If the grid height = 1, make all arrows up (the input geometry is a tile with an arrow pointing up, that is $+y$).
• If the grid width = 1, make all arrows point left (just realized maybe you want the top to point up and bottom to point down, but it's the easier part of the tree…)
• For all other cases as I wrote in the comment.
• Detect borders by checking number of neighbors = 1 and capture that on edges.
• For the face corners lying on those borders, capture the difference of their position and their face position (direction from face center to border-face-corner).
• For face corners not lying on the borders, just capture $<0, 0, 0>$ vector.
• Convert faces to points, so the face corner attribute interpolates to face domain, and then is copied to newly spawned points positioned at faces centers.
• The interpolation from face corners to face simply averages the directions.
• On a side it's an average of two same directions and two zeroes, making it still the same direction just with half of magnitude.
• On a corner the average produces the direction of the corner, which is the problem Gordon Brinkmann mentions.
• On a face inside, all corners have zeroes, so the average is also $0$.
• Spawn the input geometry (the tile) on those new points.
• I wonder if someone reads those walls of text.
• Check the length of the averaged vector is bigger than zero (the $0.1$ value is just a threshold for precision-related safety).
• Convert the boolean to integer implicitly: false = 0, true = 1.
• Use the integer as an index of the instance: 0 is the just created single quad, 1 is the input geometry (arrow tile).
• Set the rotation by aligning Euler to Vector.
• The vector to align to is either the original vector, if there was no $y$ component (so either left or right), or the vector with $x$ component removed (as I wrote in the comment; so either up or down).

Vertical line patch

Answer 2

This is perhaps a much more reasonable answer, instead of mental gymnastics, just calculate and spawn 5 zones separately: