• Facebook - Grey Circle
  • LinkedIn - Grey Circle
  • Vimeo - Grey Circle
  • SideFX Gallery
Snow Train

Title: Snow Train

Programs: Houdini

Modeled: Semi-Procedural Houdini

SIM: Houdini

Lighting: Houdini

Texture: Houdini

Rendering: Mantra

Description:

A project with the intention of designing a system in order to replicate a real-life reference as closely as possible.

Found below is the in progress renders, system design breakdown, and current shot breakdown process.

As of November 16, 2020 (11/16/20) this project is a work in progress. All the work shown so far is not an accurate depiction of the final results until stated otherwise.

Render
websiteComingSoon.jpg
Animation
websiteComingSoon.jpg
Render System Test
Observation
  • The snow the train first comes into contact with instantly breaks apart into a fine powder. Which is then thrown into the air and swirls along the air currents.

  • As the force from the initial impact is transferred along, the snow chunks begin to break apart prior to contact.

    • Which in turn gets thrown into the air and becomes powder.

  • Larger clumps of wet compacted snow are thrown into the air but do not immediately fall apart. Instead, they break into smaller pieces and slowly disintegrate along the outer and trailing edges of the clumps.

Reference
System Design Process
  • Problem: The designed system needs to be able to take animated collision geometry and accurately handle the interpolation/transfer of force to sim objects.

    • Option 1: Rigid Body Dynamic (RBD) Simulation. Handles collisions rapidly and fairly accurately, depending on setup. However, RBD is limited to only previously fractured geo and only solves for the convex hull of objects, not individual points.

    • Option 2: POP Grain Solution. Solves collisions on a per-particle basis based on Pscale. Drawbacks include an older and less efficient system. 

    • Option 3: Vellum Grain. Similar to POP grain in concept, but runs on a much faster algorithm and can handle a much larger quantity of particles. It also includes features of constraint control for clumping. However, for such a large region needed, sim times would grow exponentially with desired detail.

  • Chosen Solution: Use RBD simulation to solve the larger chunk/clumping region. Feed-in animation from RBD and use as sourcing for Vellum grain solver to handle smaller particles clumps only in the desired area. Therefore, increasing the overall solver efficiency.

RBD Source
0001_rbdSource.JPG

RBD sim prep/geo creation. Points are scattered inside a volume with the majority centered around the train's path. The points are then used in a vornoi fracture to create the RBD pieces. 

RBD Constraints
0002_rbdCTS.JPG

RBD constraint creation. The packed geo is unpacked to allow constraint connections. Three main constraints are made.

Glue_Fixed: Used to freeze geometry until needed.

Pin: Allows geometry to bend prior to fully breaking.

Glue_Cluster: Focused upon smaller volume piece to create small random clumps.

RBD SIM
0003_rbdSIM.JPG

POP Speed Limit and POP Drag ensure that pieces don't receive an unrealistic velocity at any point in time.

SIM Settings
0004_rbdSIM.JPG
Grain Source Prep
0005_grainPrep.JPG

The train geometry is given an attribute which is transferred to the newly created packed RBD geo. The sim is frozen and each piece's volume is measured, fit between 0-1 and then transferred back to the animated sim.

Grain Source
0006_grainPrep02.JPG

The selected source is passed to a configure vellum grain node. Each frame the animated geo calculates it's centroid and is then transferred to the newly created grains. The particles are culled based on the camera and Y position to optimize the scene. Afterwards a new velocity is created based on noise and the centroid, which is then added back onto the original velocity.

Grain Source Constraints
0007_grainPrep03.JPG

Create constraints from clusters (class). Next the name attribute is transferred to the create primitives. Any primitives that have two conflicting names/classes are removed and then grouped.

The grain points generate an attraction weight based on AA noise. Finally the points are set as active and combined with constraints.

Grain Sim
0008_grainSim.JPG

