Procedural and Hybrid 4D

Procedural and Hybrid 4D is a compound domain in graphics and creative tooling that unifies two convergent paradigms: (1) procedural generation — the algorithmic, rule-driven construction of geometry, materials, animation, simulation, and environment data using mathematical operations rather than…

Semantic Classification

Content

Compositional Relationships (Components)

SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:HoudiniSideFX))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:BlenderGeometryNodes))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:UnrealPCG))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:EmberGen))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:Cascadeur))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:WonderStudio))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:OpenUSD))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:FourDGaussianSplatting))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:NeRF))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:SDFHybridModels))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:hasPart gct:Infinigen))

## Dependency Relationships
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:requires gct:GPUCompute))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:requires gct:PhysicsSolver))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:requires gct:SceneGraph))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:requires gct:NeuralNetwork))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:requires gct:TemporalSampling))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:dependsOn gct:OpenUSD))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:dependsOn gct:CUDA))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:dependsOn gct:DifferentiableRendering))

## Capability Relationships
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:enables gct:PhotorealisticSynthesis))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:enables gct:DynamicSceneReconstruction))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:enables gct:RealTimeVFX))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:enables gct:ProceduralWorldBuilding))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:enables gct:AIAnimation))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:enables gct:SyntheticDataGeneration))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:supports gct:FilmVFXProduction))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:supports gct:GameDevelopment))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:supports gct:VirtualProduction))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:supports gct:XRContent))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:supports gct:RoboticsSimulation))

## Implementation Relationships
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:implements gct:GaussianSplatting))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:implements gct:NeuralRadianceField))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:implements gct:SignedDistanceFunction))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:implements gct:MaterialPointMethod))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:implements gct:FLIPSolver))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:implements gct:DeformationField))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:implements gct:HydraRendering))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:uses gct:VEXScripting))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:uses gct:DiffusionModel))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:uses gct:TransformerArchitecture))

## Reduction Relationships
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:reduces gct:ManualArtistTime))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:reduces gct:AssetCreationCost))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:reduces gct:SimulationLatency))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:reduces gct:CaptureRequirements))
SubClassOf(gct:ProceduralAndHybrid4D
  ObjectSomeValuesFrom(gct:reduces gct:IterationTime))

## Annotations
AnnotationAssertion(rdfs:label gct:ProceduralAndHybrid4D "Procedural and Hybrid 4D"@en)
AnnotationAssertion(rdfs:comment gct:ProceduralAndHybrid4D "Domain cluster unifying procedural 3D/4D generation — Houdini SideFX (Mantra/Karma/Solaris USD), Blender Geometry Nodes, Unreal PCG, EmberGen, Cascadeur, Wonder Studio — with hybrid neural representations (4DGS, NeRF+SDF, GSDF) and generative AI pipelines lifting video or text prompts to time-varying volumetric content."@en)
AnnotationAssertion(dcterms:identifier gct:ProceduralAndHybrid4D "GC-0041"^^xsd:string)
AnnotationAssertion(dcterms:subject gct:ProceduralAndHybrid4D "Procedural Generation, Gaussian Splatting, 4DGS, NeRF, Houdini, Geometry Nodes, PCG, Simulation, VFX"@en)

About Procedural and Hybrid 4D

• Procedural and Hybrid 4D sits at the intersection of three long-running traditions in computer graphics: classical algorithmic content generation (L-systems, noise functions, physics solvers), physically-based simulation, and — since approximately 2020 — neural implicit and explicit representations that can reconstruct or synthesise scene content from images, video, or text. The “4D” qualifier in the domain name signals the temporal axis: any representation that models how a 3D scene evolves over time is a 4D representation, whether that is a keyframed character rig, a fluid simulation time-series, a Houdini VEX-scripted growth animation, or a 4D Gaussian Splatting model capturing a performer’s motion. Procedural techniques and 4D representations are mutually reinforcing: procedural rules naturally encode temporal variation (e.g., a noise field advected through time for fluid turbulence, an L-system tick advancing plant growth), while neural 4D representations benefit from procedural priors (SDF distance fields constraining Gaussian Splatting, PCG graphs seeding neural scene generators).
• The economic driver is clear: a single hand-crafted hero asset in a feature film might cost £50,000–£500,000 in artist time. Procedural generation collapses this cost for secondary, background, or naturally varying content (forests, crowds, terrain, fire, destruction) by orders of magnitude. The UK’s VFX industry — the world’s second-largest behind the US — has been a central force in the development of procedural production pipelines, from Framestore’s 2024 transition of its lighting pipeline to Houdini Solaris/USD on Project Hail Mary to DNEG’s complete migration from Clarisse to Houdini Solaris between seasons of The Last of Us. Foundry London produces Katana, Mari, and Nuke — the industry-standard look-development, texture painting, and compositing tools that interface directly with Houdini-based procedural pipelines via OpenUSD.
• The neural hybrid dimension emerged from two research breakthroughs: Neural Radiance Fields (NeRF, Mildenhall et al. 2020) demonstrated that implicit neural representations could reconstruct photorealistic scenes from sparse posed images, and 3D Gaussian Splatting (3DGS, Kerbl et al. SIGGRAPH 2023) demonstrated that explicit point-cloud representations with anisotropic Gaussians could achieve real-time rendering at equivalent or superior quality. Extending these to 4D — incorporating deformation fields, temporal encodings, and dynamic appearance — defines the frontier of the field as of 2026.

Core Mathematical Foundations of Procedural Generation

• Procedural generation is formalised through several mathematical frameworks, each suited to different categories of content. L-systems (Lindenmayer Systems) define plant and organic structure generation via rewriting rules applied to symbol strings: for a string alphabet Σ, axiom ω ∈ Σ*, and production rules P: Σ → Σ*, each system iteration applies all rules simultaneously (parallel rewriting) to produce successively complex strings interpreted geometrically via turtle graphics. Context-free L-systems (DOL-systems) suffice for many plants; context-sensitive L-systems communicate environmental signals (available light, gravitational direction) between adjacent modules, producing environmentally responsive growth.
• Noise-based proceduralism underlies terrain, cloud, and material generation. Perlin noise f(x) = ∑ₙ persistence^n × noise(frequency^n × x) with octaves n=1..8 and typical persistence=0.5, frequency=2.0 produces fractal Brownian motion (fBm) with controllable roughness. Worley (cellular) noise generates voronoi-based organic patterns (stone, water caustics, skin). Domain warping (Inigo Quilez 2002) feeds noise back into itself: f(p) = noise(p + noise(p + noise(p))), producing turbulent, fluid-like forms used for procedural clouds and fire in Houdini Volume VOPs.
• Physics-based proceduralism is mathematically equivalent to numerical integration of PDEs over the scene’s temporal domain. Fluid simulation in Houdini uses the incompressible Navier-Stokes equations: ∂u/∂t + (u·∇)u = -∇p/ρ + ν∇²u + f, ∇·u = 0, where u is the velocity field, p is pressure, ρ density, ν kinematic viscosity, and f external forces (gravity, buoyancy). The FLIP solver discretises this as a hybrid particle-grid system: particles carry mass and velocity; a background MAC (Marker-And-Cell) grid handles pressure solve and incompressibility projection. Each timestep: (1) transfer particle velocities to grid via P2G (particle-to-grid); (2) apply forces and solve pressure projection on grid; (3) transfer updated velocities back to particles via G2P; (4) advect particles with updated velocities. This yields detailed fluid with minimal numerical diffusion — critical for smoke rising columns, river rapids, and ocean surface detail.
• Graph-based proceduralism (Houdini SOP networks, Blender Geometry Nodes, Unreal PCG Graphs) represents generation as directed acyclic graphs (DAGs) of typed operators: each node N: Type_in → Type_out transforms geometry, volume, point cloud, or attribute data deterministically (or stochastically with controlled seed). Network composition G = (V, E) where V is the set of operators and E the dependency edges admits automatic re-evaluation when any upstream node changes — the foundation of the non-destructive, parameter-driven workflow that makes procedural tools superior to manual modelling for iterative design exploration.

The Gaussian Splatting Revolution and its 4D Extension

• 3D Gaussian Splatting (3DGS, Kerbl et al. SIGGRAPH 2023) represents a scene as a set of N anisotropic 3D Gaussians G = {(μᵢ, Σᵢ, αᵢ, cᵢ)}ᵢ₌₁ᴺ where μᵢ ∈ ℝ³ is the Gaussian mean (position), Σᵢ = RSSᵀRᵀ is the covariance (decomposed into rotation R and scale S matrices), αᵢ ∈ [0,1] is opacity, and cᵢ represents view-dependent colour encoded as spherical harmonic (SH) coefficients. Rendering is performed by differentiable rasterisation: Gaussians are projected onto the image plane as 2D covariances Σ’ᵢ = JWΣᵢWᵀJᵀ (where J is the Jacobian of the projection and W the viewing transformation), sorted by depth, and alpha-composited front-to-back using C = ∑ᵢ cᵢαᵢ ∏ⱼ<ᵢ (1-αⱼ). Optimisation by gradient descent (Adam) on photometric loss simultaneously updates all Gaussian parameters and applies adaptive density control — splitting, cloning, and pruning Gaussians to match scene complexity. This achieves 30-120 FPS rendering at 1080p on RTX 3090-class hardware with training in 30-45 minutes from 100-300 posed images.
• Extending to 4D requires modelling temporal evolution of each Gaussian’s parameters. The dominant decomposition treats position μ(t), rotation R(t), scale S(t), opacity α(t), and colour c(t) as functions of time t ∈ [0,T]. Wu et al. (CVPR 2024) parameterise these functions using a HexPlane representation: a set of six 2D feature planes (XY, XZ, YZ, XT, YT, ZT) that factorize the 4D space-time volume, enabling efficient feature retrieval via bilinear interpolation and concatenation: f(x,y,z,t) = cat[φ_XY(x,y), φ_XZ(x,z), φ_YZ(y,z), φ_XT(x,t), φ_YT(y,t), φ_ZT(z,t)]. A compact MLP Ψ: f → Δ(μ, R, S, α, c) decodes the feature vector into Gaussian deformation parameters. This architecture achieves real-time rendering (82 FPS at 800×800 on RTX 3090) with training on a 25-second monocular video in ~1 hour — enabling practical dynamic scene capture for production use.
• The Fudan ZVG approach (ICLR 2024) instead formulates native 4D Gaussian primitives with 4D covariance tensors Σ₄ᴅ ∈ ℝ⁴ˣ⁴ and 4D Spherindrical Harmonics (4D-SH) encoding time-varying view-dependent appearance, treating time symmetrically with space rather than as a deformation parameter. This provides superior appearance modelling for fast-moving objects with significant view-dependent colour changes (metallic reflections under dynamic lighting, translucent material caustics) at the cost of higher memory and training compute requirements.

Generative AI as a Procedural Prior

• The frontier of procedural and hybrid 4D in 2026 is the integration of large-scale generative AI models — specifically video diffusion models and 3D-aware image generation models — as high-level procedural priors that constrain or initialise lower-level geometric representations. The key insight is that a video diffusion model trained on billions of video frames implicitly encodes physical world priors: objects maintain consistent identity through occlusion, lighting changes in physically plausible ways as cameras move, and deformable objects follow plausible dynamics. These priors are expensive to encode explicitly in procedural rules but emerge naturally from data-driven learning at scale.
• Video-to-4D lifting pipelines extract this implicit knowledge: given an input video V = {I_t}_{t=1}^T, (1) a depth estimation network (DPT, Depth Anything V2) produces per-frame depth maps D_t; (2) camera poses are recovered via COLMAP or a learned pose estimator; (3) a 4DGS model is initialised from the deprojected point cloud and optimised using photometric and depth consistency losses. The video diffusion model contributes through score distillation sampling (SDS) — gradients from the diffusion model’s score function guide 4DGS optimisation toward scene configurations that the diffusion model considers plausible. Sora3R (2025) demonstrates this architecture repurposing Sora’s video latent space as the 4D reconstruction backbone, achieving state-of-the-art dynamic scene quality from single monocular videos.
• This pipeline collapses the traditional capture-and-reconstruct workflow (requiring multi-camera studio rigs costing £100K-£500K to deploy) into a single-camera or even AI-hallucinated 4D scene creation system — a fundamental democratisation of dynamic 3D content creation analogous to how text-to-image diffusion collapsed the barrier to 2D digital art creation in 2022.

Components / Architecture

Houdini SideFX — Procedural VFX Authoring

• Houdini by SideFX is the industry-standard procedural content creation platform used in virtually every major VFX and game studio worldwide. Its architecture exposes a node-graph (called an operator network or SOP — Surface Operator — network) in which each node is a deterministic or stochastic function that transforms or generates geometry, volumes, particles, or simulations. The VEX (Vector Expression) language provides GPU-acceleratable code execution directly within node graphs. Unlike Maya’s history-based stacking, Houdini’s network model is a true DAG of composable operators: any node’s output can feed any compatible downstream input, forming arbitrary computation pipelines. Geometry in Houdini is represented as a typed attribute soup (points, vertices, primitives, detail-level) with an arbitrary schema — any named attribute of any numeric type can be created, manipulated, and exported, making Houdini a general-purpose spatial computing platform beyond pure rendering.
• Houdini’s Simulation Framework: The DOP (Dynamic Operator) network handles multi-solver physics: Pyro (finite-difference volumetric fire/smoke), FLIP fluids (particle-grid hybrid), Vellum (position-based cloth, soft-body, grain), Wire dynamics, and now MPM (Material Point Method). Solvers are composable — FLIP fluid can source Pyro simulation, Pyro emits particles that drive rigid bodies — enabling coupled multi-physics simulations characteristic of large-scale destruction, ocean spray, and avalanche sequences. The SOP-DOP-ROP pipeline (geometry → simulation → render) forms a completely non-destructive, re-cookable pipeline where changing a single upstream parameter propagates automatically to all downstream results.
• Houdini 20.5 (released July 2024) introduced the MPM (Material Point Method) solver for solid mechanics simulation of granular materials (sand, snow), elastic deformation, and fracture; Copernicus for node-based image processing and material generation within the DCC (procedural texture creation without leaving Houdini); and Quick Surface Materials for MaterialX-based shading. The KineFX character rigging framework received skeletal tag assignment enabling procedural rig component routing — one network defines the rig logic, tags on the skeleton determine how modular rig components attach, enabling procedural character assembly for crowd simulation and creature variation workflows.
• Houdini 21 (released August 2025) delivered what SideFX described as the “largest number of new features in Houdini ever” across 360+ bullet points. Key additions include: ML Nodes — fully automated end-to-end ML pipelines directly within the DCC (data generation, preprocessing, training, inference, all as Houdini nodes); Neural Point Surface using trained neural networks for robust point cloud meshing superior to traditional Poisson reconstruction on sparse or noisy data; and the KineFX Autorig Builder enabling less-technical character artists to assemble pre-built modular rig components into working character rigs without manual rigging expertise.
• Solaris is Houdini’s USD-native layout, lookdev, and lighting environment built on Pixar’s OpenUSD. Lighting operators (LOPs) manipulate USD prims procedurally — one LOP network can generate thousands of light variants for multi-shot environments, applying overrides, material bindings, and render settings as non-destructive USD layers. Karma is Houdini’s production renderer with two modes: Karma CPU (unbiased path tracer) and Karma XPU (simultaneous GPU+CPU acceleration via CUDA/Metal), both interfacing through Pixar’s Hydra rendering delegate framework. The Hydra abstraction means Houdini scenes can switch seamlessly between Karma XPU (artist preview and final render) and third-party delegates (Arnold, V-Ray, RenderMan) without scene modification. Framestore and DNEG migrated full lighting pipelines to Houdini Solaris in 2024 for Project Hail Mary and The Last of Us respectively — representing a paradigm shift from traditional static lighting scenes to dynamic, procedurally-driven lighting environments where one artist can light an entire film’s worth of environments through parameterised network automation.

Blender Geometry Nodes

• Blender Geometry Nodes is the open-source counterpart to Houdini’s SOP networks, providing visual programming for procedural geometry within Blender. First introduced experimentally in Blender 2.92 (2021), the system underwent rapid development through the Blender Foundation’s Everything Nodes initiative and reached production maturity through the 4.x series. Geometry Nodes operates on a fields architecture: rather than computing scalar values per-element immediately, field expressions are lazily evaluated only when a value is needed for output — analogous to functional reactive programming. This enables complex procedural setups that reference “what is this vertex’s position?” without per-vertex evaluation overhead until render time. The system supports geometry types including meshes, curves, point clouds, volumes, and instances, with a unified attribute system enabling arbitrary per-element data (float, vector, integer, boolean, colour, string) to flow through the graph.
• Blender 4.0 (November 2023): Rotation sockets and eight new rotation nodes (Rotate Rotation, Invert Rotation, Mix Rotation, etc.) enabling non-gimbal-locked rotational proceduralism; Simulation Zone per-node baking enabling frame-cached physics within the Geometry Nodes graph rather than requiring separate DOP-equivalent networks.
• Blender 4.1 (March 2024): Edge sharpness and split normals controllable from Geometry Nodes without requiring an original mesh with pre-baked normals — critical for hard-surface procedural modelling; persistent data storage within node groups enabling subgraph output caching (memoisation) so expensive operations (point cloud generation, BVH construction) are computed once and reused; the Menu Switch node for artist-facing dropdown menus in modifier panels; Active Camera node; Index Switch node for input routing via integer index; Sort Elements node for redefining vertex/edge/face topological order; Split to Instances for mesh decomposition by ID attribute.
• Blender 4.2 (July 2024): Major Geometry Nodes release with two dedicated developer showcase videos. Grease Pencil geometry nodes integration began in Blender 4.3, enabling procedural 2D stroke generation within the 3D scene graph — used for procedural toon shading, technical illustration, and motion graphics workflows. The October 2024 Geometry Nodes Workshop (Blender code.blender.org) established roadmap priorities including field expression simplification, simulation zone performance, and future support for Cycles/EEVEE shader graph integration.
• Infinigen (Princeton Vision & Learning Lab, BSD 3-Clause) is an open-source Blender-based procedural scene generator producing photorealistic training data for computer vision research. Infinigen’s approach differs from asset-library procedural tools: every object — plants, rocks, animals, terrain, atmospheric effects — is generated entirely from randomised mathematical rules with no pre-made assets, ensuring infinite variation and full parameter controllability. The constraint-based arrangement system places objects respecting physical and semantic constraints (a chair must be near a table, plants must not intersect furniture). Infinigen Indoors (CVPR 2024, Raistrick et al.) extended the system to photorealistic indoor scenes with procedural furniture, architecture elements, appliances, and everyday objects. The tool exports directly to NVIDIA Omniverse and Unreal Engine, enabling domain-randomised synthetic dataset generation at industrial scale for training object detection, depth estimation, and semantic segmentation models.

Unreal Engine PCG (Procedural Content Generation)

• Epic Games introduced the PCG Framework in Unreal Engine 5.2 as experimental, moving it to Beta in UE 5.4. The system is a graph-based tool for populating environments procedurally — placing foliage, buildings, rocks, and other assets — at runtime or in-editor, using point clouds, splines, and attribute filtering. PCG operates on spatial data flows: input sources (landscape heightmaps, splines, volumes) generate point clouds; graph operators transform, filter, scatter, and project these points; output sinks spawn actors, meshes, or data assets at resulting positions. The graph supports runtime execution — environments can be procedurally populated at game load time on target hardware rather than baked in the editor, enabling genuinely procedural open-world games where terrain, biomes, and structures emerge from algorithmic rules rather than hand-placement.
• Architecture: PCG graphs execute as asset-evaluated data flow networks. PCG points carry arbitrary typed attributes (float, vector, string, actor reference) enabling rich semantic annotation — a point might carry biome type, slope angle, moisture level, and terrain height as attributes simultaneously, driving compound conditional placement rules (“place conifer trees where slope < 30°, altitude > 500m, moisture > 0.6”). The spline-based input system integrates tightly with UE5’s Geometry Scripting system for runtime mesh generation and deformation.
• UE 5.5 (Unreal Fest 2024): Advanced Topics session demonstrated batch processing improvements and new PCG element types enabling more complex conditional logic and better integration with the World Partition system for streaming open worlds.
• UE 5.7 (2025): PCG promoted to production-ready status with approximately 2× performance improvement over UE 5.5; new PCG editor mode with in-viewport spline drawing, volume creation, and terrain painting tools; Polygon2D data type enabling closed 2D area operations; GPU parameter overrides for runtime instance variation; new Spline Intersection and Split Splines operators; experimental Procedural Vegetation Editor — a new plugin enabling direct in-editor creation and customisation of Nanite-ready tree/foliage meshes with growth simulation (branches, leaves, bark parameterisation) without requiring third-party tools such as SpeedTree or Houdini Labs.
• PCG integrates directly with Nanite (UE5’s virtualised geometry system enabling billions of polygons at interactive frame rates) and Lumen (real-time global illumination via software ray tracing), meaning procedural environments benefit from UE5’s full physically-based rendering stack without additional baking or approximation. PCG graphs can now run standalone (decoupled from actors), enabling headless server-side world generation — relevant for cloud-based procedural world streaming, simulation environments for robotics training, and persistent online game world generation.

EmberGen — Real-Time GPU Volumetric VFX

• JangaFX EmberGen (used in 200+ leading game studios) is a standalone GPU-accelerated real-time volumetric fluid simulator for fire, explosions, smoke, energy, and stylised effects. It executes full simulation and rendering on the GPU, achieving interactive frame rates where equivalent Houdini FLIP/pyro simulations run overnight.
• EmberGen 1.1 (January 2024): Improved geometry collision (smoke flowing through complex pipe geometry); emitter parenting to character bones for integrated character VFX.
• EmberGen 1.2 (July 2024): Movable simulation domains — simulation volumes can be keyframed or parented to objects/characters, enabling mobile explosions and travelling fire; mouse-movement recording for rapid test animation directly in the viewport.
• Output pipeline: EmberGen exports flipbook spritesheets, VDB volumes, and OpenEXR sequences directly compatible with Houdini, Unreal Engine, Unity, and Blender shaders.

Wonder Studio / Autodesk Flow Studio

• Wonder Dynamics was acquired by Autodesk in 2024 and rebranded as Autodesk Flow Studio. The platform is a cloud-based, web-accessible system that uses over 25 AI models to analyse live-action video (body motion, lighting, camera tracking) and automatically replace human actors with CG characters. The system handles matchmoving, motion transfer, lighting integration, and CG compositing — tasks that traditionally required weeks of artist time — in automated pipelines.
• Wonder Animation (launched October 2024): A “video to 3D scene” feature converting edited live-action footage into fully animated CG scenes with characters in 3D environments. Outputs are fully editable in DCC applications and game engines, bridging the generative video → 4D pipeline gap. Wonder Dynamics demonstrated this at Siggraph 2024 and partnered with studios including Boxel Studio which developed custom Python retargeting tools to integrate ML motion data into Maya/Unreal/Cascadeur production rigs.

Cascadeur — AI Physics Animation

• Cascadeur (Nekki) is an AI-powered 3D animation tool with physics-based AutoPhysics that generates physically-plausible secondary motion and trajectory arcs. The 2024.2 release (September 2024) expanded AutoPhysics, intuitive trajectory controls, and deep learning motion instruments. Cascadeur targets games animation — character actions and combat — providing a middle ground between full simulation and manual keyframing.

4D Gaussian Splatting (4DGS) — Neural Dynamic Scene Representations

• 3D Gaussian Splatting (3DGS), introduced at SIGGRAPH 2023, represents scenes as collections of anisotropic 3D Gaussians that can be rasterised in real time via differentiable splatting. Extending this to temporal sequences defines 4DGS:
• 4D Gaussian Splatting for Real-Time Dynamic Scene Rendering (Wu et al., CVPR 2024, arXiv:2310.08528): Uses a hybrid representation combining 3D Gaussians with 4D neural voxels (HexPlane-inspired decomposed encoding). A lightweight MLP predicts Gaussian deformations at novel timestamps. Achieves 82 FPS at 800×800 on an RTX 3090 — demonstrating real-time dynamic scene rendering from monocular video.
• Real-time Photorealistic Dynamic Scene Representation and Rendering with 4D Gaussian Splatting (Fudan ZVG, ICLR 2024): Formulates unbiased 4D Gaussian primitives with 4D Spherindrical Harmonics modelling time evolution of view-dependent colour in dynamic scenes.
• ST-4DGS: Spatial-Temporally Consistent 4D Gaussian Splatting (ACM SIGGRAPH 2024, dl.acm.org/doi/abs/10.1145/3641519.3657520): Focuses on spatial-temporal consistency for efficient dynamic scene rendering, addressing flickering and temporal inconsistency in rapidly-moving regions.
• 4D Gaussian Splatting: Modeling Dynamic Scenes with Native 4D Primitives (arXiv:2412.20720, December 2024): Proposes native 4D Gaussian primitives avoiding the two-stage (3D + deformation) decomposition, instead treating time as a native axis of the primitive.

NeRF + SDF Hybrid Models

• The canonical hybrid paradigm combines implicit distance functions (SDF — Signed Distance Function) with explicit or neural radiance field renderers:
• SuGaR (CVPR 2024): Surface-Aligned Gaussian Splatting for mesh reconstruction. Regularises 3DGS optimisation with SDF-based surface proximity constraints, yielding Gaussians co-located with the mesh surface rather than floating in free space. Enables high-quality mesh extraction from 3DGS.
• GSDF (NeurIPS 2024): Jointly optimises 3D Gaussian Splatting and SDF. The Gaussian branch provides surface proximity and depth maps to refine ray sampling for the SDF branch; the SDF branch provides geometric priors that constrain Gaussian distribution.
• MagicClay (SIGGRAPH Asia 2024): Combines implicit and explicit representations for generative sculpting — preserving mesh properties in stable regions while enabling radical topological change in edited regions via localised implicit field updates.
• 2D Gaussian Splatting for Geometrically Accurate Radiance Fields (SIGGRAPH 2024): Uses 2D surfels (oriented Gaussian discs) rather than volumetric 3D Gaussians, providing superior geometric accuracy for surface normals and SDF alignment.
• Generative video → 4D: Research in 2024-2025 demonstrated that video diffusion models (Sora, Open-Sora) can be repurposed for 4D geometry reconstruction. Sora3R fine-tunes a video diffusion backbone for 4D pointmap regression from monocular video, treating the video latent space as a prior over physical dynamics. The observation that Sora maintains 3D consistency (objects moving coherently through 3D space as camera rotates) underpins this approach — temporal consistency as an emergent property of scale.

NeRF, SDF, and Hybrid Neural Representations

• Neural Radiance Fields (NeRF) (Mildenhall et al. ECCV 2020) represent a scene as a continuous volumetric function f_Θ: (x,y,z,d) → (c,σ) where (x,y,z) is a 3D point, d is a viewing direction unit vector, c = (r,g,b) is view-dependent colour, and σ is volume density. Rendering a ray r(t) = o + td uses numerical integration: C(r) = ∫ T(t) σ(r(t)) c(r(t),d) dt where T(t) = exp(-∫ σ(r(s)) ds) is transmittance. Training minimises the MSE between rendered pixels and ground-truth images from multiple viewpoints. The MLP is typically a 8-layer network with 256 hidden units per layer, positional encoding γ(p) = [sin(2⁰πp), cos(2⁰πp), …, sin(2^{L-1}πp), cos(2^{L-1}πp)] applied to both position and direction to enable high-frequency detail representation.
• NeRF limitations and variants: Original NeRF required 1-2 days of training per scene on a V100, producing 30-60 second renders per frame. instant-ngp (Müller et al. SIGGRAPH 2022) replaced input positional encoding with multi-resolution hash tables — learnable lookup tables at L=16 resolution levels with feature vectors of dimension F=2, reducing training to 30-90 seconds on an RTX 3090. TensoRF (Chen et al. ECCV 2022) factorised the radiance field tensor as a sum of vector-matrix (VM) or canonical polyadic (CP) decompositions, reducing memory and accelerating training. Mip-NeRF 360 (Barron et al. CVPR 2022) addressed unbounded outdoor scenes. Dynamic NeRFs: D-NeRF (Pumarola et al. 2021) adds a deformation field network Ψ_Θ: (x,t) → Δx mapping each point’s canonical location to its deformed position at time t; HyperNeRF (Park et al. 2021) uses higher-dimensional ambient slicing for topological deformation.
• Signed Distance Functions (SDFs) represent surface geometry implicitly as f: ℝ³ → ℝ where f(x) < 0 inside the surface, f(x) = 0 on the surface, and f(x) > 0 outside, with |∇f| = 1 (Eikonal equation) for true distance fields. SDFs admit analytic operations (union min(f₁,f₂), intersection max(f₁,f₂), difference max(f₁,-f₂), smooth blending) and naturally handle topology change. Neural SDFs: DeepSDF (Park et al. CVPR 2019) learned a continuous SDF from point cloud inputs; NeuS (Wang et al. NeurIPS 2021) rendered neural SDFs via volume rendering with unbiased, occlusion-aware weights; VolSDF (Yariv et al. NeurIPS 2021) converted SDF to density using Laplace CDF. Procedural SDFs (Inigo Quilez’s library, extensively used in Houdini VEX and GLSL shaders) compose primitive SDFs analytically — sphere, box, torus, capsule, rounded cone — with blending operations to create complex organic and mechanical shapes entirely mathematically.
• GSDF Hybrid (NeurIPS 2024) jointly optimises 3DGS and an SDF in a coupled training procedure: the Gaussian branch provides per-pixel surface proximity estimates used to constrain the SDF’s zero-crossing location; the SDF branch provides geometric regularisation preventing the Gaussians from distributing arbitrarily in free space. This bidirectional coupling produces superior results to either representation alone — the Gaussians provide view-dependent appearance richness while the SDF provides geometric precision. SuGaR (CVPR 2024) enforces Gaussian-SDF alignment as an explicit regularisation term, enabling high-quality mesh extraction from the trained 3DGS model for downstream use in game engines or 3D printing pipelines.
• MagicClay (SIGGRAPH Asia 2024) combines implicit and explicit representations for interactive generative sculpting: the user designates sculpting regions where an implicit field (neural or analytical SDF) handles topological operations (adding/removing handles, punching holes) while surrounding stable regions are represented as explicit mesh to preserve existing geometry. Score Distillation Sampling (SDS) from a text-conditioned diffusion model guides the sculpted region toward semantically consistent geometry. This demonstrated higher geometric quality than pure implicit representations whilst maintaining the editability of mesh workflows — a practical bridge between AI-generative and artist-controlled 3D creation.

OpenUSD — Interoperability Layer

• Universal Scene Description (USD), developed by Pixar and open-sourced as OpenUSD, is the de facto interoperability format for procedural and hybrid 4D pipelines. USD provides hierarchical scene composition, non-destructive override layers, procedural schema primitives, and rendering-delegate abstraction (Hydra). The AOUSD Alliance (Apple, Adobe, Autodesk, NVIDIA, Pixar) governs the standard. Houdini Solaris, Unreal Engine, Omniverse, Maya, Katana, and Blender all read/write USD, enabling pipeline-wide procedural scene graphs where Houdini generates geometry and simulation data, exports to USD layers, and downstream tools consume the composed scene for look-development, lighting, and rendering.
• USD Core Concepts: A USD Stage is a composed view of a hierarchy of prims (primitive objects) built from one or more layers (files). Composition operators — References (include a prim from another layer), Payloads (loadable references for streaming), Inherits (class-based property inheritance), Specialises (stronger-than-inherit override), VariantSets (named alternatives), Over (anonymous non-definition override) — define how layers combine into the final scene hierarchy. This composition arc system enables the non-destructive, multi-discipline workflows central to procedural pipelines: a Houdini layout artist defines base geometry in a layer; a Katana lookdev artist adds material bindings in an override layer; a lighting artist adds light opinions in a shot layer; all layers compose into the final lit scene.
• Hydra Rendering Framework: USD’s Hydra imaging framework decouples scene description from rendering by defining a scene delegate interface (consuming USD scene data) and a render delegate interface (producing rendered images). Renderers (Karma, Arnold, V-Ray, RenderMan, Cycles, Storm) implement the render delegate interface, enabling applications to switch renderers without changing the scene description. This is directly analogous to the Vulkan/Metal abstraction layer for GPU APIs — the same scene is portable across rendering technologies. The Hydra GL (Storm) renderer provides OpenGL viewport display in Houdini, Katana, and usdview; production renderers (Karma XPU, Arnold) provide final-quality path tracing through the same interface.
• MaterialX integration: MaterialX (ILM open-source standard) provides a portable material and shading description language independent of renderer and DCC application. USD’s MaterialX binding schema allows materials authored in any tool to be consumed by any renderer supporting MaterialX — completing the full portability stack for procedural pipelines: geometry in USD, materials in MaterialX, rendering via Hydra delegate.

Use Cases / Major Families

• Feature Film VFX — Procedural Shot Scaling: The central economic motivation for procedural pipelines in film is shot scaling: a single Houdini network parameterised over shot-specific inputs (camera angle, time of day, hero character position) can generate thousands of environment variants for a film’s worth of visual content that would be impossible to produce by hand. Framestore (London) on Project Hail Mary (2024) migrated the full lighting pipeline to Houdini Solaris mid-production, enabling CG supervisors to drive lighting across hundreds of shots from a single parameterised LOP network rather than hand-lighting individual shots. DNEG’s full migration of The Last of Us lighting from Clarisse to Houdini Solaris between production seasons illustrates the industry-wide convergence on Houdini/USD as the procedural production standard. Procedural destruction (Houdini Voronoi fracture, constraint networks, RBD solvers) generates building collapses, vehicle crashes, and terrain deformation. Procedural crowds (Houdini Crowd, Massive, Golaem) populate battle scenes and urban environments with agent-based autonomous movement. Procedural vegetation (SpeedTree, Houdini Labs tree generator) fills forests with botanically varied flora.
• Virtual Production on LED Volumes: Unreal Engine PCG populates LED volume backgrounds with procedural environments rendered in real time at 24+ FPS on 16K LED walls. The procedural world must be generated and rendered within the same frame budget as the live action capture — typically 16-33ms per frame — requiring GPU-accelerated PCG evaluation, Nanite virtualised geometry for polygon budget management, and Lumen real-time GI for physically-consistent illumination matching the on-set lighting. Procedural variations (time of day, season, weather) can be dialled in remotely by the director without location scout or re-shoot costs. Studios including ILM’s StageCraft (The Mandalorian) and multiple UK facilities (Real VFX, Arora Studios) operate LED volumes using UE5 PCG procedural environments.
• Games — Real-Time Procedural VFX and Open Worlds: EmberGen GPU simulations generate VFX flipbook spritesheets (256×256 to 1024×1024, 32-64 frames) and VDB caches for Unreal Engine and Unity shaders, enabling feature-film-quality explosion and fire effects on console hardware without real-time simulation cost. JangaFX reports EmberGen adoption in 200+ major game studios for this pipeline. Cascadeur AutoPhysics animates characters with physically-plausible secondary motion (cloth, hair, muscle deformation) procedurally from animator-driven primary poses, used in games production for AAA titles where manual secondary animation would be prohibitively expensive. Unreal PCG populates open-world maps — forests, biome transitions, rock fields, urban debris — using spatial attribute queries against heightmaps, distance fields, and gameplay zone volumes, scaling to game worlds covering thousands of square kilometres (e.g., Star Wars Outlaws, Stalker 2 production use open-world procedural population tools of this category).
• Synthetic Data Generation for Computer Vision: Procedural generation is the dominant paradigm for scalable synthetic training data, enabling dataset creation that is impossible through real-world capture at equivalent scale and diversity. Infinigen Indoors (CVPR 2024) generates photorealistic procedural indoor scenes with ground-truth depth, surface normal, semantic segmentation, and optical flow annotations — all computable analytically from the procedural scene graph without human labelling. Domain randomisation — randomly varying textures, lighting, object arrangements, camera poses — across millions of procedurally generated variants produces training distributions that cover the tail risks (rare lighting conditions, uncommon object combinations) inadequately represented in real-world datasets. Tesla, Waymo, and UK AV startups (Wayve, FiveAI/Bosch) use procedural synthetic data pipelines to augment real-world training data for perception model training.
• Dynamic Scene Reconstruction (4DGS): 4DGS methods reconstruct dynamic performers — dancers, athletes, actors — from multi-camera capture rigs (typically 40-100 synchronised cameras at 60-120fps) for free-viewpoint video, sports broadcast AR replay, and volumetric telepresence. ST-4DGS (SIGGRAPH 2024) focuses specifically on spatial-temporal consistency for this use case, addressing the flickering and temporal incoherence that naive per-frame 3DGS produces on fast-moving limbs. Applications include: NFL/Premier League AR replay where broadcasters reconstruct plays in 3D from existing broadcast cameras; volumetric stage performances (ABBA Voyage-style, but reconstructed rather than pre-scanned); and medical procedure recording for surgical training where free-viewpoint replay enables trainees to view operations from any angle.
• Volumetric Telepresence and XR: 4DGS and hybrid NeRF representations enable real-time streaming of dynamic human subjects (presenters, colleagues, performers) in XR contexts at quality levels approaching video call fidelity but with genuine 3D presence. A speaker reconstructed in 4DGS can be placed in a shared virtual environment visible from multiple viewpoints simultaneously to remote participants — connecting to Spatial Computing Paradigm and AR Frame workflows. Compression research (4DGS variants using motion prediction between keyframes) is reducing bitrate requirements toward streaming-feasible levels (target: <10 Mbps for high-quality dynamic human), anticipating the metaverse presence use case of the late 2020s.
• Generative World Building — AI Hybrid Pipelines: The emerging paradigm couples text-conditional diffusion models (generating photorealistic initial guidance images) with procedural 3D generation (SDF-based meshing, PCG population, physics validation) to produce complete 3D world content from textual descriptions. NVIDIA Edify 3D generates 3D assets from text prompts using a 3DGS representation; Adobe Firefly 3D extends the Firefly image generation system to 3D object creation; Meshy, Tripo3D, and similar services generate 3D meshes from text or image prompts within seconds. The deeper integration — where a language model generates a complete PCG graph specification from a textual world description — represents the next frontier, with early research prototypes demonstrated at SIGGRAPH 2024 workshops.

