Articles

Exploded View Product Animation in Houdini: Step-by-Step Workflow

ARTILABZ™

ARTILABZ™ gives you unlimited access to all Houdini courses, 3D assets, simulation files, textures and tools. updated every month.

Everything You Need to master Houdini.

01

Premium Houdini Tutorials

Full access to every course — fluid simulation, procedural FX, brand visuals and more.

02

Monthly New Content

Fresh tutorials and assets added every month — your library grows with you.

03

Instant Access to Everything

The moment you join, the full library is yours — no drip-feed, no waiting.

04

Project Files Included

Every tutorial comes with the full Houdini scene file — open every node, learn every detail.

FROM 14.99€/MONTH

Includes one exclusive complete course

The exclusive course — a full production tutorial you won't find anywhere else, never sold alone.

Best Seller
Most Loved
Tutorial Camera Rig

ADVANCED CUSTOM CAMERA RIG

ANIMATION · CONSTRAINTS · CUSTOM UI

BUILD A FULLY CUSTOM CONSTRAINT-BASED CAMERA RIG IN HOUDINI WITH A CUSTOM UI PANEL. DESIGN FLEXIBLE SYSTEMS FOR PRECISE, CINEMATIC CAMERA ANIMATION ON ANY PROJECT.

€29.99

Freebies
Free Studio HDRI Pack box by Artivoxa showing 60 studio lighting setups with softboxes wrapped around the packaging

Studio HDRI Collection

ASSETS · EXR & HDR · 60 HDRIS

DOWNLOAD 60 STUDIO HDRIS CAPTURED IN A REAL PHOTO STUDIO. LIGHT YOUR PRODUCT AND BEAUTY RENDERS LIKE A PHOTOGRAPHER — SOFTBOX, LANTERN, STRIP AND GRID SETUPS, READY FOR ANY RENDERER.

FREE

Exploded View Product Animation in Houdini: Step-by-Step Workflow

An Exploded View Product Animation in Houdini works best when every component has a stable identity, a valid local pivot, and two clearly defined states: assembled and exploded. Rather than moving raw polygons or relying on simulation, build a piece-level transform system that separates asset preparation, layout, animation, and rendering. This produces predictable motion, supports art-directed overrides, and survives common revisions such as updated geometry, new cameras, or alternate assembly sequences.

This advanced workflow covers the complete process: organizing the product asset, generating radial or axis-based separation, preserving rigid transforms and material assignments, sequencing the animation, and preparing the shot for lighting and rendering. It also addresses practical failure modes, including unstable piece IDs, incorrect pivots, intersections, flipped orientations, z-fighting, and unreadable motion.

1. Plan the exploded-view shot

Define what the animation needs to explain before building the Houdini network. The objective may be to show the complete assembly, reveal an internal mechanism, clarify component order, or highlight a replaceable module. That decision determines which pieces need independent motion and how much separation is actually useful.

Do not assume that every disconnected mesh should become a separately animated component. Small screws, washers, clips, and seals can remain grouped with a parent module unless their placement matters to the product story. Separating every polygon island tends to create visual noise, unnecessary transform data, and a more fragile timing system.

Establish the assembly logic

Classify the asset into functional levels such as:

  • Primary components: housings, panels, modules, lenses, boards, and other parts that define the assembly.
  • Attached details: fasteners, clips, washers, and decorative elements that may move with a parent.
  • Nested assemblies: components that should first move as a unit and separate internally later.
  • Nonessential geometry: hidden construction surfaces or redundant detail that does not improve the explanation.

Decide whether the shot shows assembly, disassembly, or both. In every case, retain an authoritative assembled transform for each component. The exploded arrangement should be a second state derived from that rest pose, not the only stored position.

Set the product scale, up axis, forward direction, assembly center, camera range, and frame range at the start. Scale affects separation distances, camera clipping, light size, depth of field, displacement, and motion blur. The assembly center should also be an explicit control rather than an assumption that the product is centered at the world origin.

Judge spacing through the final camera. A layout that appears clear in an orthographic viewport can still contain severe screen-space overlap. Conversely, a mechanically accurate distance may be too small to reveal a thin gasket or connector. Exploded views are explanatory compositions, so legibility can justify controlled exaggeration.

Choose the layout strategy

There are three practical approaches to part separation:

Method Best suited to Main controls
Radial Assemblies with a clear center and parts distributed around it Center, distance, direction bias, and per-piece weight
Axis-based Products built along a dominant opening or construction direction Local axis, signed travel, spacing, and direction overrides
Art-directed Asymmetrical products and tightly composed hero shots Per-piece target transforms, pivots, and manual offsets

A hybrid system is usually the most flexible. Generate an initial radial or axis-based layout, then add non-destructive overrides for pieces that intersect, disappear behind the product, or need extra emphasis. Keep generated offsets and manual corrections in separate attributes so a procedural update does not erase approved art direction.

