Simon van de Lagemaat2 By far one of the best examples of this is the VDB scene on the openvdb site. It's out of date but it's STILL one of the best learning resources for a specific methodology I've come across. I learned more from that one scene than any documentation or video.
Wow, thanks Simon for the kind words on my vdb example file!
re: out of date FYI I have a h15.5 vdb3.1 that will be up shortly, and I hope to have a h16, vdb4 version by siggraph for the vdb course [s2017.siggraph.org]. Let me know if there's anything else you want in there.
here's a quick example. the mask to the vdb smooth is intended to a 0-1 scalar vdb for where you want the filter applied.
unfortunately, they hide away the filter width parameter, so I had to crack open the tool to get a more aggressive smooth.
In practice, our artists prefer working with the vdb tools directly, as the one-size-fits-all approach of the particlefluidsurface tool is often very difficult to work with.
I received a question I though others might be interested in: “How do I create a new VDB that matches the topology and resolution of an existing VDB grid”?
It's not straightforward to do this today, but it is possible (we have plans to make this easier in the future). I often find myself needing this in order to build topology for volume wrangles (which only iterate over existing active voxels).
In any case, check out the attached HIP. Create an empty grid via VDB create and specify the name/type/etc. Connect this grid and your reference grid to a VDB combine. The operation “activity union” matches the topology of the empty grid A to the existing grid B.
If you want to match the resolution, choose resample “A to match B”, which uses the voxel size of the existing grid B.
If instead, you want the topology of B, but at a different resolution, you would set this to “B to match A” and then set the voxel size in the VDB create.
You now have active topology to iterate over in a wrangle, etc.
advecting to displace a level set along the gradient isn't necessary. take your level set and add a noise that samples the closest point transform (don't sample the noise via position).
level set -> vdb analysis (CPT) -> merge (level set & CPT)
then, something like this in a volume wrangle (or volume vop): @surface += noise( @cpt )
note you need a wide-enough narrow band to account for how far you displace the level set, so you may need to increase the narrow band (vdb activate sdf) prior to the vdb analysis.
Assuming you have level sets, try linear interpolation with a volume wrangle? (see attached)
the only trick is that volume wrangle only iterates over set voxels, so you may need to resize your narrow band to activate a wider topology (to account for the data in the second input).
the difference is that if you do vdb adect without a solver sop (timestep = $F/24), it's doing the run-up for the entire frame range (0->$F) for every frame's advection; that's a lot of wasted effort.
If instead you use vdb advect in a solver sop (timestep = 1/24), you are only doing that frame's work (not the entire run-up).
FYI another advantage of vdb advect in the solver sop is that the velocity field can change per frame (whereas the alternative only evaluates velocity once).
Of course, the tradeoff is that the solver sop runs in serial, while a vdb advect ($F/24) could be executed in parallel.
3.1 has huge performance improvements over 3.0 and many cool new nodes, but I don't believe SESI included the nodes in 15.5. 3.2 is awesome, it's going to be a really great release too!
If you want to live on the bleeding edge, you might want to learn how to build these plugins. Check out the vdb forum if ya need help
you can generate vdb grids from arbitrary particle attributes via vdbFromParticles' “point attributes” multiparm, hence you can add Cd there to make a color vdb grid.
alternatively, you could skip creating a color vdb grid and simply modify the diffuse color of the volume shader (ie read the point color at rendertime with a pcfilter).
Make a box, then pass that to vdbFromPolys to make your density grid. Assuming you want a mask with a falloff, note the width of the transition from 0-1 in vdbFromPolys can be controlled via “interior band voxels”
hey all, is there a way to tell gplay to frame the geometry on open? ie: commandline argument that performs the same operation as hitting in the 3DV “f”
hey all, I'm exporting “crowd-like” instances to ABC and had a question… If I pass deforming geometry into a Copy SOP then Alembic ROP, all of the nodes in the ABC are instanced correctly.
In practice, you likely want to offset the timing of the instances. Unfortunately, I haven't been able to figure out how to offset the timing and still retain instancing (I've attached a hip). Anyone know how to set this up? thanks!
FYI to check, read the ABC back in and look at the path attribute. if you see “instance” in the name, you're probably good; or you can use python like I do to inspect the file: import alembic
def visitObject(iObj, tab=''): printObject(iObj, tab) for child in iObj.children: visitObject(child, tab+' ‘)
there have been huge advances in vdb from h13 (vdb 1.0 i think?) to h15 (vdb 3.0); actually, it's unfortunate h15 didn't pick up 3.1, as it has large speed improvements. cool new stuff in 3.2 that the team is working to release shortly.
definitely check out our slides; I have a diagram which describes how to sculpt a really nice surface. tldr: you need to complement vdbFromParticles with filtering & morphological operations to get the desired result.
ConvertVDB isn't what you want; it assumes VDB input and outputs what you select in the dropdown.
You have a couple options: VDBFromParticles, which takes points as input and creates a VDB volume. It sounds like you want to render a scalar field (density), so turn off the “distance VDB” checkbox and turn on “Fog VDB”.
volumerasterize points, which accumulates your points in a VDB you supply in the first input, and you can noise up the volume footprint of each point
since Houdini doesnt allow you to author new volume topology in a vop, I prefer to think about the problem as a reverse lookup.
1) create points that match your volume 2) store points' rest position, then perform the deformation 3) make a volume scratch space that you want to write to 4) iterate over the scratch space, use deformed points' rest position to look up the values in your original volume