Infinigen: Procedural Scene Generation for Computer Vision

• Infinigen’s architecture is specifically optimised for computer vision training data generation — it prioritises annotation quality, scene diversity, and export fidelity over production pipeline integration:
• Procedural object generators (Infinigen core): every object in Infinigen is a Python-callable procedural generator with a random seed parameter. The library covers:
  • Plants: trees (branch fractal generation), bushes, flowers, grass patches, underwater sea coral, kelp, mushrooms
  • Terrain: mountain ranges (domain-warped Perlin heightmaps), river systems (flow simulation on terrain), cave systems (procedural erosion), desert dunes (aeolian transport simulation)
  • Atmospheric effects: procedural cloud volumes (Perlin-based density fields), rainfall particles, snowfall systems
  • Animals: fish, birds, insects (procedural body mesh from skeleton templates with random morphological variation)
  • Indoor objects (Infinigen Indoors, CVPR 2024): chairs, tables, sofas, beds, shelving, kitchen appliances, lamps — all procedurally generated with material variation
• Annotation pipeline: because every scene element is procedurally defined, ground-truth annotations are computed analytically rather than labelled manually:
  • Depth maps: Z-buffer from camera space (exact, no approximation)
  • Surface normals: analytical from geometry normals (exact)
  • Semantic segmentation: object ID tracked through scene graph (exact per-pixel class)
  • Instance segmentation: per-instance ID (exact)
  • Optical flow: velocity-field based (exact temporal correspondence)
  • 3D bounding boxes: computed from geometry AABB (exact)
• Dataset scale: a single Infinigen run with 100 GPU hours can generate 50,000+ diverse scene images with all annotation types — equivalent to months of manual annotation effort for a real-world dataset. Published Infinigen datasets are used for training AV perception models, indoor robot navigation, and embodied AI research.
• Export targets: Infinigen scenes export to NVIDIA Omniverse (USD), Unreal Engine (USD/FBX), and Blender render (direct). This enables downstream domain randomisation — taking the same procedural scene and varying lighting, sky, and material parameters to produce thousands of annotated variants from a single scene layout.

Blender Geometry Nodes: Node Types and Use Cases

• Blender Geometry Nodes exposes a rich library of typed nodes organised by data domain and operation type. Understanding the node taxonomy is essential for procedural Blender workflows:
• Input Nodes — provide data from the scene and object context:
  • Position, Normal, Index, ID: fundamental per-element geometric data
  • Named Attribute: read arbitrary attribute by name (enables parameter-driven attribute access)
  • Active Camera, Scene Time, Is Viewport: context-aware inputs for animation-driven and viewport-conditional logic
  • Object Info, Collection Info: reference external objects/collections for instancing
• Geometry Nodes — create and modify geometric data:
  • Mesh Primitive nodes (Cube, UV Sphere, Cylinder, Cone, Grid, ICO Sphere, Circle, Line, Points): procedural primitive creation without input mesh dependency
  • Mesh Boolean: CSG (Constructive Solid Geometry) union/difference/intersect between meshes (differentiable geometry composition)
  • Extrude Mesh, Inset Faces, Subdivide Mesh, Triangulate, Dual Mesh: topology modification operations
  • Merge by Distance: weld near-coincident vertices (procedural equivalent of Remove Doubles)
  • Convex Hull, Delaunay Triangulation, Fill Curve: computational geometry operations
• Point Nodes — manipulate point clouds:
  • Distribute Points on Faces: scatter points over mesh surface by density attribute — the primary environment population tool (trees, rocks, grass, buildings)
  • Distribute Points in Volume: volumetric scatter for particle initialisation
  • Points to Vertices, Points to Volume: domain conversion for downstream processing
• Instancing Nodes — place instances efficiently:
  • Instance on Points: places geometry/collection instances at each point, using point attributes for rotation, scale, and instance index selection. The core tool for procedural environment population.
  • Realize Instances: materialise instances into actual geometry for boolean or attribute operations
  • Rotate Instances, Scale Instances, Translate Instances: transform instance attributes
• Curve Nodes — procedural spline operations:
  • Curve Primitive nodes: Bezier, NURBS, polyline, spiral, arc, star curve generators
  • Resample Curve, Subdivide Curve, Smooth Curve: curve refinement
  • Curve to Mesh, Curve to Points: domain conversion for tube generation (ropes, vines, roads along splines)
  • Fill Curve: polygon fill of closed curves for road/river footprint generation
• Simulation Zone (Blender 4.0+): persistent state simulation within Geometry Nodes:
  • Input/output socket pair defines the simulation frame boundary
  • State persists between frames, enabling cloth, fluid, agent, and growth simulation within the node graph
  • Bake-per-zone enables individual simulation baking without full graph re-evaluation
  • Critical for procedural growth animations (L-system simulation, coral growth, crystal formation) where state must accumulate over time

Unreal Engine PCG: Graph Architecture and Operator Library

• The Unreal Engine Procedural Content Generation (PCG) framework exposes a composable graph of typed operators transforming spatial data between PCG point clouds, splines, volumes, and landscapes:
• Input Nodes — data acquisition from the UE world:
  • Landscape Sampler: samples landscape heightmap at configurable grid resolution, generating a PCG point cloud with position, normal, slope, and curvature attributes
  • Get Spline Data: converts UE spline components to PCG spline primitives (paths for roads, rivers, fences)
  • Volume Sampler: fills a volume actor with PCG points (building interiors, forest volumes)
  • Actor Selector: queries actors in the world by tag/class, providing reference data for placement rules
• Spatial Operators — transform and filter point distributions:
  • Point Filter: boolean filter on attribute expressions (e.g., keep points where Slope < 30° and Altitude > 200m)
  • Density Filter: probabilistic filter using density attribute for controlled randomisation
  • Point Transform: apply matrix transform to all points (scale, rotate, translate entire distribution)
  • Project Points: project points onto landscape/mesh surfaces (ensures instances follow terrain contour)
  • Spline Sampler: sample points along a spline at configurable interval/density
  • Bounds Modifier: expand/shrink point bounding boxes for collision checking
• Scatter Operators — point distribution:
  • Point Scatter: Poisson disc or uniform random scatter within input bounds
  • Polygon2D Operations (UE 5.7+): create/intersect/split polygonal areas for biome boundary definition
  • Surface Sampler: weighted scatter by surface normal and attribute maps
• Output Nodes — materialise PCG data into UE actors and assets:
  • Static Mesh Spawner: instantiate static mesh assets at PCG point positions, using point attributes (Rotation, Scale, Selection) to drive mesh selection from an asset pool
  • Spawn Actor: spawn arbitrary UE Actors (Blueprint, Landscape Grass, NPC spawners) at PCG points
  • Data Table Row Selector: drive asset selection from data table rows using point string attributes
• Runtime vs Editor PCG: PCG graphs can execute in-editor (baked to instances, faster at runtime) or at runtime (regenerates on demand, supports streaming). Runtime PCG is used for procedural dungeons, infinite terrain streaming, and online games with server-side world generation.
• PCG Graph as Pipeline Asset: PCG graphs are UE assets referenceable across levels, inheritable (child graphs override parent parameters), and composable (sub-graphs embedded as nodes). This enables a modular library of procedural rules (BiomePCG, UrbanPCG, RuinsPCG) composited for specific level requirements — the same architectural pattern as Houdini’s HDA library.

Houdini VEX and Python: Procedural Scripting Layers

• Beyond node-graph visual programming, Houdini exposes two scripting layers that give procedural artists full computational expressiveness:
• VEX (Vector Expression): a C-like compiled language designed for GPU-acceleratable parallel computation over geometry attributes. VEX wrangle nodes execute user-written code in parallel across every point, vertex, primitive, or detail in the geometry. VEX operations on a million-point cloud run at GPU speeds — typical attribute manipulation (noise evaluation, vector math, conditional branching) executes in <10ms on modern hardware.
  • VEX data model: attributes accessed via @name syntax; intrinsic globals: @P (position), @N (normal), @v (velocity), @pscale (point scale), @Cd (colour), @id, @name, @group_*. Custom attributes of any type (float, vector, matrix, string, integer) created on-the-fly: @myattr = 1.0.
  • VEX noise functions: noise(), snoise(), vnoise(), wnoise() (Worley), xnoise() (simplex), curlnoise(), flownoise() (Perlin flow noise) all GPU-accelerated and seedable. Octave summing via loops: for(int i=0; i<8; i++) { result += pow(0.5, i) * noise(pos * pow(2,i)); }
  • VEX procedural geometry: Houdini’s Add SOP + VEX can construct arbitrary geometry from scratch (no input mesh required): addpoint(), addprim(), addvertex() in VEX create point, primitive, and vertex arrays dynamically — enabling fully algorithmic geometry generation (Sierpinski tetrahedra, Lindenmayer turtle, Penrose tiling, molecular space-filling models).
  • VEX in DOPs: Houdini Pyro and FLIP DOPs expose VEX microsolvers — custom simulation step operations — enabling artists to add custom force fields, custom density sources, and custom velocity modifications to fluid simulations without C++ plugin development.
• Python in Houdini: SideFX exposes a comprehensive Python API (HOM — Houdini Object Model) enabling full pipeline automation, node network construction, parameter modification, and render submission from Python scripts.
  • Network proceduralism: Python scripts can build entire Houdini networks programmatically — hou.node('/obj').createNode('geo'), geo.createNode('popnet') — enabling rule-driven DCC automation where scene setup, shot variant generation, and render submission are fully automated from pipeline databases (shot management systems, asset management tools).
  • Pipeline integration: Python connects Houdini to USD (pxr Python bindings), Perforce/Git version control, Shotgun/ftrack production tracking, AWS/GCP render farm APIs, and studio custom pipeline tools. DNEG and Framestore operate fully Python-automated Houdini pipelines where artists rarely interact with Houdini directly — Python drives scene setup from shot data, artists adjust parameters, Python submits to Deadline/Conductor render farms.
  • Houdini Engine: exposes Houdini node networks as parametric “HDAs” (Houdini Digital Assets) to host applications — Unreal Engine, Maya, Unity, Cinema 4D — via the Houdini Engine API. A Houdini network becomes a plugin in another DCC, enabling Houdini proceduralism without requiring a Houdini licence in the consuming application. Widely used for Unreal game development: terrain generators, building populators, destruction setup tools.

Neural Rendering Pipeline: From NeRF to 3DGS in Production

• The transition from NeRF to 3DGS in practical production use illustrates how research representations evolve toward deployment. Each step addresses the previous method’s principal limitation:
• NeRF (2020): photorealistic reconstruction from posed images. Limitation: 1-2 days training; 30-60 seconds per rendered frame. Use: research, offline novel view synthesis.
• instant-ngp (2022): multi-resolution hash encoding reduces training to 30-90 seconds. Limitation: still implicit; must re-render for each new viewpoint at ~1-5 FPS. Use: faster iteration, NeRF prototyping.
• 3DGS (SIGGRAPH 2023): explicit Gaussian rasterisation achieves 30-120 FPS real-time rendering. Training 30-45 minutes from 100-300 images. Limitation: static scenes only; limited surface reconstruction quality.
• SuGaR (CVPR 2024): SDF-regularised 3DGS enables high-quality mesh extraction. Limitation: requires careful regularisation weight tuning; mesh quality still below manual modelling.
• GSDF (NeurIPS 2024): jointly optimised Gaussian + SDF provides geometric accuracy with appearance richness. Limitation: double optimisation complexity; ~2× training time vs vanilla 3DGS.
• 4DGS (CVPR 2024): HexPlane-extended 3DGS enables real-time dynamic scene reconstruction. Training ~1h from video; 82 FPS rendering. Limitation: deformation field approximation breaks down for large non-rigid deformations.
• 4DGS Native Primitives (Dec 2024): true 4D Gaussians avoid deformation approximation. Limitation: increased computational complexity; longer training time; less tool support.
• Generative 3DGS (2024-2025): text/image → 3DGS via Score Distillation Sampling (DreamFusion, GaussianDreamer, LucidDreamer). Limitation: quality inconsistent; view-inconsistent hallucinations; slow convergence. Use: concept art exploration, asset pre-visualisation.
• Production deployment status (2026):
  • Static 3DGS: widely used in games (capture of hero props/environments), real estate visualisation, cultural heritage documentation
  • 4DGS: deployment in broadcast (sports AR), pilot in XR telepresence; not yet standard DCC workflow
  • Generative 3DGS: early adoption in creative industries for concept exploration; quality gap vs manual modelling remains significant
  • NeRF: largely superseded by 3DGS for new use cases but legacy deployments continue in autonomous vehicle HD map capture (Waymo, Cruise NeRF mapping pipelines)

UK Procedural VFX Ecosystem: Studios and Research Groups

• The UK procedural and hybrid 4D ecosystem spans world-class post-production studios, specialist software vendors, academic research groups, and games studios:
• London Post-Production Hub (Soho / King’s Cross):
  • Framestore: 35-year-old studio; Paddington Bear visual creature development; Project Hail Mary lighting pipeline migration to Houdini Solaris 2024; Gravity (2013) space environment pioneer; multi-Oscar winner.
  • DNEG: 5,000+ global artists; The Last of Us lighting pipeline migration Clarisse→Houdini Solaris; Dune Part Two procedural sand storm simulation; dual London HQ and global facilities (Mumbai, Los Angeles, Montreal).
  • Cinesite: specialist in creature and character VFX; procedural rigging pipelines for complex creature work; Paddington films, Avengers series work.
  • Milk VFX: BAFTA-nominated boutique; Doctor Who, His Dark Materials; Houdini procedural environment and simulation work.
  • Outpost VFX: Bournemouth-based; The Crown, Emily in Paris; specialist in photoreal environments and procedural digital matte paintings.
• Software Vendors:
  • The Foundry (King’s Cross, London): Katana (look-development, used by ILM/DNEG/Weta/Framestore), Nuke (compositing, world market leader), Mari (3D texture painting), Modo (sub-division modelling). 400+ employees, 25-year heritage. USD-integrated across entire product line.
  • SideFX: Toronto-based but UK office; Houdini developer. UK VFX industry adoption effectively total for FX/simulation work.
  • JangaFX: Montreal-based; EmberGen and LiquiGen (real-time liquid simulation) widely adopted in UK games (Playground Games, Rebellion, Rare).
• Academic Research (Procedural and Neural Graphics):
  • UCL VECG (Virtual Environments and Computer Graphics Group): professor Anthony Steed leads XR research; affiliated groups work on deformable surfaces, physics-based animation, neural rendering.
  • Imperial Visual Computing: Stefanos Zafeiriou group (face reconstruction, dynamic 3D); related research on neural implicit surfaces and 3D generative models.
  • University of Edinburgh Informatics: neural rendering and implicit representation research; School of Informatics computer graphics contributions.
  • Oxford VGG (Visual Geometry Group): Andrew Zisserman group; foundational contributions to structure from motion, dense reconstruction — mathematical underpinning of NeRF camera estimation pipelines.
  • Cambridge DAMTP: computational fluid dynamics numerical methods (PDE solvers) directly relevant to Houdini’s simulation backends.
• Games Studios (Northern England and Nationwide):
  • Playground Games (Leamington Spa): Forza Horizon series; UE5 PCG for procedural open-world environment population; major Houdini games workflow adopter.
  • Frontier Developments (Cambridge): Planet Coaster, Jurassic World Evolution; procedural building construction systems; Houdini-derived procedural content pipelines.
  • Rare (Twycross, Midlands): Sea of Thieves; EmberGen-based VFX for ocean storms and fire; UE PCG for island environment population.
  • Creative Assembly (Horsham, West Sussex): Total War series; procedural terrain generation and large-scale battle environment tooling.
  • Sumo Group (Sheffield): multiple studios; specialist in UE5 procedural environment workflows for licensed game production.

EmberGen and Real-Time GPU Simulation Architecture

• JangaFX EmberGen represents a distinct architectural choice from Houdini’s CPU-dominated simulation pipeline — a GPU-native real-time simulation designed for artist iteration speed over physical accuracy.
• Simulation architecture: EmberGen discretises the simulation domain as a 3D voxel grid on the GPU (CUDA/Vulkan compute shaders). Each voxel stores velocity, pressure, temperature, density, and fuel as float32 buffers in GPU memory. The simulation runs as a pipeline of GPU compute shader passes: velocity advection → divergence computation → pressure solve (Jacobi/conjugate gradient) → velocity projection → density/temperature advection → rendering. All operations execute in GPU thread blocks, achieving interactive frame rates (30-120 FPS simulation + rendering simultaneously on RTX 4090).
• Output pipeline for games: EmberGen exports:
  • Flipbook spritesheets: 2D grids of simulation frames (e.g., 8×8 grid of 512×512 frames = 4096×4096 PNG) used as texture atlases in particle shader systems. Standard in Unreal/Unity/Godot particle material shaders for fire, smoke, explosion effects.
  • VDB sequences: OpenVDB volumetric files for offline rendering in Houdini/Blender/Arnold, providing full volumetric lighting of the simulation results.
  • Normal maps and flow maps: EmberGen 1.2+ exports normal-mapped flipbooks enabling parallax/depth shading of volumetric effects in real-time game shaders, significantly improving visual quality of 2D flipbook approximations.
• EmberGen 1.1 (January 2024): geometry collision improvements — simulation correctly flows through complex pipe/tunnel geometry rather than treating it as a simple bounding box; emitter parenting to character bones for dynamic character-coupled VFX (fire breathing, character-integrated smoke trails).
• EmberGen 1.2 (July 2024): movable simulation domains — the entire voxel grid can be keyframed or parented to a scene object, enabling a travelling fireball or helicopter rotor wash that moves through the scene; mouse-movement recording for rapid test animation without setting keyframes.
• Integration with Cascadeur: Artists use Cascadeur to establish character physics animation (AutoPhysics secondary motion), then import the character animation into EmberGen as a collision/emitter source for character-coupled VFX, then composite the results in Nuke — a cross-tool procedural pipeline for character-integrated VFX.

Wonder Studio / Autodesk Flow Studio: AI-Procedural Hybrid for Character VFX

• Wonder Dynamics (acquired by Autodesk 2024, rebranded Autodesk Flow Studio) operates a fundamentally different paradigm from traditional VFX: AI models replace manually authored procedural networks for specific high-cost operations (matchmoving, motion tracking, character replacement, lighting integration).
• Technical architecture: Wonder Studio operates 25+ AI models in a cloud pipeline:
  • Body detection and tracking: human detection network identifies actors frame-by-frame across cuts; optical flow models track body keypoints (OpenPose derivative) at 50+ body joint positions.
  • Camera estimation: learned camera estimation from monocular video, producing camera pose sequences without markers or calibration targets — replacing manual COLMAP/SfM camera tracking.
  • Depth estimation: per-frame depth maps (Depth Anything V2 or equivalent) enable 2D-to-3D lift of motion tracking for correct character placement in 3D space relative to the live-action environment.
  • Character replacement: actor keypoint tracks are retargeted to the CG character rig via learned motion retargeting; the CG character is rendered with matched lighting; composited into the live footage with AI-estimated matte extraction.
  • Lighting estimation: an illumination estimation model predicts scene lighting (dominant light direction, intensity, colour temperature, HDRI approximation) from the live footage, used to drive the CG character’s material response without manual HDRI capture.
• Wonder Animation (October 2024): extends single-character replacement to full scene conversion. Input: edited live-action sequence. Output: full CG animated scene with characters, 3D environment reconstruction, and camera track — exportable to Maya, Blender, Unreal for further production work. This is a video→4D scene pipeline using AI rather than explicit procedural rules.
• Autodesk integration trajectory: Wonder Dynamics’ AI models are being integrated into Autodesk’s wider DCC ecosystem (Maya, 3ds Max, MotionBuilder) as AI-assisted tools following the acquisition pattern of Autodesk Flow (production management), Autodesk Tandem (digital twin), and Autodesk Forma (architecture AI).

Academic Context

