Geometric features between the micro and macro scales produce an expressive family of visual effects grouped under the term 'glints'. Efficiently rendering these effects amounts to finding the highlights caused by the geometry under each pixel. To allow for fast rendering, we represent our faceted geometry as a 4D point process on an implicit multiscale grid, designed to efficiently find the facets most likely to cause a highlight. The facets' normals are generated to match a given micro-facet normal distribution such as Trowbridge-Reitz (GGX) or Beckmann, to which our model converges under increasing surface area. Our method is simple to implement, memory-and-precomputation-free, allows for importance sampling and covers a wide range of different appearances such as anisotropic as well as individually colored particles. We provide a base implementation as a standalone fragment shader.
Rendering Particles with Compute Shaders
Overview I developed a technique to render single-pixel particles (using additive blending) with compute shaders rather than the usual fixed-function rasterization with vertex and fragment shaders. My approach runs 31–350% faster than rasterization on the cases I tested and is particularly faster for some “pathological” cases (which for my application are not actually that uncommon). I observed these speedups on both NVIDIA and AMD GPUs. Using this technique allowed me to ship an app that runs on minimum-spec hardware without sacrificing visual fidelity.
Surfel-based global illumination on the web
Can we use WebGPU to compute real-time global illumination with surface patches called surfels? Does it look good enough? Is it fast enough? And can we finally construct viable compute-heavy rendering pipelines right here on the open web? Join me on this journey and let's find out!
Nicole Feng
We describe a method for computing signed distance to point clouds that allows fast pointwise evaluation at arbitrary spatial resolution. As input, our method takes a point cloud with normals; as output, it provides an analytical parameterization that allows queries of signed distance to the approximate underlying surface at arbitrary points — simultaneously providing reconstruction and distance. Our key idea is to reconstruct shapes by locally fitting point clouds with tori, which have closed-form signed distance functions. Tori are fitted in a feed-forward manner, using a pre-trained network to output per-point curvature and shift parameters. Importantly, our method does not require costly global optimization or spatial discretization, and is easily parallelizable. Underlying our method is a new theory that unifies signed distance with the classic reconstruction methods of winding numbers and Poisson surface reconstruction. We use our method to compute signed distance to point clouds arising from photogrammetry, meshes, 3D Gaussians, and neural implicits. Our method allows point clouds to be used directly in applications, without explicit surface reconstruction: as examples, we take offsets of point clouds, apply morphological and Boolean operations, and directly visualize offset surfaces using sphere tracing.
Adventures in Neural Rendering
In recent years, neural networks have started to find their way into many areas of rendering. While antialiasing and upscaling are probably the most well‑known uses, they’re far from the only ones—…
Mesh Outlines Without Post-Processing in Unreal Engine
Some time ago I saw a neat solution by Cory Spooner on outlining meshes using particle sprites. The concept has been done before – but it’s interesting enough to cover it regardless for Unreal Engine...
Hash Functions for GPU Rendering – Nathan Reed’s coding blog
Pixels and polygons and shaders, oh my!
Stylized GGX shading | Alexandre Lamure
A practical guide to stylized GGX shading: mixing sharp toon specular highlights with soft PBR gradients.
FromSoft Image Macro Creator
Create convincing looking image macros based on FromSoft games.
heerich.js
Tiny engine for 3D voxel scenes rendered to SVG — boolean ops, oblique/perspective cameras, zero dependencies.
Unreal Scoop: Make your own “shaded textured unlit” viewmode real quick
Hammer, king of level editors, has a view mode where the scene is unlit, but not fullbright; it’s shaded to make it easier to parse. Unreal doesn’t have that! But you can add it yourself, really easily, with no C++ or Blueprint – just a postprocess material and a line in a config file. Here’s how!
The Best Darn Grid Shader (Yet)
For as long as I’ve been writing shaders, there’s been one specific shader I’ve always tried to write…
Infinite Grid Shader
Learning to create an infinite grid procedurally using GLSL shaders. This post contains my notes, lessons and findings, and is intended for personal reference. Therefore, you might find errors, misjudgments, and other issues, which are fine by me because my intention was to learn by teaching myself. In a way, I was being my own rubber duck.
Lindenmayer Systems
Let me show you how to use Lindenmayer systems to produce beautiful images like this one: