Title: Snow Train
Modeled: Semi-Procedural Houdini
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 System Test
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.
Original Video found at:
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 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 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.
POP Speed Limit and POP Drag ensure that pieces don't receive an unrealistic velocity at any point in time.
Grain Source Prep
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.
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
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.
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.
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.
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
**Ensure to turn on "Enlarge Fields to Contain Source" on the volume source node.**
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.
Near identical to Pyro source just without the volume creation.
POP Sim Settings
System Design Tests
RBD Secondary Source: SIM Animation
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
RBD Secondary Source: New Activation
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.
Vellum SIM: Vellum Source Error
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 Grain Test
Pyro Source: Custom Trail
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 SIM: Gas Dissipate Custom
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
1/(24*4) = 0.01 timescale