• Procedural generation has deep academic roots in formal language theory and computational geometry. Lindenmayer Systems (L-systems) (Prusinkiewicz & Lindenmayer 1990) formalise botanical growth as context-free grammars producing string-encoded geometry interpreted via turtle graphics (forward F, rotate +/-, branch push/pop []). D0L-systems (deterministic, context-free) generate fractal-like plants; stochastic L-systems (sL-systems) incorporate probabilistic rule selection for biological variety; context-sensitive L-systems (1L, 2L) model resource communication between plant modules for environmentally-responsive growth. Extended L-systems with parametric modules (pL-systems, Prusinkiewicz et al. 1993) enable quantitative parameter passing between modules, modelling phototropism, gravitropism, and competitive resource allocation. L-systems underpin all procedural vegetation tools including SpeedTree, Houdini Labs Forest, and Blender’s Sapling Tree generator.
• Perlin Noise (Perlin 1985 Academy Award for Technical Achievement 2002) introduced gradient noise by assigning random gradient vectors to integer lattice points and interpolating: noise(x) = ∑ₖ grad(k) · (x-k) × w(x-k) where grad(k) is a pseudo-random unit vector at lattice point k and w is a smooth fade function (6t⁵-15t⁴+10t³). Fractional Brownian motion (fBm) sums octaves: fBm(x) = ∑ₙ amplitude^n × noise(frequency^n × x), with amplitude (persistence) ∈ (0,1) and frequency (lacunarity) > 1 controlling roughness. Simplex noise (Perlin 2001) replaced the cubic gradient lattice with simplex (triangular/tetrahedral) tessellation, reducing computational complexity from O(2^N) to O(N²) in N dimensions and eliminating directional artefacts. Worley (cellular) noise (Worley 1996) computes distance to the nearest random feature point in each cell, producing voronoi-based patterns for rock, skin, and biological texture.
• Wave Function Collapse (WFC) (Gumin 2016) applies constraint propagation from model synthesis to tile-based procedural content generation. WFC observes an input example to extract allowed adjacency rules between tiles, then generates arbitrarily large outputs consistent with those rules via iterative collapse (selecting lowest-entropy cells first) and constraint propagation (eliminating incompatible tiles in neighbouring cells). WFC generalisations — overlapping WFC for pixel-level texture synthesis, 3D WFC for volumetric structure generation, semantic WFC incorporating high-level layout constraints — are used in games (Caves of Qud, Townscaper) and architectural design tools.
• The physics simulation substrate draws from fluid mechanics and continuum mechanics: FLIP (Fluid Implicit Particle) solvers (Brackbill & Ruppel 1986; Zhu & Bridson 2005) underpin Houdini’s flagship fluid simulation, combining grid-based pressure solve with particle-based advection for detailed, turbulent fluid at low numerical diffusion. SPH (Smoothed Particle Hydrodynamics) (Gingold & Monaghan 1977, Lucy 1977) provides a Lagrangian particle-based formulation where density ρ(r) = ∑ⱼ mⱼ W(|r-rⱼ|, h) and pressure forces are computed from kernel-weighted particle summations — more straightforward to implement than FLIP but prone to particle clumping and acoustic noise. MPM (Material Point Method) (Sulsky et al. 1994; Stomakhin et al. SIGGRAPH 2013; Hu et al. 2019) generalises particle simulation to solid-fluid mixtures using a hybrid Lagrangian-Eulerian formulation: material points carry deformation gradient F and constitute variables; background grid handles force computation and velocity update via standard FEM; G2P/P2G transfers exchange information. MPM handles material phase transitions (liquid→gas, solid→fracture) and large deformation without mesh tangling, making it ideal for snow (Disney Frozen, Stomakhin et al. 2013), sand, cloth, and the new Houdini 20.5 MPM solver.
• Position-Based Dynamics (PBD) (Müller et al. 2007) and its extension XPBD (Macklin et al. 2016) provide a constraint-based simulation framework for cloth, soft bodies, and ropes that is numerically unconditionally stable at any timestep and solver-friendly for GPU parallelisation. Houdini Vellum is a production implementation of XPBD. The key insight is iterative constraint projection: for each constraint C(x) = 0, update x ← x + Δx where Δx = -λ∇C/‖∇C‖² minimising constraint violation — simpler than implicit integration of forces but approximating physical accuracy through iteration count.
• On the neural representation side, the field evolved rapidly: NeRF (Mildenhall et al. ECCV 2020) introduced implicit coordinate networks f_Θ: (x,y,z,θ,φ) → (RGB, σ) trained by volume rendering loss; D-NeRF (Pumarola et al. 2021) added temporal deformation fields Ψ_Θ: (x,t) → Δx enabling dynamic scene NeRF; instant-ngp (Müller et al. SIGGRAPH 2022) replaced MLP features with multi-resolution hash tables reducing training from 24h to 30s; TensoRF (Chen et al. ECCV 2022) factorised radiance field tensors as CP/VM decompositions; 3DGS (Kerbl et al. SIGGRAPH 2023) replaced continuous field queries with explicit anisotropic Gaussian rasterisation; and the 4DGS family (Wu et al. CVPR 2024; Yang et al. ICLR 2024; ST-4DGS SIGGRAPH 2024; Ye et al. arXiv Dec 2024) extended Gaussian representations to the temporal axis.
• Key academic venues: ACM SIGGRAPH / SIGGRAPH Asia (premiere venue for graphics, rendering, simulation, and procedural generation — ACM TOG publication); CVPR, ICCV, ECCV, NeurIPS, ICLR (neural representations, differentiable rendering); EuroGraphics (European graphics research); I3D (Interactive 3D Graphics and Games — real-time rendering); SGP (Symposium on Geometry Processing — mesh processing and implicit surfaces). UK institutions regularly publish at all these venues: UCL VECG, Imperial Visual Computing, Edinburgh Informatics, Oxford VGG (Visual Geometry Group), Cambridge DAMTP computational graphics.

Current Landscape (2026)

• As of May 2026, the procedural and hybrid 4D landscape is characterised by five convergent structural trends reshaping every layer of the creative tools stack:
• Procedural tools gaining AI sub-systems as first-class operators: Houdini 21’s ML Nodes represent the most concrete instantiation of this trend — full ML pipeline execution (dataset generation from procedural scenes, model training, inference) as native Houdini operators in the SOP/DOP/LOP networks. This means procedural scene generation and neural learning are now deeply integrated within a single authoring environment. Unity Muse provides AI-assisted asset generation and animation retargeting within the Unity Editor. Unreal Engine 5.7’s experimental AI PCG graph generation (first demonstrations at GDC 2026) allows natural language to drive PCG node graph construction. The common thread: AI is treated as a procedural operator rather than a replacement for procedural authoring — an AI node takes inputs (text prompt, reference image, training data) and produces outputs (geometry, material, animation) that feed into conventional procedural networks.
• Neural representations reaching production deployment beyond research: 4DGS and its variants have transitioned from research prototypes (2023) to production tools (2025-2026) across three sectors: (1) Broadcast sports (NFL, Premier League, F1) deploying multi-camera 4DGS reconstruction for free-viewpoint AR replay, reducing per-event capture rig cost by 40-60% compared to traditional volumetric video systems; (2) Games (character mocap workflows where 4DGS captures performer motion directly from multi-camera setups without marker-based suit requirements); (3) XR (Meta, Apple Vision Pro, and enterprise telepresence platforms evaluating 4DGS as streaming format for photorealistic dynamic avatars). The 80+ FPS rendering performance on RTX 4080-class hardware is the enabling threshold for real-time applications.
• Generative video models as implicit 4D world priors: Sora (OpenAI, 2024), Kling (Kuaishou, 2024), Runway Gen-3 Alpha, and Luma Dream Machine demonstrate that billion-parameter video diffusion models trained on internet video develop implicit 3D-consistent world models — camera rotation produces coherent object-background parallax, objects maintain physical continuity through occlusion, lighting changes follow photometric consistency. Research pipelines including Sora3R (2025) demonstrate that these video latent spaces can be explicitly decoded into 4D geometry representations (dynamic Gaussian fields, 4D pointmaps) via fine-tuned spatial prediction heads — lifting video-generation quality from 2D perceptual fidelity to 3D geometric accuracy. This pipeline will likely enter DCC tooling (Houdini, Blender) as a “video-to-3D” operator by 2027-2028.
• OpenUSD as converged cross-application scene substrate: The Alliance for OpenUSD (AOUSD: Apple, Adobe, Autodesk, NVIDIA, Pixar) has driven OpenUSD adoption across every major DCC: Houdini Solaris (native USD LOPs), Blender (USD import/export, expanding native support), Unreal Engine (USD stage import and export), Maya (USD plugin), NVIDIA Omniverse (USD-native platform), Katana (USD-centric look-development), Maya USD plugin (Autodesk), DaVinci Resolve (USD timeline metadata). This convergence enables cross-tool procedural pipelines with zero format conversion: a Houdini SOP network generates terrain geometry, exports via USD, a Katana LOP network applies look-development overrides, Unreal imports the composed USD stage for real-time preview, and a Karma XPU farm renders the final output — with all tools reading from and writing to the same USD layer stack.
• UK competitive position and industrial significance: The UK VFX industry employs approximately 32,000 people (BFI Screen Industry Report 2024), generates £1.4B in annual revenue, and attracts major Hollywood tentpole productions through the UK’s Audio-Visual Expenditure Credit (AVEC, successor to UKITR) providing 34% tax relief on qualifying VFX expenditure — the highest rate in Europe for above-the-line digital content. Framestore (London), DNEG (London), Cinesite (London/Montreal), Milk VFX (London/Bristol), and Outpost VFX (Bournemouth) all operate full Houdini/Karma/USD procedural pipelines. Foundry (London) produces the ecosystem’s two most critical bridging tools — Katana (look-development/lighting consumed by ILM, DNEG, Weta, Framestore) and Nuke (the world’s dominant compositing platform) — both deeply USD-integrated. The Houdini ecosystem’s penetration into UK games (Rare, Creative Assembly, Rocksteady, Playground Games, Frontier Developments) is also substantial, with Houdini Indie and Core licences widely used for procedural environment and VFX tooling in AAA console/PC game production.

UK Context

• Foundry (London, King’s Cross): Developer of Katana (look-development and lighting — used by ILM, DNEG, Weta, Framestore), Mari (3D texture painting), Nuke (industry-standard compositing), and Modo (sub-division modelling). Foundry’s 25-year heritage places it at the centre of UK and global VFX software. Katana integrates procedural scene-graph assembly with USD for scalable multi-shot lighting workflows.
• Framestore (London, Soho): Award-winning VFX studio whose CG Supervisor Nestor Prado oversaw the transition of Framestore’s lighting pipeline to Houdini Solaris/USD during Project Hail Mary production (2024). Framestore is among the most technically advanced Houdini procedural pipeline operators in Europe.
• DNEG (London, Soho): VFX and animation studio that migrated their full lighting pipeline from Clarisse to Houdini Solaris between seasons of The Last of Us. DNEG operates procedural simulation and effects pipelines for major Marvel, DC, and streaming productions.
• UCL (University College London) — UCL’s Virtual Environments and Computer Graphics (VECG) group works on procedural and physics-based animation, deformation, and fluid simulation. The UCL Computer Science department is a leading UK node for differentiable rendering and neural scene representation research.
• Imperial College London — Imperial’s Visual Computing group contributes to real-time rendering, computational photography, and neural implicit surfaces. Imperial hosts the London node of the UKRI Centre for Doctoral Training in AI for Healthcare, adjacent to XR and volumetric capture.
• University of Edinburgh — The Edinburgh Computer Vision group (including contributors to NeRF research) and the School of Informatics contribute to implicit neural representations and procedural simulation.
• Manchester / Sheffield: Northern English industrial presence through games studios (e.g., Sumo Group Sheffield, various Eurogamer-listed studios), where Unreal PCG and EmberGen are standard production tools. The University of Manchester Computer Graphics group contributes to procedural terrain and simulation research.

Future Directions (2026–2030)

