Hey guys, and I wanted to share a module I have been working on which ports SideFX Houdini’s VAT 3.0 tools to WGSL. Below are some notes, a link to a repository with the code, and playground example showing a version created for Babylon-js (stackblitz version to come). There are a wealth of interesting tools and tutorials available online (SideFX Labs) explaining how the same tools have been used to create effects for Unreal and Unity. The repository contains a basic demo which shows each of the variants running from a local server.
Please take a look, and let me know what you think.
VAT3 — Houdini Vertex Animation Textures
VAT3 brings SideFX Houdini’s Vertex Animation Textures (VAT) workflow to modern WebGPU renderers.
Artists author simulations in Houdini and export them as a portable asset package consisting of geometry, textures, and metadata. At runtime, Babylon.js and Three.js reconstruct those simulations entirely on the GPU by sampling animation data from textures rather than evaluating animation or simulation logic on the CPU.
The result is a scalable workflow for rendering cloth, destruction, fluids, crowds, particles, and other complex effects in real time while preserving a clean separation between content creation and runtime implementation.
I got curious about this, so I took your samples, and some others that I found, and combined the logic along with logic from other repos like the babylon one, to make this:
That’s really cool, and thanks for migrating the assets instead of hacking headers. I was thinking about adding some per-instance data and this looks great.
awesome! glad it could give you some ideas. thanks for the inspiration!
I wanted to try to keep it as general as possible in the hopes that it could open VATs from different sources…
But I also tried some VATs that were used/created for unity hdrp, and I’m having mixed/bad results. I want to track down more examples to test with in there.
The Unity outputs are y-up lh and would need to be converted (probably not worth your time). I am going to migrate the particle work to compute shaders, and in the process open the simulation up for enrichment (particle trails, advection, icp search, mesh collisions). Houdini can create infinite combinations of simulation data and export packed (sparse) containers that expand into shader inputs (dense reconstructions) at runtime. It’s a work flow leveraged a lot in Unreal games that really raises the quality bar of renders.
I added your link to the post I made a few weeks ago on LinkedIn, but wasn’t able to find your profile to directly site you. Let me know if that’s important and I’ll update it.
@rdurnin I fixed interpolation for rigidBody + particles + softBody.. so now you can actually use lower FPS exports and still get smooth motion… (doesn’t apply to fluids which have variable topology)
Check it out, ( try setting the speed to slower and observe that the fracture+particles+softBody all look smooth in slow motion )
And also fixed a bunch of bugs.. like shadows, etc.
And I also wrote an exporter for Blender to export VATs so you can make your own.. and a test suite, in a .blend file in the repo as well.
I had tried to get OpenVAT to work, but its export wasn’t very conformant to how the vat3 demos work, so I wrote my own exporter (available in the repo) that emits something easier to consume.
Wow, thanks, and I have shared the repo with the Babylon.js forum as well. As a side note, I added a flag that would allow you to use 8 bit color textures with the 32 fp animation data (rotation, position, etc). There isn’t much value in loading those textures high-res and it’s worth checking if the Blender version isn’t automatically applying gamma to them on export.
Ooo that sounds like a good optimization. My blender exporter does either/or (all png, or all exr), but not mixed.. (png for rot/norm, exr for position).
I’ll have to figure out how to tag it in the metadata.
You shouldn’t need to as there is already a switch named isColorTexHdr (might need porting as it’s used on asset ingest and not in the shader). I built an accompanying particle shading lib (nova) which requires emissive maps to use linear textures, as they apply a (rough) scaling factor to improve glow (required tone mapping). It’s a carry over from how Unity handles glow, but it makes for nicer looking fire and explosions (etc).
Thanks again for any efforts you have made. It’s always a pleasure to see what someone else can do when you pass them a ball.
This isn’t exactly the same, but I once worked on something similar—fundamentally the same concept—but applied to volume. I wonder if anyone has optimized this aspect yet.
I’m using a few tricks to keep the file size around 300KB for an animation nearly a second long—spanning 30 to 60 frames. I’m not using compression because the resulting errors are too significant.
There is a vdb → unreal exporter, and some interesting work done with it (see below), that I have been thinking about porting. It would need to use a gpu friendly data structure (nanovb or picovdb) but could be quantized for faster unpacking and downloading (likely as an export post-process).
:
