Geometry Nodes: Distribute Points in Volume #85898

New Issue

Kenzie · 2021-02-22T20:21:07+01:00

Kenzie commented

2021-02-22 20:21:07 +01:00

Why Volume Point Distribution Is Needed

There are many use cases for distributing points (which other objects can be instanced) in a volume

Cubification Motion Graphics
Debris in smoke/water
Objects suspended in air
Scattering flying insects
Set dressing "voxel" art styles
Etc.

Volumetrics or Geometry Volume?

Geometry Volume:

Pros
Memory footprint is not much of a concern for users
Cons
No control over the volume's interior properties
Sampling surface properties is likely out of the question
Will likely not be able to handle complex or porous volumes
Stability of points will likely become an issue

Volumetrics:

Pros
User is able to control distribution per-voxel
User is able to assign attributes per-voxel
Predictable results even for complex and porous volumes
Stable distribution is basically free with grids
Cons
Memory footprint can quickly become an issue for users

Geometry Volume: I just want to scatter some points in a box/sphere
Volumetrics: I need to be able to scatter points in this model/sim

Given that sampling volumes is far more useful this design task will focus on that.

Approach 1: Add to the Point Distribute Node

Bundle it into the existing point distribute node. This approach would likely lead to making the point distribute node's code a bit of a mess as it is currently only designed to work with surfaces. Volumes can have their own distribution methods which do not cleanly integrate with the existing distribute methods. Volumes and geometry volume could be implicitly treated as the same when switching to a volume distribution mode, but this again gets messy and would produce the worst of both worlds.

Approach 2: Make it it's own Distribute Node

Rename the "Point Distribute" node to something like "Point Distribute Surface" and create a new "Point Distribute Volume" node which can take on code of it's own specifically designed for sampling volumes. Distribution methods could possibly include grid sampling and in the future SDF (signed distance field) sampling to distribute on the surface of an SDF.

Approach 3: Make a Volume to Points Node

Create a new "Volume to Points" node. This doesn't rule out Approach 2 and would only support grid distribution (users can always jitter and displace points to break up the grid as they need). This would however be the simplest of all of the approaches and make moving to Approach 2 easier in the future. We can make the user interface and workflow similar to the "Volume to Mesh" node. For attribute transfers we would sample the points on all VDB grids and transfer that to point attributes. Given that users are mostly just looking to distribute points in a volume and SDFs or other distribution methods are likely longer down the road this feels like the better approach. (Mockup)

Progress

Approach 2: Work in progress: https://developer.blender.org/D10506

# Why Volume Point Distribution Is Needed There are many use cases for distributing points (which other objects can be instanced) in a volume * Cubification Motion Graphics * Debris in smoke/water * Objects suspended in air * Scattering flying insects * Set dressing "voxel" art styles * Etc. # Volumetrics or Geometry Volume? Geometry Volume: * Pros * Memory footprint is not much of a concern for users * Cons * No control over the volume's interior properties * Sampling surface properties is likely out of the question * Will likely not be able to handle complex or porous volumes * Stability of points will likely become an issue Volumetrics: * Pros * User is able to control distribution per-voxel * User is able to assign attributes per-voxel * Predictable results even for complex and porous volumes * Stable distribution is basically free with grids * Cons * Memory footprint can quickly become an issue for users Geometry Volume: I just want to scatter some points in a box/sphere Volumetrics: I need to be able to scatter points in this model/sim Given that sampling volumes is far more useful this design task will focus on that. # Approach 1: Add to the Point Distribute Node Bundle it into the existing point distribute node. This approach would likely lead to making the point distribute node's code a bit of a mess as it is currently only designed to work with surfaces. Volumes can have their own distribution methods which do not cleanly integrate with the existing distribute methods. Volumes and geometry volume could be implicitly treated as the same when switching to a volume distribution mode, but this again gets messy and would produce the worst of both worlds. # Approach 2: Make it it's own Distribute Node Rename the "Point Distribute" node to something like "Point Distribute Surface" and create a new "Point Distribute Volume" node which can take on code of it's own specifically designed for sampling volumes. Distribution methods could possibly include grid sampling and in the future SDF (signed distance field) sampling to distribute on the surface of an SDF. # Approach 3: Make a Volume to Points Node Create a new "Volume to Points" node. This doesn't rule out Approach 2 and would only support grid distribution (users can always jitter and displace points to break up the grid as they need). This would however be the simplest of all of the approaches and make moving to Approach 2 easier in the future. We can make the user interface and workflow similar to the "Volume to Mesh" node. For attribute transfers we would sample the points on all VDB grids and transfer that to point attributes. Given that users are mostly just looking to distribute points in a volume and SDFs or other distribution methods are likely longer down the road this feels like the better approach. (Mockup) ![image.png](https://archive.blender.org/developer/F9828115/image.png) # Progress Approach 2: Work in progress: https://developer.blender.org/D10506

Kenzie commented

2021-02-22 20:21:07 +01:00

Added subscriber: @KenzieMac130

Kenzie changed title from ~~Geometry Nodes: Distribute Points a Volume~~ to Geometry Nodes: Distribute Points in Volume

2021-02-22 21:13:48 +01:00

Hans Goudey commented

2021-02-22 22:38:50 +01:00

Added subscriber: @HooglyBoogly

Hans Goudey commented

2021-02-22 22:38:50 +01:00

I prefer the second approach, sounds like the proper way to do it.

This design task could actually cover common algorithms for that case. I assume you're interested in implementing this?

I prefer the second approach, sounds like the proper way to do it. This design task could actually cover common algorithms for that case. I assume you're interested in implementing this?

Kenzie commented

2021-02-22 23:50:19 +01:00

In #85898#1117314, @HooglyBoogly wrote:
I prefer the second approach, sounds like the proper way to do it.

This design task could actually cover common algorithms for that case. I assume you're interested in implementing this?

Yes, I have already worked on the distribute node before and it seemed like a relatively straightforward task once design is approved. If Approach 2 seems like the way to go I can start working on it.

> In #85898#1117314, @HooglyBoogly wrote: > I prefer the second approach, sounds like the proper way to do it. > > This design task could actually cover common algorithms for that case. I assume you're interested in implementing this? Yes, I have already worked on the distribute node before and it seemed like a relatively straightforward task once design is approved. If Approach 2 seems like the way to go I can start working on it.

Kenzie self-assigned this 2021-02-22 23:57:42 +01:00

Stephen Swaney commented

2021-02-23 02:13:45 +01:00

Added subscriber: @StephenSwaney

Kenzie commented

2021-02-23 04:46:59 +01:00

Began working on Approach 2 D10506. Will keep this updated with more potential design issues, especially when it comes to the distribution method.

Began working on Approach 2 [D10506](https://archive.blender.org/developer/D10506). Will keep this updated with more potential design issues, especially when it comes to the distribution method.

Kenzie commented

2021-02-23 04:59:13 +01:00

It appears that the implementation of geometry volume sampling in the legacy particle system produces quite broken and unstable results under random and especially jittered volume distributions.

Grid distribution is also an issue in the old system...

Not sure if this is even worthy of a bug report as it is end of life anyways and likely wouldn't be an issue with simple geometry that was typically used as particle emitters. Either way it seems examining the old way of doing it is a dead end.

It appears that the implementation of geometry volume sampling in the legacy particle system produces quite broken and unstable results under random and especially jittered volume distributions. ![image.png](https://archive.blender.org/developer/F9829321/image.png) ![image.png](https://archive.blender.org/developer/F9829329/image.png) Grid distribution is also an issue in the old system... ![image.png](https://archive.blender.org/developer/F9829337/image.png) Not sure if this is even worthy of a bug report as it is end of life anyways and likely wouldn't be an issue with simple geometry that was typically used as particle emitters. Either way it seems examining the old way of doing it is a dead end.

Kenzie commented

2021-02-23 08:04:41 +01:00

Looking at the VDB documentation it should be relatively straight forward to just add the distribute functionality with the Point Scatter API with just a wrapper around the Point Cloud class. Then if there is any other VDB grids we sample those in parallel and add them as attributes.

Distribution Modes:

Density Grid: Maps to UniformPointScatter with one per cell and no spread.
Density Random: Maps to NonUniformPointScatter with full spread
(Future expansion can include SDF distribution modes)

Attribute Sampling Modes

None: Don't sample attributes from grids
Linear: Box filter grids
Nearest: Point filter grids

Looking at the VDB documentation it should be relatively straight forward to just add the distribute functionality with the [Point Scatter API ](https://www.openvdb.org/documentation/doxygen/classopenvdb_1_1v8__2_1_1tools_1_1BasePointScatter.html) with just a wrapper around the Point Cloud class. Then if there is any other VDB grids we sample those in parallel and add them as attributes. Distribution Modes: * Density Grid: Maps to UniformPointScatter with one per cell and no spread. * Density Random: Maps to NonUniformPointScatter with full spread * (Future expansion can include SDF distribution modes) Attribute Sampling Modes * None: Don't sample attributes from grids * Linear: Box filter grids * Nearest: Point filter grids

Pipeliner commented

2021-02-23 17:33:36 +01:00

Added subscriber: @Pipeliner

DorianB commented

2021-02-23 18:09:37 +01:00

Added subscriber: @dodododorian

Kenzie commented

2021-02-24 00:08:31 +01:00

First bit of tangible progress: https://www.youtube.com/watch?v=EdOhC0yGfh4

I am having issues though with some rather bizarre offset where it doesn't appear to line up with voxels, I can't tell if that is a blender issue or a vdb issue though... other than that it feels like random distribution is pretty much complete.

Edit: It is a VDB issue... Looks like I am going to either have to re-implement it or undo the offset.

Edit: Fixed the issue, needed to offset each point by half the voxel size.

Upon inspection it seems that VDB's "random" point scatter also doesn't care about temporal stability with changing volumes. This makes sense as it intends for the distribution to be part of a static model or and initial burst that can be later advected and simulated.

Given that this kind of issue is inescapable not only with point distribution but also many other modeling operations there really needs to be more of a focus in geometry nodes on caching geometry and then animating/simulating it.

First bit of tangible progress: https://www.youtube.com/watch?v=EdOhC0yGfh4 I am having issues though with some rather bizarre offset where it doesn't appear to line up with voxels, I can't tell if that is a blender issue or a vdb issue though... other than that it feels like random distribution is pretty much complete. Edit: It is a VDB issue... Looks like I am going to either have to re-implement it or undo the offset. Edit: Fixed the issue, needed to offset each point by half the voxel size. Upon inspection it seems that VDB's "random" point scatter also doesn't care about temporal stability with changing volumes. This makes sense as it intends for the distribution to be part of a static model or and initial burst that can be later advected and simulated. Given that this kind of issue is inescapable not only with point distribution but also many other modeling operations there really needs to be more of a focus in geometry nodes on caching geometry and then animating/simulating it.

Florian Kamenz commented

2021-02-24 10:08:17 +01:00

Added subscriber: @TimBrown

Florian Kamenz commented

2021-02-24 10:08:17 +01:00

So is this kind of the same distribution as in the old Particle System?

So is this kind of the same distribution as in the old Particle System? ![Unbenannt.PNG](https://archive.blender.org/developer/F9834148/Unbenannt.PNG)

Philipp Oeser commented

2021-02-24 14:32:06 +01:00

Added subscriber: @lichtwerk

Philipp Oeser commented

2021-02-24 14:32:06 +01:00

Grid distribution is also an issue in the old system...

see #85167 (Particle volume distribution calculation is not creating particles inside the volume)

> Grid distribution is also an issue in the old system... see #85167 (Particle volume distribution calculation is not creating particles inside the volume)

Kenzie commented

2021-02-24 17:14:47 +01:00

In #85898#1118073, @TimBrown wrote:
So is this kind of the same distribution as in the old Particle System?

No, this is a different implementation using VDB.

In #85898#1118285, @lichtwerk wrote:

Grid distribution is also an issue in the old system...

see #85167 (Particle volume distribution calculation is not creating particles inside the volume)

Thank you for mentioning this. Yeah, this is not going to use any of that old code. I think it would be better to let the users control the contents of the volume with VDB rather than rely on the assumed mesh volume. This has the benefits of being far more robust and allowing volumetric attribute transfers.

> In #85898#1118073, @TimBrown wrote: > So is this kind of the same distribution as in the old Particle System? > ![Unbenannt.PNG](https://archive.blender.org/developer/F9834148/Unbenannt.PNG) No, this is a different implementation using VDB. > In #85898#1118285, @lichtwerk wrote: >> Grid distribution is also an issue in the old system... > see #85167 (Particle volume distribution calculation is not creating particles inside the volume) Thank you for mentioning this. Yeah, this is not going to use any of that old code. I think it would be better to let the users control the contents of the volume with VDB rather than rely on the assumed mesh volume. This has the benefits of being far more robust and allowing volumetric attribute transfers.

Kenzie commented

2021-02-24 21:58:37 +01:00

Initial user interface

Initial user interface ![image.png](https://archive.blender.org/developer/F9836075/image.png) ![image.png](https://archive.blender.org/developer/F9836078/image.png)

Kenzie commented

2021-02-26 23:46:20 +01:00

WIP build is available for people who want to try it out (it is not going to be the most up-to-date version however) https://blender.community/c/graphicall/nsbbbc/

Vyacheslav Kobozev commented

2021-03-01 21:41:08 +01:00

Added subscriber: @Vyach

Charlie Jolly commented

2021-03-06 15:09:02 +01:00

Added subscriber: @CharlieJolly

Charlie Jolly commented

2021-03-06 15:09:02 +01:00

Just from a naming point of view, should it be called Volume Point Distribute. My initial test was to use it like the existing Point Distribute node but it needs the Points to Volume to work.

Just from a naming point of view, should it be called `Volume Point Distribute`. My initial test was to use it like the existing `Point Distribute` node but it needs the `Points to Volume` to work. ![image.png](https://archive.blender.org/developer/F9873228/image.png)

Kenzie commented

2021-03-07 03:04:56 +01:00

In #85898#1125167, @CharlieJolly wrote:
Just from a naming point of view, should it be called Volume Point Distribute.

I'll get more feedback on this. The intention was to break point distribute up into "Point Distribute Surface" and "Point Distribute Volume" I originally went with this because it read and was grouped better when adding the nodes in the menu.

My initial test was to use it like the existing Point Distribute node but it needs the Points to Volume to work.

I am aware of this, it requires an explicit volume definition in order to function (VDB) as described in the design notes. It isn't working on external volumetrics at the moment.

> In #85898#1125167, @CharlieJolly wrote: > Just from a naming point of view, should it be called `Volume Point Distribute`. I'll get more feedback on this. The intention was to break point distribute up into "Point Distribute Surface" and "Point Distribute Volume" I originally went with this because it read and was grouped better when adding the nodes in the menu. > My initial test was to use it like the existing `Point Distribute` node but it needs the `Points to Volume` to work. I am aware of this, it requires an explicit volume definition in order to function (VDB) as described in the design notes. It isn't working on external volumetrics at the moment.

Bodhi commented

2021-04-13 10:44:13 +02:00

Added subscriber: @Bodi

Bodhi commented

2021-04-13 10:52:06 +02:00

Changed status from 'Needs Triage' to: 'Confirmed'

Bodhi commented

2021-04-13 10:52:06 +02:00

Vote for Approach #2. I think this was chosen.

{meme, src=itsawesome, above=Point Volume Distribute, below=. : . : . : : ` " . .}

Vote for Approach #2. I think this was chosen. {meme, src=itsawesome, above=Point Volume Distribute, below=. : . : . : : ` " . .}

Bodhi commented

2021-04-13 11:36:24 +02:00

Found it: Approach 2 D10506 :-)

Found it: Approach 2 [D10506](https://archive.blender.org/developer/D10506) :-)

Jacob DeBenedetto commented

2021-05-01 19:47:25 +02:00

Added subscriber: @doppler

Kenzie commented

2021-05-03 07:55:19 +02:00

Moving back to community tasks as I moved it after a meeting to be wrapped up for 2.93 but due to technical issues and the solution feeling incomplete this was not done to avoid a rushed product. I feel like shifting sands around the codebase and bigger priorities around geometry nodes have pushed this back a bit. I would like to return to this when more decisions around volume modeling are made and it fits in more with ongoing design tasks.

Lukas Tönne commented

2021-05-07 12:53:20 +02:00

Added subscriber: @LukasTonne

Tomasz Kaye commented

2021-05-14 16:29:19 +02:00

Added subscriber: @info-27

Kenzie commented

2021-07-05 07:38:57 +02:00

I feel I should resign from this one and put it up for grabs (not sure how) I am not keeping up with things. A lot has moved ahead and I feel as though this task can be better tackled with a more clear design from a core team.

Kenzie was unassigned by Philipp Oeser

2021-07-05 08:04:20 +02:00

Philipp Oeser commented

2021-07-05 08:04:20 +02:00

@KenzieMac130 : You can do so by Add Action > Assign/Claim > and then remove your name.

@KenzieMac130 : You can do so by `Add Action` > `Assign/Claim` > and then remove your name.

Cedric van den Berg commented

2021-09-16 17:07:53 +02:00

Added subscriber: @XLP-3

Evan Ryan commented

2021-09-20 23:24:08 +02:00

Added subscriber: @evantryan

Jordi Santini commented

2021-09-22 07:29:55 +02:00

Added subscriber: @Darksunrise

Atamert Ölçgen commented

2021-11-26 22:26:59 +01:00

Added subscriber: @muhuk

Coen de Oude commented

2022-01-01 15:54:18 +01:00

Added subscriber: @6Lithium-2

Leonard Göttert commented

2022-01-08 12:28:53 +01:00

Added subscriber: @Leonard-Gottert

Daedra commented

2022-01-15 04:05:53 +01:00

Added subscriber: @Daedra

Jakob commented

2022-02-17 17:47:44 +01:00

Added subscriber: @jak99jak

Eyad Ahmed commented

2022-05-24 22:45:32 +02:00

Added subscriber: @IyadAhmed

Yegor commented

2022-06-04 20:22:58 +02:00

Added subscriber: @YegorSmirnov

André Vieira commented

2022-06-16 16:55:38 +02:00

Added subscriber: @AndreVieira

Eyad Ahmed commented

2022-06-28 18:31:40 +02:00

I have been experimenting with ideas for this and currently the best two ways are (both are based on rejection sampling):

Generalized Winding Numbers (exact but slow)

Note that it depends on normals, but that might be a desired property
Paper: https://igl.ethz.ch/projects/winding-number/robust-inside-outside-segmentation-using-generalized-winding-numbers-siggraph-2013-compressed-jacobson-et-al.pdf
Blender Python API Demo (non-hierarchical vectorized implementation): https://github.com/iyadahmed/meshprocessing_blender/blob/master/volume_sampling/vectorized_winding_numbers.py

Monte Carlo (faster but more prune to errors, it improves the more you increase number of samples):

Doesn't depend on normals
Blender Python API Demo: https://github.com/iyadahmed/meshprocessing_blender/blob/master/volume_sampling/monte_carlo.py

To be fair, rejection sampling isn't the best way to distribute points inside a mesh obviously, but hopefully this is a good starting point

I have been experimenting with ideas for this and currently the best two ways are (both are based on rejection sampling): 1. Generalized Winding Numbers (exact but slow) - Note that it depends on normals, but that might be a desired property - Paper: <https://igl.ethz.ch/projects/winding-number/robust-inside-outside-segmentation-using-generalized-winding-numbers-siggraph-2013-compressed-jacobson-et-al.pdf> - Blender Python API Demo (non-hierarchical vectorized implementation): <https://github.com/iyadahmed/meshprocessing_blender/blob/master/volume_sampling/vectorized_winding_numbers.py> 2. Monte Carlo (faster but more prune to errors, it improves the more you increase number of samples): - Doesn't depend on normals - Blender Python API Demo: <https://github.com/iyadahmed/meshprocessing_blender/blob/master/volume_sampling/monte_carlo.py> To be fair, rejection sampling isn't the best way to distribute points inside a mesh obviously, but hopefully this is a good starting point ![image.png](https://archive.blender.org/developer/F13235082/image.png)

Iliya Katushenock commented

2022-06-28 19:24:25 +02:00

Added subscriber: @mod_moder

Eyad Ahmed commented

2022-06-29 11:48:22 +02:00

Might be useful
https://www.joesfer.com/?p=84

Also this
lightweight_mesh_sampling.pdf

Might be useful https://www.joesfer.com/?p=84 Also this [lightweight_mesh_sampling.pdf](https://archive.blender.org/developer/F13237949/lightweight_mesh_sampling.pdf)

Eyad Ahmed commented

2022-07-01 20:24:47 +02:00

Sampling the Standford bunny
https://github.com/iyadahmed/meshprocessing/blob/main/apps/mcwn.cc

Sampling the Standford bunny https://github.com/iyadahmed/meshprocessing/blob/main/apps/mcwn.cc ![image.png](https://archive.blender.org/developer/F13246608/image.png) ![image.png](https://archive.blender.org/developer/F13246617/image.png)

Eyad Ahmed self-assigned this 2022-07-02 17:01:23 +02:00

Eyad Ahmed commented

2022-07-02 17:01:23 +02:00

I would like to give this a try, the plan is to first use rejection sampling as a start
then in the near future the node could be updated with more methods

I'm happy to hear ideas and discussion

I would like to give this a try, the plan is to first use rejection sampling as a start then in the near future the node could be updated with more methods I'm happy to hear ideas and discussion

Eyad Ahmed commented

2022-07-02 17:04:13 +02:00

actually wait
yes there's already progress here
https://developer.blender.org/D12636

actually wait yes there's already progress here https://developer.blender.org/D12636

Eyad Ahmed removed their assignment 2022-07-02 17:25:11 +02:00

Eyad Ahmed commented

2022-07-02 17:31:08 +02:00

it seems that with this patch and the mesh to volume node we can achieve this

https://developer.blender.org/D12636

it seems that with this patch and the mesh to volume node we can achieve this https://developer.blender.org/D12636 ![image.png](https://archive.blender.org/developer/F13249556/image.png)

Eyad Ahmed commented

2022-07-02 18:29:27 +02:00

This comment was removed by @IyadAhmed

*This comment was removed by @IyadAhmed*

Jacob DeBenedetto commented

2022-07-02 19:29:02 +02:00

Removed subscriber: @doppler

saded beta commented

2022-07-16 18:29:35 +02:00

Added subscriber: @saded

saded beta commented

2022-07-16 18:29:35 +02:00

Hello everyone,
I asked on a mixer forum how to generate fibers (cylinders) in a cube using the geometric knot technique. Someone suggested me a solution that you can find in this link: How to use random cylinders inside a cube with geometric nodes? How to use random cylinders inside a cube with geometric nodes?
This solution of generation of fibers does not result in a volume percentage greater than 15% fiber in the cube.
I want to use these models in my scientific research, I would like to ask you if you could improve this technique to use in this solution to increase the fiber content up to 20 or 25%. Any Help?
Technic of generation

Hello everyone, I asked on a mixer forum how to generate fibers (cylinders) in a cube using the geometric knot technique. Someone suggested me a solution that you can find in this link: How to use random cylinders inside a cube with geometric nodes? [How to use random cylinders inside a cube with geometric nodes? ](https://blender.stackexchange.com/questions/262531/how-to-use-random-cylinders-inside-a-cube-with-geometric-nodes) This solution of generation of fibers does not result in a volume percentage greater than 15% fiber in the cube. I want to use these models in my scientific research, I would like to ask you if you could improve this technique to use in this solution to increase the fiber content up to 20 or 25%. Any Help? [Technic of generation ](https://i.stack.imgur.com/m6nqy.gif)

Eyad Ahmed commented

2022-07-17 13:52:56 +02:00

@saded
btw do you have a working matlab/python code for it?, maybe it could be ported

one idea is to resolve collisions instead of discarding intersecting triangles (move cylinders so that they are not intersected)

you might need a bounding volume hirearchy to make it fast

though maybe the issue with discarding is that the cylinders are too big in the video you show, can you make them smaller and try the same setup again?

also the blender exchange has the file
https://blend-exchange.com/b/pldmd4ep/

@saded btw do you have a working matlab/python code for it?, maybe it could be ported one idea is to resolve collisions instead of discarding intersecting triangles (move cylinders so that they are not intersected) you might need a bounding volume hirearchy to make it fast though maybe the issue with discarding is that the cylinders are too big in the video you show, can you make them smaller and try the same setup again? also the blender exchange has the file https://blend-exchange.com/b/pldmd4ep/

Eyad Ahmed was assigned by Hans Goudey

2022-08-05 17:34:37 +02:00

blender-admin commented

2022-09-19 17:13:55 +02:00

This issue was referenced by b6e26a410c

This issue was referenced by b6e26a410cd29f32da1e8112607a61f29c2863c4

Jacques Lucke commented

2022-10-20 15:20:36 +02:00

Changed status from 'Confirmed' to: 'Resolved'

Jacques Lucke closed this issue

2022-10-20 15:20:36 +02:00

Sign in to join this conversation.

No Label

Download

What's New

Blender Studio

Manual

Developers Blog

Documentation

Benchmark

Blender Conference

Development Fund

One-time Donations

Geometry Nodes: Distribute Points in Volume #85898

Why Volume Point Distribution Is Needed

Volumetrics or Geometry Volume?

Approach 1: Add to the Point Distribute Node

Approach 2: Make it it's own Distribute Node

Approach 3: Make a Volume to Points Node

Progress