Mykhailo Moroz

Figured out a proper Gaussian Splat -> #VRChat workflow using free software and @michael-moroz.bsky.social's implementation. I'm really happy with the result!

I made a tutorial on my blog if anyone wants to scan the world and create VRChat maps from it!

blog.monsy.monster/gaussian-spl...

Nanite Tessellation Nanite Tessellation, aka Nanite Dynamic Tessellation, aka Nanite Dynamic Displacement was the next major feature I worked on after Nanite it...

I'm finally writing up how Nanite Tessellation works. The first few blogs posts are up. More will be coming.
graphicrants.blogspot.com/2026/02/nani...

I just released my video about the engine (and game) I've been working on.

The engine is based on dynamic SDFs, and the video describes how it works and what it makes possible.

Link in the reply!

This is my first YouTube video and it took forever - please repost!

Ever seen one of these, and wondered *why* they work? 🧵

This is a so-called Bitonic sorting network, and the illustrations show the two common ways to implement them. From an implementation point of view the two methods are effectively the same, so which one you pick just comes down to preference.

I might make a new blog post on this, but that will take time 😪

Of course, it has a drawback since its much noisier than RT (but is it a drawback really?), and is much less suited for a gas simulation due to using whole integer particle masses, so they cant fill all space properly.

An additional bonus is that since the masses are uints, as long as it doesn't overflow the counter the mass / particle count is preserved exactly. While in reintegration tracking it would have been lost with time due to float imprecision.

I like this approach significantly more compared to michaelmoroz.github.io/Reintegratio... since without much velocity averaging this can actually preserve angular momentum significantly better. Not to mention the you get subpixel details without aliasing due to the grid.

As long as the particle density is lower than 1.0 particle per cell, you are guaranteed that no resampling happens, which means it will behave exactly like a normal SPH (or anything else) particle sim.

You could also call this particle resampling cellular automaton, i.e. it tries to resample the actual particle count to keep it lower than the max 2 per grid cell (so that a grid only simulation is possible)

Decided to go back to making Shadertoy fluid sims for for a bit.
This time I improved my particle clustering cellular automaton SPH fluid sim to support multiple species particle merging and splitting. Also some fine tuning of the physics.
shadertoy.com/view/tfyyWD

I am making clouds for @skipsy.ca's new VRChat world. The clouds render faster than the mountains lol

#VRChat

Gonna add my own 2 coins
michaelmoroz.github.io/TracingGeode...
www.shadertoy.com/view/ftBGWm
rantonels.github.io/starless/

Yeah I was aware of iResolution, I just never used the z component, but I guess I should still add it for compatibility.
Mouse zw has no equivalent in Compute toys, so that needs to be added in the first place.
Texture mipmaps for the pass-in/out buffers are not computed unfortunately

Of course there are still some minor differences:
* matrix multiplications are not a*b but mul(a,b)
* no GLSL texture types like sample2D / etc
* there are no "Shadertoy" channels, you need to resetup them to use absolute indices of the pass_in/out buffer

Slang can be made extremely close to GLSL/Shadertoy style of shaders by using a set of defines and typealiases, I've made a template in compute.toyts just for that compute.toys/view/1947
I also ported my most popular shadertoy using it:
compute.toys/view/1948

Compute.toys finally got the Slang compiler integrated, which means its finally time to ditch WGSL 🎉🎉
I've ported my FFT to it, coding in it is much nicer. compute.toys/view/1922
Should try something with its autodiff next.

Faster Mixed Radix FFT Forked from https://compute.toys/view/1914 Faster version

Made a mixed radix FFT implementation in compute.toys/view/1915
It is neat, but I still wonder how do you properly handle large prime factor size FFT's?

I mean its just SPH, its not *that* difficult

No, its written by me, that's why I can not answer your question easily.

uhhhm, shadertoy?

The answer to this will require a whole new blog post I'm afraid...

Shadertoy

I've also tested out using it for nontrilinear stuff as well as volumetric integration
shadertoy.com/view/w3sXzf
shadertoy.com/view/t3sXzX
shadertoy.com/view/t3lSzf

I've ported my vrchat isosurface ray tracer to shadertoy and added it to my fluid simulation there.
Its probably the fastest multibounce ray tracing for liquids I've made thus far.
shadertoy.com/view/w3sXzs

Shadertoy

I posted my own implementation of the trilinear isosurface intersection on shadertoy
2 methods, one is the one from jcgt.org/published/00... and the other one is my own idea of using 4 trilinear samples (can use HW samplers here) to reconstruct the cubic.

www.shadertoy.com/view/WXS3Rm

Managed to get Nvidia Flow (PhysX) to compile and run, after initially failing the other week. Was curious for a quick peek now that it's been open sourced (github.com/NVIDIA-Omniv...)

Flow itself isn't CUDA based, but instead uses compute shaders

Some higher level observations in the replies 1/?

I've also finally implemented sorting of the simulation particles, gave quite a nice performance boost (around
3-4x)

till surprising to me just how fast this turned out to work, my older attempts at ray tracing density isosurfaces were horrifyingly slow, and on top of that less accurate too, as it was just constant step ray marching.

The paper was about tracing SDFs but you can apply it to any isosurface of an interpolated 3D volume, like the liquid density.

The Nvidia paper from above also shows how to optimize those intersections quite significantly, giving a fast way to get the coefficients of the cubic as well as how to solve it quickly (would be great if it wasn't patented by Nvidia tho heh...)