• Foundation-model-driven procedural graph generation: The trajectory is toward systems where a text or image prompt triggers automatic generation of a complete procedural graph — PCG nodes, physics solvers, material assignment, temporal animation, lighting — with a foundation model acting as a “procedural programming language” interpreter for natural language creative intent. The technical substrate is already emerging: Houdini 21 ML Nodes (AI inference as DCC operators), LLM-to-node-graph translation research (generating Python/VEX code from natural language), and multi-modal foundation models (Claude, GPT-4o, Gemini) demonstrating proficiency at generating Houdini VEX and Python SOP scripts. By 2028-2030, the expectation is that a director-level user will describe a scene procedurally in natural language and a foundation model will instantiate the appropriate Houdini/PCG/Geometry Nodes network, with technical artists reviewing and refining the result rather than building it from scratch.
• 4DGS as native DCC primitive type: 4DGS representations are expected to appear as native primitive types in major DCC tools (Houdini, Blender, Unreal Engine) by 2027-2028, following the integration path of volumetric VDB (first research→Houdini native→cross-DCC standard via OpenVDB). A “Gaussian Splatting Geometry” node in Blender Geometry Nodes or a Houdini SOP for 4DGS import/export/simulation coupling would allow artists to work with captured dynamic content using the same graph-based procedural paradigms used for conventional geometry today. The AOUSD alliance is exploring USD schema extensions for Gaussian Splatting primitives, which would further accelerate cross-tool interoperability.
• Generalised 4D world models as content creation substrates: Large video generation models (Sora successors, Genie 2 derivatives, VideoWorldModels) trained explicitly on 3D-consistent datasets (Infinigen, Objaverse, synthetic data from Omniverse) will likely produce 4D geometry as a first-class output modality by 2027-2028 — not a post-hoc lift from 2D video but a native spatiotemporal representation. This collapses the distinction between “generative AI” and “procedural 3D” into a unified creative system where the model understands physical law implicitly and generates content that satisfies it by construction. The critical enabling dataset is synthetic 3D-consistent video at scale — something only procedural generation pipelines (Infinigen, Houdini-based synthetic data tools, Omniverse Replicator) can produce efficiently.
• Volumetric streaming standards and 4D content distribution: The MPEG Immersive Video (MIV) standard (ISO/IEC 23090-12) and Video-based Point Cloud Compression (V-PCC, ISO/IEC 23090-5) are developing the transport layer for dynamic 3D content delivery to XR devices. Khronos Group’s glTF extensions for mesh animation and volumetric primitives are expanding toward 4DGS representation support. By 2027-2028, a standardised volumetric streaming codec optimised for 4DGS (leveraging inter-frame Gaussian prediction, motion-compensated Gaussian tracking, and hierarchical detail streaming) is anticipated to enable broadcast-quality 4D content delivery at 5G-feasible bitrates (<25 Mbps for full HD dynamic scene).
• Physics-informed neural operators for interactive simulation: Fourier Neural Operators (FNO, Li et al. NeurIPS 2020) and DeepONets (Lu et al. Nature Machine Intelligence 2021) trained on Houdini FLIP simulation data are demonstrated to accelerate fluid simulation by 100-10,000× relative to numerical PDE solving at comparable accuracy for the distributions they are trained on. By 2027-2028, neural operator-based simulation accelerators are expected to appear as Houdini SOP nodes — replacing the Pyro/FLIP/MPM numerical solvers for common effect categories (turbulent smoke, ocean wave propagation, granular debris) while preserving the procedural network authoring paradigm. This enables interactive (real-time or near-real-time) simulation of physical complexity previously requiring 8-24 hour Houdini farm renders, fundamentally changing the iteration speed of VFX production.
• Procedural generation for embodied AI and robotics: Synthetic environments generated by procedural tools (Unreal PCG, Infinigen, Houdini, Omniverse) are the dominant training substrate for embodied AI systems (household robots, autonomous vehicles, warehouse logistics). The quality and diversity of procedural environments — specifically their physical realism (material properties, lighting, geometry detail) and semantic richness (object identities, part annotations, affordance labels) — are the principal bottlenecks for sim-to-real transfer. UK organisations (Dyson robotics, Bosch/FiveAI (now Bosch AI), Wayve) are major consumers of procedurally generated training environments, creating industrial demand for the next generation of physics-accurate, semantically rich procedural world generation tools.

Procedural VFX Pipeline: End-to-End Workflow

• A typical procedural VFX shot pipeline (e.g., city destruction for a feature film) illustrates how these tools interconnect in production. Each stage outputs a USD layer consumed by the next:
• Stage 1 — Procedural Environment Layout (Houdini Solaris LOPs / Unreal PCG):
  • City blocks generated by CGA shape grammar (Esri CityEngine) or Houdini instancing from building block set
  • Streets, infrastructure, terrain populated procedurally using scattering and constraint systems
  • Output: USD prims with building instances, terrain mesh, road network geometry
• Stage 2 — Destruction Pre-Computation (Houdini RBD + Voronoi Fracture):
  • Hero buildings pre-fractured using Voronoi fracture SOP with artist-controlled interior detail
  • Constraint networks define structural hierarchy (walls→floors→foundation) determining collapse progression
  • Houdini Pyro/FLIP simulation generates fire, smoke, dust, debris dynamics coupled to RBD
  • Output: USD geometry caches (Alembic or USD PointInstancers) for fractured building animation
• Stage 3 — Look-Development (Katana + MaterialX):
  • Material assignments defined in Katana look file as USD override layers
  • MaterialX shading networks define building materials (concrete, glass, rebar, signage) with damage-state variation
  • Environment HDRI lighting and key/fill/rim light assignments in Katana LOP network
  • Output: USD look file layer with material bindings and light prims
• Stage 4 — Crowd and Secondary Elements (Houdini Crowd / Houdini Copy-and-Transform):
  • Crowd agents (civilians, emergency services) generated with Houdini Crowd simulation
  • Agent state machines drive run/stumble/cover behaviour parameterised by proximity to destruction
  • Secondary debris (papers, glass shards, lightweight objects) as particle systems driven by fluid simulation velocity fields
  • Output: USD PointInstancer prims for crowd agents and debris particles
• Stage 5 — Atmospheric FX (Houdini Pyro / EmberGen):
  • Large-scale smoke columns (Houdini Pyro on render farm, 4-8 hour simulation for hero elements)
  • Real-time GPU smoke (EmberGen) for secondary/background smoke elements, exported as VDB caches
  • Dust and particulate (Houdini particles advected by Pyro velocity fields, rendered as volumes)
  • Output: VDB volume caches referenced as USD Volume prims
• Stage 6 — Final Render (Karma XPU / Arnold):
  • Karma XPU combines GPU ray tracing (RTX acceleration) with CPU path tracing for complex lighting
  • Cryptomatte AOVs (arbitrary output variables) separate foreground/background/element IDs for compositing
  • Deep EXR output (32-bit with per-sample depth) enables depth-correct compositing of volumetric elements
  • Full render: 4-16 minutes per frame on CPU farm; 30-90 seconds per frame on GPU with Karma XPU
• Stage 7 — Compositing (Nuke):
  • Houdini-rendered elements composited with live-action plate and other CG elements
  • Foundry Nuke’s Cryptomatte node provides artist-friendly per-object colour correction
  • USD-native Nuke (Nuke 14+ USD support) can read 3D USD scene geometry directly into Nuke’s 3D workspace for interactive projection mapping and re-lighting

Procedural Generation Taxonomy: Six Major Paradigms

• The field of procedural generation encompasses six structurally distinct paradigms, each with its own mathematical foundations, principal tools, and target content categories:
• 1. Grammar-Based Generation uses formal rewriting systems — L-systems, shape grammars (Stiny & Gips 1972), graph grammars — to derive complex structures from simple axioms by iterative rule application.
  • L-systems: string rewriting applied to botanical and organic structure generation. Axiom ω, productions P: Σ→Σ*, parallel rewriting produces exponentially complex structures in O(n) iterations.
  • Shape grammars: parameterised rules operating on geometric shapes rather than strings. Widely used for procedural architecture (CGA Shape grammar in Esri CityEngine, procedural building generation in GTA/RDR2).
  • Graph grammars: rules operating on attributed graphs representing scene topology. Used in procedural dungeon generation, level layout, and narrative structure systems.
  • Wave Function Collapse: constraint propagation over tile adjacency rules. Tile type observed: tile collapsed → neighbour possibilities reduced. Used in Caves of Qud, Townscaper, Nier:Automata environment generation.
• 2. Noise-Based Synthesis generates continuous, coherent random fields via mathematical noise functions.
  • Perlin/Simplex noise: gradient-interpolated noise with controllable octave structure (fBm). Universally used for terrain heightmaps, cloud density volumes, and procedural textures across Houdini Volume VOPs, Blender Shader/Geometry Nodes, and HLSL/GLSL shaders.
  • Worley (cellular) noise: distance to nearest random point in cell. Produces voronoi-pattern textures — biological tissue, cracked earth, water caustics.
  • Domain warping: recursive noise self-application f(p) = noise(p + noise(p + noise(p))). Produces turbulent, fluid-resembling patterns used for fire, clouds, and organic deformation.
  • Curl noise: divergence-free vector field derived from noise potential function, used for smooth particle advection in Houdini pyro simulation and stylised smoke art direction.
• 3. Physics-Based Simulation generates time-varying content by numerically integrating physical equations.
  • Fluid simulation (FLIP/SPH): incompressible Navier-Stokes solved via hybrid particle-grid (FLIP) or pure particle (SPH) methods. Houdini FLIP, Phoenix FD, Bifrost.
  • Rigid body dynamics (RBD): contact forces and collision resolution for rigid objects. Houdini RBD, Bullet physics, Havok. Used for building destruction (Houdini Voronoi fracture + constraint networks).
  • Cloth/soft body (Vellum/XPBD): position-based constraint simulation for textiles, character hair, elastic bodies. Houdini Vellum (XPBD), Marvelous Designer, nCloth.
  • Fire/smoke (Pyro): finite-difference volumetric combustion simulation on MAC grids. Houdini Pyro FX. EmberGen replaces this for games/real-time with GPU-native voxel simulation.
  • MPM (Material Point Method): unified particle-grid formulation handling solid-fluid mixtures, granular flow, elastic fracture. Houdini 20.5+ MPM solver. Research origin: Disney Frozen (Stomakhin et al. 2013 snow simulation).
  • Ocean simulation: spectral methods (JONSWAP/PM spectra) for deep water, Tessendorf (2001) FFT-based ocean surface, shallow water equations for shoreline interaction. Houdini Ocean FX with FLIP foam/spray.
• 4. Instance/Scatter-Based Generation procedurally places and varies asset instances across surfaces and volumes.
  • Scatter: Poisson disc sampling, jitter grid, random distribution of instances over surfaces using attribute-driven density maps and slope/altitude masks. Houdini Copy and Transform SOP, Blender Geometry Nodes Instance on Points, Unreal PCG Point Scatter.
  • Foliage systems: SpeedTree, Houdini Labs tree generator, Unreal PCG Procedural Vegetation Editor (UE 5.7). Botanical parameterisation (trunk taper, branch angle, leaf density) generates botanically valid trees with LOD variants.
  • Crowd simulation: Houdini Crowd (agent state machines, steering behaviours, terrain adaptation), Massive (Lord of the Rings heritage), Golaem (Maya plugin). Agent-based autonomous movement in large-scale battle scenes and cityscapes.
  • Point cloud instancing: Houdini packed primitives system enables billions of instances with shared geometry data — single mesh drawn millions of times with varied transforms, attributes (colour, scale), reducing memory from O(N×geo) to O(geo + N×transforms).
• 5. Constraint-Based / Optimisation-Driven Generation specifies desired properties of output and solves for configurations satisfying them.
  • Constraint propagation (WFC): enforces adjacency rules during generation. Used for tile-based environments, map layout, architecture.
  • Space planning: Infinigen Indoors constraint-based arrangement system places furniture respecting physical clearance, semantic adjacency (chair near table, sink near stove), and room topology constraints.
  • Procedural rigging constraints: Houdini KineFX constraint networks enforce joint limits, IK/FK blending, and physics-coupled secondary motion satisfying kinematic and dynamic constraints simultaneously.
• 6. Hybrid Neural-Procedural Generation integrates learned models as procedural operators or priors.
  • Neural field synthesis: NeRF, 3DGS, SDF neural networks reconstructing scene content from images as continuous differentiable functions — then used as procedural scene representations editable by downstream operators.
  • Diffusion-guided proceduralism: SDS (Score Distillation Sampling) uses diffusion model gradients to guide procedural parameter optimisation toward semantic objectives — text-driven 3D shape generation via 3DGS optimisation (DreamFusion, Magic3D, GaussianDreamer).
  • Houdini 21 ML Nodes: data generation, training, inference as Houdini operators. Neural network embedded as a procedural node outputting deformed geometry, material predictions, or novel frame synthesis.
  • Neural point cloud meshing: Houdini 21 Neural Point Surface. Learned models for surface reconstruction from sparse, noisy point clouds — better than Poisson reconstruction at handling data gaps and thin structures.

Procedural Shader and Material Systems

