Unreal Engine 4 Rendering Part 1: Introduction

Styled Nodes in Unreal Engine

I showcase how you can style a collection of Unreal Engine nodes

Hash Functions for GPU Rendering – Nathan Reed’s coding blog

Pixels and polygons and shaders, oh my!

Evaluating and Sampling Glinty NDFs in Constant Time

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.

Shaders

Component library for creative WebGPU effects in modern frontend frameworks. Compose interactive visuals for Vue, React, Svelte and Solid.

Vulkan Ray Tracing Tutorial KHR

A comprehensive tutorial for learning Vulkan ray tracing with practical examples.

Shadertoy

Build shaders, share them, and learn from the best community.

Unreal Scoop: Making a “Compiling Shaders…” Screen

Unreal has a reputation amoung the ill-informed for being plagued by shader compilation stutter. As an attribute of Unreal itself, this is basically made up – devs are just not always doing what they are supposed to do pre-ship to avoid this issue. I’ll elaborate, but basically, to avoid compiling shaders during gameplay, you want to do it up-front, like during an initial loading screen, which maybe says “Compiling shaders” on it, and not let the player begin until it’s done. To do that last part properly, you need a little bit of C++. I had to do this for InFlux Redux recently, so here’s mine.

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…

Visualizing GL_NV_shader_sm_builtins

Using GL_NV_shader_sm_builtins to visualize Streaming Multiprocessors and Warps

Inlay Renderer

An independent implementation of the Inlay SDUI rendering engine, deployed on Cloudflare Workers.

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.

Modern rendering culling techniques | krupitskas 🌦️

🏠🏠🏠🌲🌲🌲🏠🌲🌲🏠🌲🌲🏠🌲🏠🌲❌🏠🌲🌲🌲

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...

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.

Leveraging Rust and the GPU to render user interfaces at 120 FPS

From the Zed Blog: A deep-dive into the graphical underpinnings of GPUI, the hardware-accelerated framework that powers Zed's user interface.