Are you an intermediate 3D artist who has tried to simulate a beauty product liquid pour shot in Houdini only to end up with messy splashes and slow renders? Do you find the sim settings overwhelming and the lighting unpredictable?
Are you frustrated by shaders that lack realism or worried your render pipeline won’t hold up to an ad-quality standard? Does the thought of integrating fluid sims, materials, and compositing feel like navigating a maze without a map?
If you’re tired of trial and error, this guide is for you. We’ll cut through the noise and lay out a clear workflow that covers setup, simulation, shading, lighting, and render optimization.
By the end, you’ll understand how to craft a polished beauty liquid pour shot in Houdini and overcome common pitfalls—no guesswork, just proven steps toward an eye-catching, professional result.
What references, scene scale, and project settings should I prepare before simulating?
Before launching a liquid simulation, gather high-quality photo and video references of the target pour: lighting, fluid thickness, edge behavior against the container and surface tension at the rim. Record bottle dimensions, fill levels and pouring angles. Accurate measures feed directly into collision geometry and fluid volumes, avoiding scale mismatches later.
Next, establish your scene scale in Houdini’s Units Preferences. If you’re working in meters, model the bottle and catch tray at real-world dimensions (e.g. 0.07 m radius, 0.2 m height). A consistent unit scale ensures the Flip Solver’s particle separation parameter corresponds to actual millimeters, preserving fluid detail and solver stability.
- Units Preferences: set to meters or centimeters, matching modeling package.
- Frame Range > Simulation FPS: match final render (typically 24 or 25 fps).
- Gravity Vector: default −9.81 m/s²; adjust only for stylized motion.
- Collision Margin: 1–2x particle separation to prevent leaks.
- Solver Substeps: 2–4 substeps/frame for high-viscosity pours.
Finally, configure your project settings folder: create a DOP import node network that references a cached Flipbook or .bgeo sequence. Enable auto-save for DOP caches and set a clear naming scheme (bottle_pour_v001.$F4.bgeo). This workflow ensures reproducible results, quick iterations on viscosity, surface tension and particle reseeding without restarting geometry or lighting setups.
How do I model and prep the bottle, cap, and pour geometry for accurate collisions?
Accurate liquid–object interaction in Houdini starts with well-prepared collision meshes. First, model your bottle and cap with correct scale and thickness: ensure the inner cavity is a closed volume so FLIP particles can’t escape. Keep resolution reasonable—aim for 10–20k polygons on the outer shell, higher only where detail matters (threads, lip).
Next, split the assembly into logical groups: one for the stationary bottle walls, one for the removable cap, and a small “pour spout” proxy to emit fluid. Name groups clearly (e.g. bottle_outer, cap_thread, pour_spout) to drive collision and source settings in the DOP network.
- Use a PolyReduce SOP on non-critical faces—threads can stay dense, flat sides can be simplified.
- Run a Clean SOP to remove n-gons and zero‐area faces; repair open edges with a Fuse SOP.
- Compute consistent normals outward via a Normal SOP—necessary for SDF generation.
Convert your cleaned meshes to packed geometry for performance. Packing ensures Houdini treats each part as a single transformable primitive in the DOP, reducing memory overhead. Inside a SOP Solver or before export to DOPs, attach attributes like shop_materialpath or custom collision groups.
Inside the DOP network, import each part as a Static Object with a VDB collision volume: use the VDB from Polygons DOP. This generates a precise signed distance field, giving high-quality impacts without exorbitant substep costs. For the cap (if animated), switch to a Rigid Body Object and reference the same proxy VDB for collision consistency.
Finally, set up the pour spout as the FLIP source: place a small closed mesh at the bottle lip, matching its normals. Use the SOP Fluid Source DOP, pointing to pour_spout group. This focused emitter avoids particles spawning inside walls. Combined, these steps create robust collision geometry for ad-quality liquid pour shots.
How do I set up an ad-quality liquid pour simulation in Houdini (solver, emitters, viscosity, surface capture)?
Emitter and source setup: velocity, emission type, and timing
Inside a DOP Network, create a Flip Object with a Source Volume DOP. Point its SOP Path to the interior of your pour geometry (for example a bottle neck). Set Emission Type to “Volume” to fill the mesh, or “Surface” to emit from a thin shell. Use the Activation tab to animate start and stop frames, ensuring the pour begins precisely at frame 1 and ends when the desired volume has been released.
Control initial velocity by adding a POP Source within the Flip Object. In the POP Source node, switch to “Use External Velocity” to import a custom velocity field from a Velocity SOP, or set a uniform Velocity Scale vector (e.g., –5 in Y for downward motion). This ensures the liquid has enough momentum to break free from the emitter and form realistic streams.
Collision and solver optimization: SDFs, particle separation, and adaptivity
Convert all colliders to signed distance fields (SDFs) by feeding your static or animated geo into an IsoOffset or VDB from Polygons SOP. In the Static Object DOP, choose VDB under Volume Representation. This yields robust contact resolution and prevents leaks when particles interact with complex container shapes.
- Set Particle Separation in the Flip Solver to around 0.005–0.003 for ad-quality detail; smaller values increase resolution at the cost of sim time.
- Attach a Gas Resize Fluid Dynamic DOP to dynamically expand bounds only when the fluid nears edges, reducing wasted voxels.
- Enable Secondary Particles (spray and foam) in the Flip Solver for fine surface details.
- Use substeps (e.g., 2–4) under Solver Settings to maintain stability at high velocities.
For adaptive detail, leverage the Flip Solver’s Particle Separation Scale. By assigning a low scale near the free surface (via a mask), you maintain high fidelity where the viewer focuses, while coarser separation deep inside conserves memory. Finally, capture the surface with a Particle Fluid Surface SOP, adjusting its band width and smoothing iterations to balance crisp highlights against mesh noise.
How do I convert FLIP/particles into a renderable, high-detail liquid surface (meshing, VDB smoothing, contact fixes)?
When working with a FLIP sim you need to convert millions of particles into a continuous, renderable surface. In Houdini, the industry-standard approach uses a VDB From Particles SOP. Set the input attribute (usually pscale or density) and choose a voxel size matching your final render resolution, then generate a signed distance field that approximates the fluid surface.
- VDB From Particles: create initial SDF from pscale
- VDB Resample/Smooth SDF: remove noise and small spikes
- VDB Combine: merge liquid and collider volumes
Next, use the VDB Smooth SDF node to control surface fidelity. A small number of iterations (2–4) preserves splashes while reducing micro-artifacts. If you need sharper droplet details, apply the smoothing selectively by masking regions based on particle velocity or curvature. That avoids over-blurring high-frequency features near the rim of your container.
After smoothing, convert the VDB to polygons with a Convert VDB SOP. Follow this with a Remesh SOP to generate uniform quads or tris for subdivision-friendly topology. Use the edge length parameter to balance mesh density and render performance. A light pass through PolyDoctor can automatically fix non-manifold edges or degenerate faces before shading.
Finally, address contact artifacts at collider intersections: ray-cast samples from the fluid field back to the geometry to detect penetration. Generate an attribute mask where distance-to-collider is below a threshold, and apply a secondary VDB Smooth SDF only in that zone. This targeted fix eliminates spikes or cracks along the vessel while preserving overall detail in open areas.
How do I shade and render the liquid for ad-quality results (materials, IOR, SSS, micro-surface, AOVs)?
Begin with a physically based shader—Houdini’s Material network or a third-party engine like Redshift. A **strong** physically based workflow guarantees your liquid behaves predictably under studio lights. Build a layered network: base transmission, optional SSS, and a micro-surface roughness layer. Organize each stage in a Material Builder for clear parameter control.
For realistic refraction, set the base IOR to 1.33 for water-like fluids or adjust between 1.35–1.45 for thicker oils or lotions. Drive the transmission weight to 1.0 and use color absorption to tint your fluid—pick a subtle gradient ramp in the shader to emulate thickness-based coloration.
If your beauty product has a milky or creamy look, enable Subsurface Scattering. In Redshift, connect an SSS node, choose a radius matching droplet size (0.1–0.3 cm), and set the anisotropy to 0.2 for forward scattering. Control SSS color via a volume absorption texture or ramp mapped along the fluid’s volume attribute.
The micro-surface layer controls specular highlights. Plug a high-frequency noise or a grunge map into your specular roughness input. Keep values between 0.02–0.1 for sharp, glinty highlights, or up to 0.2 for a diffused sheen. Use a Remap Range to fine-tune contrast.
Finally, output dedicated AOVs for compositing:
- Refraction and Specular
- Transmission (with bottled caustics separated)
- SSS or Volume
- Depth (Z) and Cryptomatte for masks
Render in multilayer EXR to preserve each pass. This setup allows nuanced control in post, ensuring your final shot meets ad-quality standards with precise color, reflection, and depth separation.
How do I light, compose, and finish the shot for a beauty product ad (camera, lighting rigs, denoise, compositing passes, and delivery)?
In Houdini’s Solaris context we build the camera and lighting rig alongside USD geometry. Leverage Karma XPU (or Redshift ROP) for interactive lookdev. At /stage, assign materials procedurally and use light filters for precise falloff. Early organization ensures that subsequent sampling and compositing passes align predictably, reducing iteration times and guaranteeing an ad-quality finish.
Position a physical camera node at /stage/cam to replicate an 85mm macro lens. Set f-stop to F5.6–F8 for a shallow depth of field that isolates the product. Enable aperture ramp and focal distance linkage to track geometry pivot. Use the camera’s framing grid to apply the rule of thirds or central symmetry, depending on label orientation, ensuring the focus remains crisp on the product surface.
Build a three-point beauty rig: a key area light above and 30° off axis, an IES-profile fill light at low intensity opposite the key, and a rim light behind to define edges. Add a dome light with an HDRI for environment wrap, dialing down its intensity to avoid flattening specular highlights. In Solaris, adjust light link masks so each light affects only intended USD primitives.
In your render ROP, set pixel samples to 8×8 and light samples to 4. Clamp indirect to 2 for firefly control. After rendering, use the Denoise ROP with Intel Open Image Denoise, feeding both beauty and normal AOVs. This preserves texture detail while smoothing noise. Verify before-and-after denoise buffers in the MPlay viewer to confirm no loss of specular crispness.
- diffuse_albedo
- specular_reflect
- sss_scatter
- transmission
- emission (for glows)
- Z_depth (for focus pulls)
- cryptomatte (for selective grading)
Composite in Houdini’s COPs or export a multichannel EXR to Nuke. In an ACEScg color pipeline, merge passes using light group masks to tweak highlight brightness independently of base color. Use the Z_depth pass for depth-of-field effects and add subtle glare via a glare node or custom lens shader. Balance midtones with a logarithmic grade, then apply a final filmic transform for contrast.
Render final frames at 3840×2160 or higher, 16-bit float EXR. Organize files with descriptive tokens (_[cam]_[light]_v###). For agency review, convert to ProRes 422 HQ using FFmpeg or Adobe Media Encoder, embedding an sRGB LUT. Include a burned-in frame counter and safe-title guides. Finally, perform a test on calibrated monitors to confirm color fidelity before handing off to editorial.