• Procedural generation extends beyond geometry into surface appearance — material and shader systems that generate texture and appearance algorithmically rather than from scanned or painted image maps:
• MaterialX (ILM open-source standard, ASWF): a portable node-graph shading language defining material properties independent of renderer and DCC. MaterialX nodes span:
  • Geometric inputs: position, normal, tangent, UV coordinates, curvature
  • Noise functions: Perlin, Worley, fBm, fractal — all implemented as materialX nodes for portability
  • Layering: add, multiply, mix, screen, over compositing operations
  • BSDF (Bidirectional Scattering Distribution Function) primitives: diffuse, specular, transmission, subsurface scattering, sheen — combined via layering for physically-based materials
  • MaterialX → GLSL/HLSL/MSL/OIIO transpilation: a single MaterialX document generates valid shader code for OpenGL, DirectX, Metal, and Arnold/Karma/RenderMan simultaneously
• Houdini VOP (Vector Operation) Networks: Houdini’s visual shader graph system built on VEX compilation. CVEX (Context-specific VEX) runs in render contexts: surface, displacement, volume, and light shader contexts.
  • Volume VOPs: generate procedural volumes (noise-based density fields) without cached VDB simulation — infinite resolution, parameter-driven, zero storage cost
  • Displacement VOPs: per-vertex procedural displacement mapping — entire terrains generated by noise displacement of low-res base meshes
  • MaterialX bridge: Houdini 20.5+ generates MaterialX output from VOP networks for cross-DCC portability
• Blender’s Cycles/EEVEE Shader Nodes: Blender’s material node system supports procedural textures natively:
  • Noise Texture, Wave Texture, Magic Texture, Voronoi Texture, Brick Texture: built-in procedural generators
  • Geometry node: access position, normal, UV coordinates for position-based proceduralism
  • Color Ramp, Mix, Map Range: value manipulation for driving material parameters from geometric attributes
  • Shader to RGB (EEVEE only): access rendered colour for toon/stylised effects driven by geometry
• Unreal Engine Material Graph: UE’s physically-based material system (Disney PBR) exposed as a node graph:
  • Material parameter collections: shared parameters driving multiple materials simultaneously — change time-of-day parameter → all procedural sky/water/terrain materials update
  • Runtime Virtual Textures: procedurally generated terrains write their appearance into runtime virtual textures for efficient landscape rendering
  • Material Functions: reusable node sub-graphs analogous to Houdini HDAs for materials — a library of procedural rock, snow, mud, and blend functions composited per material

4DGS Variants: Comparative Analysis

• The 4DGS family of methods (2024) represents the current frontier of dynamic neural scene representation. Each approach makes different design choices in how temporal information is encoded:
• 4D Gaussian Splatting for Real-Time Dynamic Scene Rendering (Wu et al., CVPR 2024):
  • Representation: 3D Gaussians + 4D neural voxels (HexPlane decomposition over XY, XZ, YZ, XT, YT, ZT planes)
  • Deformation: lightweight MLP decodes space-time features to Gaussian parameter deltas (Δμ, ΔR, ΔS)
  • Performance: 82 FPS at 800×800, RTX 3090; training ~1h on 25-second video
  • Strength: efficient feature retrieval; real-time capable
  • Limitation: MLP deformation is approximate; may miss high-frequency temporal detail
• Real-time Photorealistic Dynamic Scene Representation with 4D Gaussian Splatting (Yang et al., ICLR 2024):
  • Representation: native 4D Gaussian primitives with 4D covariance tensors Σ₄ᴅ ∈ ℝ⁴ˣ⁴
  • Colour: 4D Spherindrical Harmonics for time-varying view-dependent appearance
  • Strength: superior appearance modelling for view-dependent colour under dynamic lighting
  • Limitation: higher memory and training compute; harder to extend to production pipelines
• ST-4DGS: Spatial-Temporally Consistent 4D Gaussian Splatting (SIGGRAPH 2024):
  • Focus: temporal consistency — reduces flickering between frames on fast-moving regions
  • Method: adds temporal regularisation losses penalising Gaussian parameter discontinuities between adjacent frames
  • Application: multi-camera human capture, broadcast sports replay
• 4D Gaussian Splatting: Native 4D Primitives (Ye et al., arXiv Dec 2024):
  • Eliminates the 3D+deformation decomposition; Gaussians are native 4D objects
  • Treats time as a fourth spatial axis — Gaussians “exist” in spacetime rather than being deformed
  • Theoretical advantage: avoids accumulation of deformation estimation errors over long sequences
• GGHead: Fast Generalizable 3D Gaussian Heads (SIGGRAPH Asia 2024):
  • Uses 3DGS within a 3D GAN framework for human head generation
  • 2D CNN generates Gaussian attributes in UV space on a template head mesh
  • Application: generative avatars, face synthesis — a generative (not reconstruction) 4D paradigm

Cascadeur: AI Physics Animation Architecture

• Cascadeur by Nekki occupies a specific niche in the procedural animation space — AI-assisted physically-correct keyframe animation rather than full simulation or pure kinematics:
• AutoPhysics: the core Cascadeur feature. Given a keyframed animation with primary poses set by the animator, AutoPhysics automatically computes physically correct secondary motion:
  • Trajectory arcs: adjusts in-between poses to follow physically plausible ballistic trajectories (parabolic arcs for jumps, pendulum motion for hanging limbs)
  • Mass distribution: simulates simplified rigid body dynamics on the character skeletal chain to correct momentum and weight transfer
  • Secondary motion: cloth proxy, tail/hair proxy dynamics computed as spring-mass chains from the physics-correct primary motion
• Pose Prediction: deep learning models trained on motion capture libraries predict probable next poses from current pose context — providing motion auto-complete for common movement types (locomotion, combat, action) that animators can accept or override.
• Physics Verification Tools: real-time visualisation of centre of mass trajectory, balance polygons (convex hull of support contacts), and joint torques enables animators to visually verify physical plausibility without running full physics simulation.
• Pipeline integration: Cascadeur exports FBX (Maya, Unreal, Unity compatible) and BVH (motion capture format). Boxel Studio’s workflow (Wonder Dynamics partnership) demonstrates Python retargeting tools converting Cascadeur ML motion data to production rigs in Maya/Unreal — a cross-AI-procedural-tool pipeline where Wonder Studio provides character replacement and Cascadeur provides physics-correct motion refinement.
• Cascadeur 2024.2 (September 2024): expanded AutoPhysics accuracy, improved trajectory handles, new deep learning motion instruments for combat animation, and export improvements for Unreal Engine 5 skeleton mapping.
• Market position: Cascadeur targets the games animation market specifically — a segment where Houdini/Maya simulation is too complex and expensive for tight production schedules. Cascadeur’s per-animator subscription (significantly cheaper than Houdini) and focused character animation scope make it accessible to indie and mid-tier games studios across the UK and globally.

Research & Literature

• 1. Prusinkiewicz, P. & Lindenmayer, A. (1990). The Algorithmic Beauty of Plants. Springer-Verlag. [Foundational L-systems text]
• 2. Perlin, K. (1985). An Image Synthesizer. SIGGRAPH 1985. [Perlin noise — procedural texture foundation]
• 3. Brackbill, J.U. & Ruppel, H.M. (1986). FLIP: A Method for Adaptively Zoned, Particle-in-Cell Calculations in Two Dimensions. Journal of Computational Physics.
• 4. Zhu, Y. & Bridson, R. (2005). Animating Sand as a Fluid. SIGGRAPH 2005. [FLIP for sand/fluid hybrid]
• 5. Stomakhin, A. et al. (2013). A Material Point Method for Snow Simulation. SIGGRAPH 2013.
• 6. Müller, M. et al. (2007). Position-Based Simulation Methods in Computer Graphics. EuroGraphics 2007.
• 7. Mildenhall, B. et al. (2020). NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis. ECCV 2020.
• 8. Müller, T. et al. (2022). Instant Neural Graphics Primitives with a Multiresolution Hash Encoding. SIGGRAPH 2022.
• 9. Kerbl, B. et al. (2023). 3D Gaussian Splatting for Real-Time Radiance Field Rendering. SIGGRAPH 2023. ACM TOG.
• 10. Wu, G. et al. (2024). 4D Gaussian Splatting for Real-Time Dynamic Scene Rendering. CVPR 2024. arXiv:2310.08528.
• 11. Yang, Z. et al. (2024). Real-time Photorealistic Dynamic Scene Representation and Rendering with 4D Gaussian Splatting. ICLR 2024. (Fudan ZVG)
• 12. ST-4DGS (2024). Spatial-Temporally Consistent 4D Gaussian Splatting for Efficient Dynamic Scene Rendering. ACM SIGGRAPH 2024. doi:10.1145/3641519.3657520.
• 13. Ye, Z. et al. (2024). 4D Gaussian Splatting: Modeling Dynamic Scenes with Native 4D Primitives. arXiv:2412.20720.
• 14. Guédon, A. & Lepetit, V. (2024). SuGaR: Surface-Aligned Gaussian Splatting for Efficient 3D Mesh Reconstruction and High-Quality Mesh Rendering. CVPR 2024.
• 15. Huang, B. et al. (2024). 2D Gaussian Splatting for Geometrically Accurate Radiance Fields. SIGGRAPH 2024.
• 16. GSDF (2024). 3DGS Meets SDF for Improved Neural Rendering and Reconstruction. NeurIPS 2024.
• 17. Raistrick, A. et al. (2024). Infinigen Indoors: Photorealistic Indoor Scenes using Procedural Generation. CVPR 2024.
• 18. OpenAI (2024). Video Generation Models as World Simulators. Technical Report (Sora). openai.com/index/video-generation-models-as-world-simulators/
• 19. SideFX (2024). What’s New in Houdini 20.5. sidefx.com/products/whats-new-in-h205/
• 20. SideFX (2025). Houdini 21 — SIGGRAPH 2025 Keynote. sidefx.com/houdini-hive/siggraph-2025/
• 21. Blender Foundation (2024). New Geometry Nodes Features in Blender 4.2. studio.blender.org/blog/new-geometry-nodes-features-in-blender-42/
• 22. Epic Games (2024/2025). Procedural Content Generation Framework — Unreal Engine 5.7 Documentation. dev.epicgames.com/documentation/en-us/unreal-engine/procedural-content-generation-overview
• 23. JangaFX (2024). EmberGen 1.2 Release Notes. cgchannel.com/2024/07/jangafx-releases-embergen-1-2/
• 24. CG Channel (2024). Wonder Animation — Wonder Studio’s AI Video to 3D Scene System. cgchannel.com/2024/10/check-out-wonder-animation-wonder-studios-ai-video-to-3d-scene-system/
• 25. Nekki (2024). Cascadeur 2024.2. beforesandafters.com/2024/09/15/ai-powered-animation-software-cascadeur-2024-2-now-out/
• 26. Pixar / AOUSD (2024). Universal Scene Description — Introduction. openusd.org/release/intro.html
• 27. BFI (2024). UK Screen Alliance: VFX Industry Report 2024. [UK economic context]
• 28. Digital Production (2025). Houdini 21: SideFX Pushes for Production Readiness Across the CG Pipeline. digitalproduction.com/2025/08/13/houdini-21-sidefx-pushes-for-production-readiness/

Provenance

• domain-correction: spatial-computing → graphics-creative-tools
• domain-correction-rationale: The concept is a domain cluster of DCC tools, neural rendering representations, and procedural generation pipelines — it belongs to the graphics-creative-tools ontological domain, not spatial-computing. IRI, URI, same-as, and owl-class corrected accordingly.
• iri-correction: http://narrativegoldmine.com/spatial-computing#ProceduralAndHybrid4D → http://narrativegoldmine.com/graphics-creative-tools#ProceduralAndHybrid4D

Metadata

• Lines: 606 (target 600-850)
• Words: 14,340 (target 8,500-12,000; exceeds upper bound due to depth of coverage)
• OWL Axioms: 45 (target 35-46)
• Wikilink Relationships: 82 (target 60-82)
• References: 28 (target 25-28)
• Domain corrected: spatial-computing → graphics-creative-tools
• Quality score: 0.52
• Authority score: 0.87