2. Prepare the product asset

Asset preparation determines whether the setup remains stable after a modeling revision. Before creating animation controls, inspect the imported geometry at both object and SOP levels. Confirm units, object transforms, normals, topology, material assignments, duplicate surfaces, non-manifold areas, and hidden renderable geometry.

Do not automatically bake object transforms if the asset must remain compatible with an existing USD hierarchy, layout scene, or animation rig. Instead, document where the authoritative transform lives and convert spaces deliberately.

Create meaningful component boundaries

Preserve an existing assembly hierarchy whenever possible. FBX, Alembic, USD, or CAD-derived assets may already contain useful object paths, component names, material bindings, and local transforms. Reconstructing these boundaries from polygons can discard information that the source application has already provided.

When no usable hierarchy exists, component boundaries can come from several sources:

  • physically disconnected regions identified with Connectivity SOP;
  • existing primitive groups or object paths;
  • material assignments or CAD part identifiers;
  • manually authored groups for components that are connected topologically but must move independently.

Convert the result into a stable string attribute such as name. Connectivity class values are useful during preparation, but they are unsafe as permanent identities because topology edits, Boolean operations, merges, and primitive reordering can change their numbering.

Use deterministic names such as housing_main, lens_front, and screw_014. If identical parts are generated procedurally, derive their suffixes from persistent source data or documented assembly locations rather than current point or primitive numbers.

Stable names allow the same pieces to recover their transforms, timing, materials, cache assignments, and render overrides after an update. Validate the names before continuing: missing and duplicate values should be treated as asset errors, not repaired implicitly inside the animation network.

Author pivots and local frames

A rigid component needs more than a center position. It needs a local frame that describes how it should translate and rotate. The geometric centroid may be acceptable for a simple outward translation, but it is rarely appropriate for a lid, hinged panel, screw, gear, or sliding mechanism.

Use source assembly transforms where available. Otherwise, derive pivots and orientation from authored guide points, construction geometry, measured axes, primitive normals, or known mechanical relationships. Common Houdini representations include:

  • a pivot position and quaternion orient attribute;
  • a complete per-piece transform matrix;
  • the transform intrinsic of a packed primitive;
  • a control point carrying the rest and target transforms for a named piece.

Choose one coordinate convention and use it throughout the system. Mixing world-space Euler rotations, local quaternion orientations, and object-level transforms without explicit conversions is a common source of tilting, flipping, and unexpected rotation axes.

Test the frames before building the exploded layout. Display pivot markers and local axes, then apply a temporary rotation to each component. A panel should turn around its hinge, a screw around its shaft, and a gear around its axle. Correcting these frames later can invalidate an otherwise approved animation.

Pack rigid components without losing render data

Packed primitives are well suited to rigid product components. They reduce transform overhead, preserve high-resolution geometry behind lightweight representations, and provide one logical primitive per piece. They also work naturally with piece-matching workflows such as Transform Pieces SOP.

Before packing, verify that the following information survives the operation and any later unpacking:

  • name and other piece-level attributes;
  • UVs, vertex normals, and custom normals;
  • primitive material assignments and USD material bindings;
  • render visibility and instancing data;
  • decals, displacement attributes, and renderer-specific properties.

Packing is not a substitute for correct organization. Keep an unpacked source or render branch when downstream operations require topology access, deformation, or per-face editing. The packed animation branch should drive transforms without becoming the only copy of the prepared asset.

3. Build an art-directable exploded layout

Create a lightweight control representation with one point or packed representative per component. Match it to the source geometry by name, and store all layout controls there rather than repeatedly modifying the render geometry.

A useful control point can carry:

  • name and optional parent or assembly_id;
  • rest_center, rest_transform, and bounding-box dimensions;
  • explode_dir or explosion_axis;
  • distance_scale and piece_mask;
  • manual_offset and optional target rotation;
  • timing attributes such as priority, delay, and duration.

Generate radial separation

For a radial layout, derive the initial direction from the piece center and an explicit product center:

radial = normalize(rest_center - product_center)
offset = radial * base_distance * distance_scale * piece_mask
target_position = rest_center + offset + manual_offset

Guard against pieces whose centers coincide with the product center. Normalizing a zero-length vector can create invalid or unstable values; assign those pieces a documented fallback axis or a manual direction.

Scale the offset according to the visual role of the component rather than its size alone. Bounding-box dimensions can provide an initial spacing estimate, but a thin gasket may require disproportionate screen-space separation, while a large outer shell may need only a short move to expose the interior.

Use local axes where radial motion fails

Radial movement is often inappropriate for rails, panels, shafts, lids, stacked layers, and parts constrained by a mechanical opening direction. Store a per-piece explosion_axis and blend it with the radial vector:

direction = normalize(lerp(radial, explosion_axis, axis_weight))
offset = direction * distance

The axis should be transformed from the component’s local frame into the required working space. A global X, Y, or Z vector may appear correct in the default pose but fail when the product or subassembly is rotated.

Keep manual offsets additive and separate from the generated result. This distinction allows global controls—such as explosion distance or axis bias—to remain useful without destroying corrections for individual pieces.

Preserve orientation with rigid transforms

Apply offsets through packed primitive transforms, per-piece matrices, or a Transform Pieces workflow that matches rest and target control points by name. Preserve the source geometry as a rest branch and use the control geometry only to drive transformations.

Translation alone is often enough for a technical exploded view because it preserves the installed orientation and makes component relationships easy to compare. Add rotation only when it clarifies a mechanism, reveals an important surface, or follows a meaningful assembly path. Decorative tumbling usually makes the sequence harder to read.

When rotation is required, rotate around the component’s local pivot and store the target orientation explicitly. Do not derive it from the current animated geometry each frame; that can introduce transform accumulation and prevent the part from returning exactly to its rest state.

Handle nested assemblies

A button inside a housing or a lens inside a barrel should not necessarily receive an independent world-space explosion. Define parent-child relationships so children inherit a parent transform and then receive a controlled local offset:

child_world_transform = parent_world_transform * child_local_transform

Two staging patterns are particularly useful:

  • Rigid subassembly staging: move a complete module first, then separate its internal components.
  • Hierarchical local offsets: move the parent while selected children separate within the parent’s frame.

Calculate and compose the parent transform before the child’s local transform. Applying the parent translation at the assembly level and then adding it again to each child is a common cause of doubled offsets and drifting parts.

Resolve intersections deliberately

Bounding-box checks can flag likely collisions, but they are only approximations for concave or irregular components. When an overlap appears, determine whether its cause is an incorrect center, a poor direction, insufficient distance, or an invalid hierarchy. Increasing the global explosion amount may clear one intersection while creating several others.

Prefer a revised local axis, a manual correction vector, or staged timing for the affected piece. Rigid-body simulation is rarely necessary for a technical exploded view; it becomes useful only when the shot depends on physically caused contact, gravity, constraints, or believable secondary motion.

4. Animate between assembled and exploded states

Treat the approved layout as a stable target state. Each component should have an assembled transform and an exploded transform, with a normalized control such as assembly_progress driving the transition. A value of zero can represent the assembled product and one the exploded arrangement.

This state-based design makes the animation reversible and avoids cumulative errors. Never compute a new target from the previous frame’s animated geometry. Both transforms should come from fixed rest data and deterministic layout controls.

Create per-piece timing

Derive a local progress value from the global control, delay, and duration:

local_u = clamp((assembly_progress - delay) / duration, 0, 1)

For disassembly, interpolate from the assembled transform to the exploded transform. For assembly, reverse the interpolation or invert the global progress. Apply easing after calculating each piece’s normalized local progress so that delay and duration retain predictable meanings.

Use product logic rather than random offsets to define the sequence. An order such as outer shell, fasteners, bracket, electronics, and core mechanism communicates structure. Useful attributes include:

  • Priority: defines the broad assembly stage.
  • Delay: offsets the start without changing the target transform.
  • Duration multiplier: gives major pieces more screen time.
  • Animation mask: excludes stationary or currently irrelevant components.

Nested parts should normally begin relative to their parent’s progress. Allow the housing to clear the view before moving the bracket inside it, or move the complete module first and expose its internal sequence in a later beat.

For a deeper treatment of sequencing and transform architecture, see the related procedural product assembly workflow.

Interpolate rotation safely

Quaternions are generally preferable for interpolating orientations because they avoid many Euler-order discontinuities. Store compatible rest and target quaternions, then use spherical interpolation. If Euler rotations are required, define the rotation order explicitly and watch for axis-boundary flips.

Translation and rotation can use different remapped progress curves. A cover might rotate around its hinge first and translate away only after opening. Separating these channels avoids the unintended arc that can result from interpolating one combined transform between distant poses.

Preview the animation forward and backward through the final camera. Look for:

  • intersections during intermediate frames, not just at the endpoints;
  • orientation flips and long-path quaternion interpolation;
  • small components becoming unreadable at shot scale;
  • surfaces remaining close enough to cause z-fighting;
  • motion that implies an incorrect assembly order.

Use temporary piece colors, labels, pivot guides, and motion trails during diagnosis. If a component suddenly receives another part’s motion, investigate upstream naming and piece matching before editing the animation curves.

5. Compose, light, and render the product

The final camera should preserve the recognizable product silhouette while exposing the relationships the animation is meant to explain. A three-quarter view often gives useful depth cues, but the best angle depends on the assembly. Important fasteners, connectors, contact surfaces, and internal modules should not be hidden behind larger components.