Near identical setup to RBD Sim.

  • Problem: The larger pieces and area close to the train need to generate a large amount of material to fill and interact with the air of the scene.

    • Option 1: Particle Operator (POP) Simulation. Capable of generating millions of individual particles, each can be affected by forces such as wind, gravity, and custom fields. Also extremely efficient to solve. The drawback is the number of particles needed to generate the desired effect is beyond substantial (initial guess exceeds 70 million).

    • Option 2: Pyro Simulation. Solved as a fluid and voxels instead of individual particles. When rendered as a volume can cover much larger areas requiring far lower resolutions. Also received a massive update to include sparse solution in Houdini 18. Drawbacks include simulation times are slower due to being three-dimensional instead of points, also less control is available over certain aspects of the simulation.

  • Chosen Solution: Create Sparse Pyro source based on RBD and Vellum Grain results. Results will provide better outcome and more control in the final composite than attempting large particle simulation.

Pyro Source
0009_pyroPrep.JPG

Timeshift RBD to frame 1 and transfer the used group plus the trigger time from animated sim. Scatter points onto this frozen geo and create ID. Move the points based on name from SIM. Blast the points based on velocity and the dot product between the velocity and normal.

Get and add points from grain sim to newly created points.

Pyro Source
0010_pyroPrep.JPG

Trail by length of one. Create primitives based on id (Add node). Resample resolution. Create uv along spline. Use spline to create ramp along length. Convert particles to vdb and back into polygon.

Use new sparce pyro (pyro source) method. Transfer back vel to points. Add noise to vel. Refine density by ramp and area. Finally volume rasterize attributes.

Sparse Pyro Sim
0011_pyroSIM.JPG
Sparse Settings
0012_pyroSIM_02.JPG

**Ensure to turn on "Enlarge Fields to Contain Source" on the volume source node.**

0013_pyroSIM_03.JPG
0014_pyroSIM_04.JPG
0015_pyroSIM_05.JPG
  • Problem: Due to the choice of using sparse pyro to generate the larger mass of airborne snow when rendered the volume will not have the fine specular reflection gained from particle (point) rendering.

  • Chosen Solution: Create a POP simulation to generate airborne particles that are driven by pyro simulation. When rendered and layered together final result will be visually more appealing.

POP Source
0016_popPrep.JPG

Near identical to Pyro source just without the volume creation.

POP Sim
0017_popSIM.JPG
POP Sim Settings
0018_popSIM.JPG
System Design Tests
Shot Breakdown
RBD Source: Heightfield
0001_rbdSource_001.JPG

A heightfield was created for the surrounding environment. A section of the heightfield was taken and converted to geometry to work with.

RBD Source: Create Snow Geometry
0002_rbdSource_createShape.JPG

Vex noise is used to generate the desired look of the top snow. The original geometry position is then mixed between and the updated position using vex to create a smooth transition between the heightfield and soon to be simulation geometry.

RBD Source: Reshape and Reduce
0003_rbdSource_convertVDB.JPG

The VDB is smoothed and dialated to generate a less harsh mesh. It is then converted to polygons and reduced.

RBD Source: Scatter Points
0004_rbdSource_points.JPG

Volum wrangles are used to focus where points are going to be scatter inside the geometry. These points are then used to pre-fracture the snow for RBD simulation.

RBD Source: Fracture
0005_rbdSource_fractures.JPG

Noise is added to the original position and then fractured. Afterwards the rest position is restored and interior detailed added. The pieces are then packed and given a section number.

RBD Source: SIM Geometry
0006_rbdSource_simGeo.JPG

Sim geo is created by remeshing the individual pieces to reduce sim time.

RBD Source: Define Active
0007_rbdSource_groupActive.JPG

All sim geo is turned inactive and then only the desired region is grouped and are turned back to active.

RBD Source: Optimize Active
0008_rbdSource_animateActive.JPG

