Is it possible to scatter points on the outside surface of a group of instances?

Question

new to geometry nodes. I generated instances so they're all clumped together to form one large object, and I want to scatter more instances to make smaller clumps over the surface of this large object. I know this is because the instances are all their own volumes and so scatter points on faces will naturally do that even in the parts overlapping. Is there a workaround? Thanks

picture 1) I made cube instances on the points on the faces on the cluster of cylinder instances

picture 2) however I would like to be selective on where the cubes/points are generated so that they are only on the outer surface of the cylinder cluster, and exclude the parts of it inside that are overlapped/hidden. if possible I would like for the 'scatter points on surface' to be on the outer surface of the whole cluster itself, and not all the faces of each individual cylinder (most which have sides that are hidden), the way it is in this photo when I hide the cylinder cluster

Newest pic to show examples of points that I would like to not have there.

Tried with a mesh boolean node and with only primitives just to make sure that they are manifold objects I'm working with. Unfortunately I can still see that the instances are being made inside where the objects' volumes have intersected. I hid the outer cube for visibility, but inside the points are still made inside.

Answer 1

You have a bunch of instances generated in a different modifier. These instances intersect each other. You would like to distribute some other instances on the surface of these objects, with a new GN modifier, but not where they intersect each other. Is that correct?

We start with a "realize instances" node so we can do further work on the instanced meshes. Then we can use a "mesh boolean" node with self-intersection enabled to create a single surface from the union of all of our instances (assuming those instances are manifold meshes; otherwise, the notion of "outer" is ambiguous.) Then we'll distribute instances only on the surface of this union.

Answer 2

_{*This method needs manifold geometry (closed and with outward normals)*}

With the Raycast node and a few chained raycasts, you can get a good result:

• Red: Inside Points
• Yellow: Unsure Points
• Black: Outside Points

But for a lot of instances intersecting the number of iterations needed grows:

^{I have some other ideas for optimizing for very clumped instances, I may test them and update the answer later.}

---

The idea is simple, first for a point raycast to the source surface using the source normal, if the raycast hits and the hit normal points away from the source normal, then the point is inside a mesh.

To know if the hit normal points away or towards the point normal we can use the Dot Product operation, it receives two vectors and outputs the cosine of the angle between them if they are normalized, so if the result is greater than $0$ the hit comes from inside, else it comes from outside.

A single raycast will work if there's a maximum of one intersection per mesh, but, if there isn't, more raycasts starting from the previous raycast hit position will be needed, and the result will depend on the number of times a ray enter and exit a mesh, if it exits more times than it enters, it is inside some geometry.

For a point, first store an integer to be used as a depth counter, then raycast to the source surface, if there's no hit, it's outside; if the hit normal is opposite to the point normal, subtract $1$ from depth, else add $1$. As soon as depth becomes 1, you know the ray started [and still is] inside some geometry, but while it doesn't hit, repeat the raycast process, accumulating depth until it reaches $1$ or does not hit.

A way to reduce the number of iterations needed for some points is also raycasting backwards, storing another integer for the backwards depth, but this one starts at $-1$, since the ray will have exit the source mesh, adding an extra $1$ to the total.

---

In Geometry nodes, first we prepare our variables:

• direction: the point normal, used as the raycast direction.
• hit_pos: the position hit by the last forward raycast, initialized as the point position.
• hit_depth: the depth of the forward raycast, starting at 0.
• inv_hit_pos: the position hit by the last backward raycast, initialized as the point position.
• inv_depth: the depth of the backward raycast, starting at -1, since the back of the source mesh will eventually be hit, adding an extra $1$ to the value.

Now we need a node group that does the raycasting and can be chained:

Something important to do is offset the raycast source in the raycast direction by a very small amount, if that's not done, the raycast can hit the place where the point was distributed. The offset value in the blend file I provided is $0.001$, but can be made smaller inside the node group if your meshes are of smaller scale, I tested until $0.00005$.

At the end of the chain, we can remove the named attributes used for calculation:

Here there's switches that output no geometry if the source is empty, the only purpose of that is to stop the 'named attribute not found' warning. I also added an option to join unsure points to the resulting points (which contains the outside points).

Blender 3.6.1

---

In blender 4.0, with repeat zones, you won't need to duplicate the chain nodes anymore, the number of iterations can be chosen in the node:

Answer 3

Well, this is how it could be done:

Just create a volume from the objects, without increasing the Band Width, and with a high Voxel Amount. Then convert the volume into a mesh. This will give you a closed mesh that combines all objects into one, similar to Mesh Boolean.

Then distribute your points on the original objects and send a raycast to the previously created mesh in the direction of the normals of the points. Finally, delete the points if their normals point in the opposite direction, which you can solve with Compare and the Dot Product.

_{(Blender 3.6+)}

PS: I love simple solutions...