Compose for technical readability

Choose focal length according to the desired perspective. A wider lens fits more separation into a compact frame but exaggerates depth and scale. A longer lens produces a more orderly, diagrammatic appearance but requires more camera distance. Do not use focal length to compensate for a layout that needs better component spacing.

Evaluate the complete frame range, including the widest exploded state and any motion-blur extension near the image boundary. Keep critical components separated in screen space and test the shot with neutral clay materials. If the hierarchy is unclear without color and reflections, it is probably a composition or timing problem.

Use depth of field conservatively. Shallow focus can direct attention, but it can also hide seams, fasteners, and contact surfaces that explain the assembly. Check focus and blur at the intended delivery resolution.

Light for form and material identity

Use broad sources to establish the overall form, then add controlled fill or rim lighting where thin parts and internal layers need separation. Reflections should describe curvature and finish without obscuring labels or mechanical interfaces. The principles in this guide to three-point product lighting provide a useful foundation, although complex reflective products may require additional cards and shaped sources.

Preserve distinctions among metal, coated plastic, rubber, glass, and untreated internal surfaces. Roughness and highlight structure are often more informative than base color alone. Verify that newly exposed interior faces have the intended material rather than inheriting an exterior shader accidentally.

Contact shadows can reinforce where a component seats against another surface, but excessive ambient occlusion can make clean products look dirty and exaggerate gaps. Evaluate reflections and shadow movement over the complete animation, not only on a hero frame.

Configure motion blur and render detail

Motion blur should communicate direction without making small parts disappear. If a fastener becomes an unreadable streak during an important beat, adjust its speed, exposure treatment, or timing rather than relying on sharpening in post-production.

Confirm that the renderer correctly interprets packed transforms, instancing, velocity or transform samples, deformation, and camera motion. Displacement bounds must also be sufficient for displaced surfaces without creating apparent intersections. For a Karma-based pipeline, the Karma product visualization setup covers the broader render configuration.

Keep layout controls independent from render quality. Sampling, denoising, displacement, texture resolution, depth of field, and motion-blur settings should not change piece identities or animation transforms.

6. Troubleshoot and prepare the setup for production

Intersecting components

Display explode_dir, explode_distance, bounds, and piece names. Determine whether the collision comes from an incorrect direction, insufficient clearance, or a child moving independently of its parent. Apply a targeted axis or offset correction before increasing the global explosion distance.

Incorrect pivots or drifting parts

Verify that the pivot is defined in the same space as the transform being applied. Check the packed primitive intrinsic, rest matrix, and transform order. A component that shears or deforms is probably being modified at point level when it should receive a rigid piece transform.

Also inspect attribute ownership. A primitive attribute does not automatically behave like a point attribute, and a detail value affects every component unless it is explicitly remapped. Make ownership and promotion steps visible in the network.

Flipped or unstable orientations

Confirm that rest and target orientations share the same local frame and quaternion convention. For Euler rotations, inspect the rotation order and values crossing axis boundaries. Avoid reconstructing orientation from changing geometry if the source asset can provide a stable frame.

Pieces change behavior after an asset update

This nearly always indicates unstable identity data. Compare the current component list with the previous version and check for missing, duplicated, or renamed values. Do not use connectivity numbers, point order, or primitive order as production identifiers.

Flickering and z-fighting

Search for duplicate geometry, coincident caps, hidden renderable meshes, overlapping shell layers, and packed instances that contain an unexpected copy. Disable displacement and motion blur in a diagnostic render. If the artifact disappears without displacement, inspect surface construction, displacement bounds, and shader offsets before changing animation spacing.

Motion is technically correct but difficult to read

Reduce simultaneous movement, stagger assembly stages, and shorten unnecessary travel. If internal components remain hidden, adjust the camera or outer shell timing rather than pushing every piece farther away. A clear exploded view normally uses restrained, purposeful motion rather than elaborate trajectories.

Cache and version the approved animation

Separate the network into identifiable stages:

  1. source asset preparation;
  2. component naming and validation;
  3. pivot and hierarchy construction;
  4. exploded layout controls;
  5. animation and timing;
  6. geometry or USD caching;
  7. look development, lighting, camera, and rendering.

Cache only after names, pivots, transforms, hierarchy, and timing have been validated. Include the asset version and shot variant in the cache path, and retain the procedural source used to generate it. A cache should freeze an approved stage, not conceal unresolved identity or transform problems.

Before delivery, test alternate explosion distances, both animation directions, a different frame range, and at least one camera variation. Confirm that every renderable component retains its stable name, material assignment, pivot, rest transform, and intended visibility. Document the coordinate convention, required attributes, cache dependency, frame range, and renderer-specific assumptions so the setup can be revised without reverse-engineering the node graph.