To prevent simming on unneeded pieces, chunks are turned active only within a certain radius of the train geometry. A SOP Solver is then used to check the previous active state of a piece and if necessary ensure they stay active.

RBD Source: Glue Constraints
0009_rbdSource_constraintsGlue.JPG

RBD Source: Cluster Constraints
0010_rbdSource_constraintsCluster.JPG

Clusters allow the retention of larger and smaller pieces.

RBD Source: Soft Body Constraint
0011_rbdSource_constraintsSoftBody.JPG

Soft body constraints are used to allow a bending/compacting motion to occur.

RBD SIM Network
0012_rbdSIM_settings.JPG
RBD SIM: Settings
0013_rbdSIM_settings2.JPG
RBD SIM: Solver Impulses
0014_rbdSIM_impulse.JPG

The impact data is stored to create impulses to drive later aspects.

Credit:

http://fx.hamletsen.no/2018/01/28/a-setup-for-secondary-rbd-fracturing/

RBD SIM: Constraint Controls
0015_rbdSIM_constraintBreak.JPG

Vex code is used to control when and how the constraints break for more directability.

RBD Secondary Source: Volume
0016_secondaryFracture_volume.JPG

The original high resolution geometry is unpacked so that secondary fractures can be created.

RBD Secondary Source: Volume
0017_secondaryFracture_fracture.JPG

Each piece is measured, blasted if smaller than a certain volume, fractured into ten smaller pieces, packed, transfered its original name, remeshed into a sim geo, and grouped accordingly.

RBD Secondary Source: SIM Animation
0018_secondaryFracture_transferAnimation

The primary sim points are taken and time shifted to $FEND to calculate the @triggertime attribute, vel is adjusted to add randomness, @triggertime is transfered back to the live points. The new fractured SIM geo is animated based of sim points.

Credit: Triggertime creation and usage

http://fx.hamletsen.no/2018/01/28/a-setup-for-secondary-rbd-fracturing/

RBD Secondary Source: New Activation
0019_secondaryFracture_activateSecondary

New fractures are set to @active = 0 and @animated = 1 utnil the condition is met.

Condition is based off of if the points are part of an active group and has an index greater than zero, followed by @triggertime, velocity threshold, and volume threshold.

Each piece is given a random "activate" value, if this value is less then a user given "check" the piece has the opportunity of being turned active.

RBD Secondary Source: New Activation
0020_secondaryFracture_activateSecondary

Blue: @active = 0; @animated = 1;

Grey: @active = 1; @animated = 0;

RBD Secondary Source: Constraints
0021_secondaryFracture_constraints.JPG

Identical setup as primary fracture.

RBD Secondary SIM: Forces
0022_secondaryForces_metaballs.JPG

A metaball is copied to to points on the front of the animated train. Instead of using the "Force" node which would only allow the assignment of one directional force, a wrangle node creates the identical attributes instead giving complete control over the applied forces.

RBD Secondary SIM: Network
0023_secondarySIM_network.JPG

RBD Hero objects are used for the train to gain better control of the density.

RBD Secondary SIM: Settings
0023_secondarySIM_settings.JPG
RBD Tests
Vellum Source: New Sim Points
0024_vellumsource_simPoints.JPG

Take secondary RBD sim points, create a new @triggertime attribute, along with id.

Vellum Source: Set Active
0025_vellumsource_createKeep.JPG

Transfer active and volume. Create random keep attribute.

RBD Secondary SIM: Network
0026_vellumsource_transformPieces.JPG

Transform high resolution geometry based on sim points. Cull any loose pieces that transformed below ground plane.

Vellum Source: Grains
0027_vellumsource_spawnGrain.JPG

Take active source and convert to vellum grain. Unpack rbd geometry and transfer velocity, centroid and id. Cull points to ensure none spawn below ground plane.

Vellum Source: Update attributes
0028_vellumsource_class.JPG

Add noise to velocity to breakup shape. Class is used to randomly select points to generate constraint geometry.

Vellum Source: Constraints
0029_vellumsource_constraints.JPG

Connect adjacent points, transfer and promote name, kill any primitives between name and class points, and then group.

Vellum Source: Pass to SIM
0030_vellumsource_out.JPG

Add ensures that no constraint geometry gets passed into the source. Wrangles are used to give final control over SIM attributes.

Vellum SIM: Forces
0031_vellumSIM_metaball.JPG

Same process taken prior for metablls.

Vellum SIM: Network
0032_vellumSIM_network.JPG

Vellum source is used to allow the import of an animated source.

Vellum SIM: Settings
0033_vellumSIM_settings01.JPG
Vellum SIM: Solver Settings
0034_vellumSIM_settings02.JPG
0035_vellumSIM_settings03.JPG
Vellum SIM: Vellum Source Error
0036_vellumSIM_vellumSourceFix.JPG

The "Vellum Source" node has an error/setting that restricts it to read in a source file only once per integer frame. This does not work when using DOP network substeps.

By unchecking "Use Frame" and replacing "Time Between Frames" with the DOP network timescale inside the "Gas Intermittent Solve" node within vellum source. It now pulls the animated source on every substep accurately.

Vellum SIM: Export and Upres
0037_vellumexport.JPG

Upres technique credited to Steven Knipping

Vellum Grain Test
Pyro Source: Animated Scatter
0038_pyroSource_transfomrPoints.JPG

Points are scatter on the high resolution geometry and given the pieces name. The points are then animated from the vellum source animation.

Pyro Source: Refine Points
0039_pyroSource_refinePoints.JPG

Refine source points based on velocity, position, @triggertime, and boundary.

Pyro Source: Custom Trail
0040_pyroSource_trail.JPG

Houdini "Trail" sop only works in integer frame steps. The behavior is replicated and replaced with the ability to recognize subframes using a timeshift set to subtract one substep from $FF. Add creates a line between point ID, and resample generates more points for better detail.

Pyro Source: Create Source
0041_pyroSource_rasterize.JPG

The lines are converted to vdb then back into geometry where the pyro source scatters points inside. Velocity and ramp are transfered back to points. Noise is added to velocity and then rasterized.

Pyro Source: Grain Source
0042_pyroSource_vellumPoints.JPG

The new vellum grain simulation points are taken and culled based on position, velocity, and density. Finally noise is added using "Point Jitter".

Pyro Source: Grain Rasterize
0043_pyroSource_vellumRasterize.JPG

Group any points that get moved inside train geometry, check bounds, and then rasterize.

Pyro SIM: Airfield
0044_pyroSIM_airfieldPoints.JPG

Station bounds are used to create an airfield region.

Pyro SIM: Airfield
0045_pyroSIM_airfieldRasterize.JPG

Station normals are transfered to the points to create a cross product between it and the airfield noise. It is then rasterized to be passed to simulation.

Pyro SIM:Network
0046_pyroSIM_network.JPG
Pyro SIM: Settings
0047_pyroSIM_settings.JPG
Pyro SIM: Solver Settings
0048_pyroSIM_settings.JPG
0049_pyroSIM_settings.JPG
0050_pyroSIM_settings.JPG
Pyro SIM: Gas Dissipate Custom
0051_pyroSIM_dissipate.JPG

Gas dissipate bases its calculation upon FPS, time defaulting to being 24fps or some derivative of this number value. If set to evaporation of 0.99 it means that the volume would be removed near entirety over 24 frames. If 4 substeps are introduced it means it would take over 96 subframes to be removed.

Instead of adjusting the global FPS and ruining all other simulations, manual parameters were added to calculate a new timescale based on desired number of subframes for evaporation.

1(time)/(5(integer frames) * 4(substeps)) = 0.05 timescale

vs

1/(24*4) = 0.01 timescale

Pyro Tests

All Rights Reserved as intellectual property

by Luke Vuilliomenet