Weekly on Jendrik Illner - 3D Programmer

Graphics Programming weekly - Issue 436 - April 12th, 2026

Sun, 12 Apr 2026 04:00:00 +0000

Introduction to Spherical Harmonics for Graphics Programmers

introduces spherical harmonics as an orthonormal basis for approximating functions defined on a sphere, with a focus on lighting applications
walks through the mathematical foundations with interactive in-browser examples for cubemap projection
covers practical pitfalls

wayback-archive

Real-time Neural Six-way Lightmaps

proposes a neural extension of the six-way lightmaps technique to render participating media such as smoke in real time
generates a guiding map from the camera view via ray marching with a coarse sampling step to capture scattering and silhouette, then uses a neural network to predict the corresponding six lightmaps

wayback-archive

Real-Time Neural Network Implementation for GPUs

open-source companion code for the “Real-Time Neural Network Implementation for GPUs” chapter in the GPU Zen 4 book
implements multi-layer perceptron (MLP) training and inference in DirectX 12 and HLSL
presented example learns how to reconstruct an image

wayback-archive

Introducing MiniDXNN: MLP library for DirectX 12

introduces MiniDXNN, an open-source multi-layer perceptron (MLP) inference library implemented natively in HLSL
leverages cooperative vector APIs to utilize AMD Radeon GPU matrix cores
targets performance comparable to dedicated ML frameworks
The initial release ships with optimized inference kernels and 2D image reconstruction samples

wayback-archive

Custom SRP 6.2.0 3D Color LUT

upgrades the color LUT in a Unity Custom SRP from a simulated 2D texture strip to a native 3D texture
replaces the fragment-shader-based LUT generation with a compute shader that writes directly into the 3D texture
presents how to write a debug visualizer for 3D LUTs

wayback-archive

Writing to Compressed Textures in Metal

describes a workaround for Metal’s lack of resource casting by aliasing a buffer and a compressed texture on the same Metal heap allocation, allowing compute shaders to write BC7 blocks directly
the encoder must produce blocks in the GPU’s native swizzle order within 32×32 block macro-tiles
Benchmarks shows that the approach is around 20% faster than the conventional path

wayback-archive

Specialization Constants // Vulkan For Beginners #29

introduces Vulkan specialization constants as a mechanism to set compile-time constant values in GLSL shaders at pipeline creation
explains the Vulkan API structs involved
walks through a practical example integrating specialization constants into an existing shader

Lighting | Unity Shader Code Basics 06

Implements a Phong-based URP HLSL lighting model
Covers URP shader variants for shadows and normal maps
Adds point lights and a shadow mask from dynamic lightmap UVs

Behind the Pretty Frames: PRAGMATA

in-depth frame analysis of PRAGMATA, a new Capcom IP built on RE Engine
walks through the full render pipeline, including Z-prepass, deferred G-buffer with visibility buffer, compute-based SSAO, shadow maps, deferred lighting, ray-traced reflections, strand-based hair simulation and rendering, and the post-process stack

wayback-archive

Raytracing Voxels in Teardown and Beyond

explains Teardown’s unconventional voxel renderer
rasterizes object bounding boxes and runs DDA-based traversal in the fragment shader
covers the approach to soft shadows and its limitations that motivated a next-generation rewrite
presents the Vulkan hardware raytracing successor to overcome quality limitations

The fog is lifting, volumetric rendering Enshrouded

covers distinct media types found in Enshrouded
based on sparse virtual-texture voxel with BC-compressed 16³ tiles, top-down weather fog, VFX-spawned dynamic volumes, a 2D cloud density map, and water stored as a sparse signed distance field
presents how to combine the various sources to create the effects

Profiling with PIX | Intel Software

introduces the Intel PIX metrics experience for Xe GPUs
covering how to use pipeline counters to identify bottlenecks such as excess vertex fetching and high clipper rejection in shadow passes
explains the Xe GPU architecture
walks through all major hardware stall reasons, from message FIFO full, instruction fetch, jump dependency, ALU write, and much more

Thanks to Stephen Hill for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 435 - April 5th, 2026

Sun, 05 Apr 2026 04:00:00 +0000

meshoptimizer - v1.1

announces v1.1 of meshoptimizer, introducing two major new features, meshlet compression and opacity micromap rasterization
The new method compresses meshlet topology, exploiting spatial locality, and provides an example compute shader decoder
The opacity micromap support generates hardware-ready OMM data from mesh UVs and a texture alpha channel for direct use with VK_EXT_opacity_micromap or DXR 1.2

wayback-archive

Fast and Gorgeous Erosion Filter

presents a single-pass, GPU-friendly terrain erosion filter that produces branching gullies and ridges, making it suitable for infinite or chunked terrain generation
the technique uses gradient-aligned sine wave stripes subdivided into Voronoi cells to form gullies;
Several refinements are described to preserve crisp peaks and valleys
The Shadertoy example is provided

wayback-archive

How to Color Low Poly Terrain with Gradients and Curves

explains a three-control approach to color low-poly terrain driven entirely by geometry: a slope gradient, a height gradient, and a blend curve that determines which of the two governs each elevation band
demonstrates the approach in Unity “Polaris” terrain tool

wayback-archive

Rendering arbitrary-scale emojis using the Slug algorithm

describes how to extend the Slug algorithm’s GPU implementation to render vector color emojis at arbitrary scale with no prerendered bitmaps
covers how to deal with COLRv0 (flat color) and COLRv1 (gradient)

wayback-archive

Single-image Layer Decomposition for Anime Characters

presents a framework that decomposes a single static anime illustration into a manipulatable model
discussed as a starting point for artists to eliminate manual segmentation work
uses a diffusion-based transparent layer generation model combined with a fine-tuned depth estimator

wayback-archive

[video] GPU Texture Compression Explained

interview with Ignacio Castaño covering the development of Spark, a real-time GPU-based texture encoder for block-compressed formats
explains why GPU-native formats require random per-block access and therefore cannot use entropy-coded formats like JPEG
details the challenges of encoding ASTC on mobile GPUs
discusses the main practical use cases that emerged for Spark

[video] Slang Shading Language Demo & Single-Source Graphics Pipeline Explained

GDC 2026 session showing how Slang modernizes graphics development through generics, interfaces, and first-class differentiable programming
presents a demo of Slang-compiled shaders running on current-gen console devkits
deconstructs how Slang’s intermediate representation maps to console APIs
providing a blueprint for extending the language to other systems

The Future of Path Tracing | Best Practices, Optimizations & Future Standards

covering the current state of real-time path tracing, includingShader Execution Reordering, RTX Mega Geometry, DLSS, and RTX Neural Shading
presents best practices, optimization strategies
previews techniques envisioned for next-generation path-traced visuals

Scaling Game Performance Analysis with NVIDIA Nsight

presents how NVIDIA uses Nsight in daily validation systems to analyze many game titles across a wide matrix of environments, catching performance regressions and identifying optimization opportunities at scale
walks through concrete examples of real game optimization problems
provides a deeper look at the NVIDIA hardware capabilities behind ray tracing and other RTX features

Filling a Vulkan image using only CPU-recorded commands

an April 1st experiment exploring whether a Vulkan image can be filled per-pixel using only CPU-recorded commands
achieves this by aliasing a VkBuffer and a VkImage to the same VkDeviceMemory allocation and writing through vkCmdFillBuffer

wayback-archive

demote_tracker is a commandline utility to visualize demoted graphics card memory

a small Win32 command-line tool for tracking GPU memory usage and demoted memory across all running processes on Windows
visualizes how much VRAM has been demoted to system RAM

wayback-archive

Thanks to Stephen Hill for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 434 - March 29th, 2026

Sun, 29 Mar 2026 04:00:00 +0000

Old school rendering rant - Tomb Raider

analyzes the rendering techniques used in Tomb Raider III, running on hardware without T&L or programmable shaders
covers portal-based room traversal for visibility culling, texture atlases with 256×256 palettized tiles, and distance fog to mask geometry cutoffs
describes how static lighting was baked into vertex colors, and how color-key transparency and flipbook texture animations achieved dynamic-looking effects on constrained hardware

wayback-archive

Hardware Image Compression

compares the three hardware lossy image compression formats: Apple’s Metal lossy, ARM’s AFRC, and ImgTec’s PVRIC4
benchmarks quality and throughput against Spark across R8, RG8, and RGBA8 formats

wayback-archive

[video] PS5 Pro Upgraded PSSR + Enhance Image Quality Mode Analysis - Over 20 Games Tested

Digital Foundry tests the upgraded PSSR upscaler across various games
revisits previously contentious PSSR-supported games using the new “Enhance Image Quality” dashboard mode and evaluates the improvements, remaining problems, and any regressions
discusses whether Sony should have enabled the new PSSR by default and whether it qualifies as the definitive upscaling solution on PS5 Pro

Data Inheritance

article and prototype implementation explaining how to build data inheritance, where derived data inherits from a base, and overrides are explicitly tracked per property
covers how to extend the concept from simple scalar fields to collections
discusses the associated UI challenges such as visualizing override indicators, handling removed items, and providing granular revert controls

wayback-archive

[video] Landscape Puddles - Terrain Shaders - Episode 19

new part of the Terrain Shaders series, showing how to add puddle effects to landscapes in Unreal Engine
follows on from the previous episode, which covered rain effects on terrain in Unity
demonstrates how to blend puddle wetness and reflections into a landscape material shader

[video] Better SDF texture for anime face shading in blender

tutorial on using Signed Distance Field (SDF) textures to drive shadow placement on anime-style face shading
SDF face textures encode where shadows should appear on the face relative to light direction

[video] What Is Clean Topology? Part 2: Specific Examples

follow-up to part 1 on what constitutes a clean mesh in 3D modeling
walks through specific examples of how to clean up meshes for film, games, and other use cases

Quantization from the ground up

explains how LLM quantization works, covering how floats are stored and why smaller formats (float16, bfloat16, float8, float4) can replace float32 for model weights
describes symmetric and asymmetric quantization as more effective alternatives to simple rounding

wayback-archive

Vision Transformers

explains the Vision Transformer (ViT) architecture
covers patch embeddings, learnable positional encodings, the class token, and the encoder-only classification head
walkthrough for a hands-on fine-tuning example

wayback-archive

[video] Why Boycott SIGGRAPH Asia 2026?

personal statement on why SIGGRAPH Asia 2026 should be boycotted due to Malaysia being chosen as the host country
criticizes the official SIGGRAPH for framing LGBTQ+ inclusion as a matter of cultural opinion rather than membership safety
calls on SIGGRAPH leadership to relocate the conference and to introduce a structural venue review process that consults at-risk communities

Thanks to Stephen Hill for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 433 - March 22nd, 2026

Sun, 22 Mar 2026 04:00:00 +0000

Analytic Fog Rendering With Volumetric Primitives

presents an analytic approach to rendering localized fog volumes with varying density using radial density functions bounded by geometric primitives
derives closed-form antiderivatives for each density function
linear transforms applied to the ray allow volumes to be arbitrarily scaled and rotated

wayback-archive

Procedural Pool Balls

uses 2D SDFs in a ShaderGraph shader to procedurally draw pool balls
presents how to apply the ball numbercorrectly on both the front and back of the sphere

wayback-archive

A Decade of Slug

Eric Lengyel reflects on 10 years of the Slug algorithm for GPU text rendering directly from Bézier curve data, detailing evolutionary simplifications since the 2017 JCGT paper
introduces “dynamic dilation” for antialiasing without any manually-tuned constant
announces that the Slug algorithm patent is permanently dedicated to the public domain with reference HLSL shaders—including dynamic dilation—released on GitHub under the MIT license

wayback-archive

Slug Algorithm (WebGPU)

WebGPU/WGSL port of Eric Lengyel’s Slug text rendering algorithm
implements the CPU-side pipeline that extracts Bézier curves, and partitions them into vertical and horizontal bands;
the WGSL shaders then evaluate the bands to rasterize glyphs on the GPU

wayback-archive

Parallelised Differentiable Straightest Geodesics for 3D Meshes

CVPR 2026 paper presenting a parallelised CUDA implementation of differentiable geodesics on 3D mesh surfaces
proposes two differentiation methods: an Extrinsic Proxy for fast gradient approximation and Geodesic Finite Differences for higher-accuracy
demonstrates the technique in different applications

wayback-archive

Enhancing DirectX Testing with AMD Smoldr

AMD releases Smoldr, an open-source scripting tool for running DirectX 12 compute and raytracing shaders without writing any C++
a plain-text script defines HLSL sources, buffers, root signatures, pipelines, and dispatches;
basic verifications commands allow verifying and printing output values for testing

wayback-archive

UPDATED! Configuring Vulkan Layers White Paper

White paper has been updated to reflect improvements introduced in Vulkan SDK 1.4.335
Vulkan Configurator can now export a tested layer configuration directly into all supported formats, unifying layer configuration behaviour

wayback-archive

Boost your graphics performance with the M5 and A19 GPUs

deep dive into the graphics features of Apple’s M5 and A19 GPUs targeting games and pro app workflows
covers hardware design updates including universal texture compression support and an upgraded hardware ray tracing unit
introduces new profiling tools to help developers identify and exploit performance opportunities on M5 GPUs

wayback-archive

AMD GPU-Initiated I/O

explores making an AMD GPU control an NVMe device directly, bypassing the CPU for I/O submission and data placement into VRAM
discussins and presents the kernel-level paths to allow access to the required pages from DMA and GPU shader access
documents the cache coherency challenges encountered

wayback-archive

[video] Can Fiddling With Meshes Improve Game’s Performance?

overview of meshoptimizer, covering the full offline mesh processing pipeline
covers mesh shader meshlet generation, mesh simplification for LOD hierarchies, specialized mesh compression
additionally talks about cluster_load.h, a component for hierarchical continuous LOD

[video] Rain Effects On Terrain - Terrain Shaders - Episode 18

video showing how to add rain effects (puddles, raindrops, ripples) to a Unity terrain shader
adapts the built-in rain floor subgraph for the needs of the trrain
improves puddle by modulating the puddle mask with terrain height data

[video] Hands-On With DLSS 5: Our First Look At Nvidia's Next-Gen Photo-Realistic Lighting

Digital Foundry’s first hands-on look at DLSS 5
demos across Resident Evil Re:Verse, Starfield, Oblivion Remastered, and Assassin’s Creed Shadows
currently runs on dual RTX 5090 GPUs in demo form; goal is reduce hardware requirements

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 432 - March 15th, 2026

Sun, 15 Mar 2026 04:00:00 +0000

GDC 2026: DirectX is Bringing Console-Level Developer Tools to Windows

Microsoft’s official GDC 2026 announcement summary covering the DirectX tooling updates
introduces DirectX Dump Files (.dxdmp) that capture hardware state, driver/OS state, and custom game data on GPU crash
also announces Shader Explorer in PIX for offline cross-GPU static shader analysis, GPU hardware counters in PIX System Monitor, a new GPU capture file format, and the future goal of live on hardware shader debugging

wayback-archive

AMD and Microsoft partner on DirectX ML, DirectStorage, and developer tools at GDC 2026

AMD’s overview of their GDC 2026 collaboration with Microsoft
details AMD’s support for the new DirectX ML features: DX Linear Algebra accessing WMMA cores on RDNA hardware directly from HLSL, and the DirectX Compute Graph Compiler (CGC)
lists hardware support for the newly released features

wayback-archive

DirectX 12 News from GDC 2026 - My Comments

author summaries and comments on Microsoft’s D3D12 announcements from GDC 2026
covers five areas: GPU debugging tools, ML advancements, Advanced Shader Delivery, DirectStorage 1.4, and DXR 2.0

wayback-archive

Shading Languages Symposium 2026 Trip Report

Keith Stockdale shares his experience at the first Shading Languages Symposium
recurring topics across talks included: shader debugging pain points and the lack of printf in HLSL, testing frameworks for shader code, shareable/modular shader libraries
notable discussions included whether shading languages should converge with C++

wayback-archive

GTC 2026

NVIDIA GTC is starting March 16 attend virtually for free.
Presenting the latest breakthroughs in generative AI, accelerated computing, simulation technology, and more.
My top sessions: OpenUSD Crash Course (DLIW82272), Fundamentals of GPU-Accelerated Workflows (DLIW82265) and more
Win an RTX Pro 6000 GPU and see my full session recommendations here

wayback-archive

Nanite + Reyes

Brian Karis details how Reyes-style displacement mapping tessellation was integrated into Nanite
explains the new pipeline stages and how they fit into the existing structure
discusses key implementation challenges, including bounding displaced patches for culling, computing texture UV derivatives, and vectorizing scalar-heavy per-patch work across multiple patches per wave

wayback-archive

Variable sized work

discusses the problem of efficiently handling variable-sized work
introduces a wave-local work distribution technique where the producer data stays in registers and consumers use WaveReadLaneAt to read it, avoiding costly round-trips to global memory queues
applies this primitive in three places within the tessellation pipeline

wayback-archive

GPU Tracing Participating Media

Presents a well-commented HLSL implementation of participating media concepts from Physically Based Rendering (PBRT 4ed), covering homogeneous and heterogeneous volumes with absorption, scattering, and emission using delta/null tracking
shares render results showing volumetric clouds, colored cubes, and emissive volumes
documents practical implementation pitfalls

wayback-archive

A Recursive Algorithm to Render Signed Distance Fields

presents a recursive divide-and-conquer algorithm for rendering SDFs on CPU that advances all rays in a view frustum quad simultaneously, recursively subdividing into four quads only when the shared march step becomes too small
extends the algorithm with a patch-level bilinear interpolation shading mode
demonstrates 3–4x fewer samples per pixel versus standard raymarching

wayback-archive

SDF game engine? | Mike Turitzin

Mike Turitzin discusses his journey back into graphics programming and the motivation behind building an SDF-based game engine
explains how the engine uses signed distance fields with sphere tracing for rendering and WebGPU as the graphics API
shares programming philosophies around minimalism, investing deeply in chosen tools, and keeping game development the primary focus rather than falling into the engine-development trap

Texel Splatting

presents a technique for perspective-stable 3D pixel art by rendering scene geometry into a cubemap from a grid-snapped fixed probe origin, then splatting each visible cubemap texel to screen as a world-space quad
cubemap indexing provides rotation invariance, while snapping the probe origin to a world grid provides translation invariance

wayback-archive

Adobe's reference implementation of the OpenPBR BSDF

Adobe open-sources their production OpenPBR 1.0 BSDF implementation extracted from their Eclair renderer under Apache 2.0
single header design targeting C++, GLSL, CUDA, MSL, and Slang via a thin macro interop layer
LUTs support two modes: self-contained constant arrays (default, no texture bindings needed) or GPU texture sampling (smaller shader binary, hardware filtering)

wayback-archive

Qaws - C11 library for creating, evaluating, sampling, traversing, and inspecting parametric curves and surfaces in 2D and 3D

dependency-free C11 library covering 13 curve families (Bezier, Hermite, Catmull-Rom, B-Spline, NURBS, clothoid, subdivision, and more) and 5 surface types (Bezier patch, B-Spline, NURBS, swept, ruled) with a uniform create/evaluate/sample/traverse/inspect API
evaluation kernels are header-only and compile unchanged across four backends (C, HLSL, GLSL, and Halide)

wayback-archive

Even Faster asin() Was Staring Right At Me

The article presents a fast approximation to asin
follow-up to a previous article on the same topic
benchmarks across Intel i7, AMD Ryzen 9, and Apple M4 to show the effects of micro optimizations

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 431 - March 8th, 2026

Sun, 08 Mar 2026 04:00:00 +0000

Physically based rendering from first principles

The article builds up PBR theory from the physics of light
covers electromagnetic radiation, Fresnel equations, Snell’s law, and the microfacet model, distinguishing metals from dielectrics
derives the Cook-Torrance BRDF step by step, including the GGX Normal Distribution Function, Schlick-GGX Geometric Function, and Fresnel-Schlick approximation

wayback-archive

Fog rendering

derives fog color lerp from the volumetric rendering equation
extends the derivation to exponential height fog by computing optical depth for an extinction coefficient

wayback-archive

Improving Direct Lighting Material Occlusion - Part 2

presents a VNDF-based micro-shadowing approach that operates at the microfacet level rather than the geometric surface level
introduces a LUT-based real-time approximation parameterized by Visibility, Roughness, as a practical alternative to per-light VNDF sampling

Vulkan memory barriers and image layouts explained

explains pipeline barriers as a combination of three orthogonal aspects: execution control, cache control, and image layout transitions
details how image layouts abstract GPU-specific compression schemes such as fast clears, delta color compression (DCC), and hierarchical depth (Hi-Z)
demonstrates that applications rarely need to track image layouts at runtime; instead, each image has a natural default layout derived from its purpose, requiring only temporary transitions to other layouts

wayback-archive

GTC 2026

NVIDIA GTC is starting March 16 attend virtually for free.
Presenting the latest breakthroughs in generative AI, accelerated computing, simulation technology, and more.
My top sessions: OpenUSD Crash Course (DLIW82272), Fundamentals of GPU-Accelerated Workflows (DLIW82265) and more
Win an RTX Pro 6000 GPU and see my full session recommendations here

wayback-archive

Per Texel Lighting

describes a compute shader implementation that calculates lighting per-texel
uses barycentric coordinates to map every texel from UV space to world space
supports hard shadows and proximity-based dynamic blurred shadows via ray-triangle intersection tests, combining baked and real-time lighting passes into a final texture

wayback-archive

Dispatching Hundreds of Thousands of Compute Tasks

describes a Vulkan voxel spring-mass simulation for GPU-accelerated audio generation that requires a massive amount of dispatches
resolves the command buffer recording bottleneck by recording a short reusable block, dispatches with VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, and submits it multiple times

wayback-archive

Introducing Eyot - A programming language where the GPU is just another thread

introduces Eyot, a programming language that aims to make offloading work to the GPU simple
compiled for both CPU and GPU with the runtime automatically handling memory allocation, kernel compilation, and scheduling

wayback-archive

Moving Scaling and Rotating UVs in Godot Shaders | Tutorial

beginner-friendly tutorial covering UV translation, scaling, and rotation inside Godot
shows the effects of scaling UV coordinates
demonstrates anchoring transformations to an arbitrary pivot

wayback-archive

[video] Visibility Buffer and Deferred Rendering in DOOM: The Dark Ages

outlines idTech8’s new geometry pipeline for DOOM: The Dark Ages
using a triangle visibility buffer approach
evaluates multiple shadingdispatch strategies, and shares performance guidelines
presents how the tiled deferred lighting algorithm supports software VRS

[video] The wedge product | Geometric algebra episode 6

introduces the wedge product as the fundamental building block of geometric algebra
showing how it constructs basis elements from which all multivectors are formed
explains the three key properties of the wedge product and shows how they represent linear subspaces

Thanks to Matt Pharr for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 430 - March 1st, 2026

Sun, 01 Mar 2026 04:00:00 +0000

Announcing Shader Model 6.9 Retail and New D3D12 Improvements

announces the official release of Shader Model 6.9, introducing Long Vector support, 16-bit float specials, and making 16-bit/64-bit shader ops and wave ops required features
brings DXR 1.2 features (Opacity Micromaps and Shader Execution Reordering) out of preview
introduces D3D12 improvements, including revised resource view creation APIs and CPU timeline query resolves
releases preview features, including Fence Barriers for fine-grained GPU synchronization

wayback-archive

D3D12 Opacity Micromaps

introduces Opacity Micromaps (OMMs) as part of DXR Tier 1.2 to reduce overhead from redundant any-hit shader invocations for alpha-tested geometry
encodes opacity information using masks on uniformly subdivided meshes laid out on a barycentric grid
stores OMMs separately from bottom-level acceleration structures, allowing reuse across multiple BLASes

wayback-archive

Fence Barriers: Fine-Grained GPU Synchronization in Direct3D 12

introduces Fence Barriers Tier-1 in preview
provides SignalBarrier and WaitBarrier operations for command-list scoped fences, offering a cleaner alternative to split barriers
enables cross-queue synchronization through SignalBarrier with traditional queue-level waits
next iterations Tier-2 will add full cross-queue WaitBarrier support

wayback-archive

Real-time Rendering with a Neural Irradiance Volume

presents Neural Irradiance Volume (NIV), a technique that replaces traditional probe grids with a compact neural model for pre-computing diffuse global illumination
demonstrates quality improvement over probe-based methods at equivalent memory budgets while working within strict real-time constraints without requiring ray tracing or denoising

wayback-archive

Shipping Neural Texture Compression in Assassin’s Creed Mirage

describes the implementation of neural texture compression that uses a latent representation shared across all material channels
explicitly models BC compression during training to ensure the network is optimized against the exact signal sampled by the renderer at runtime
achieves approximately 30% memory reduction

wayback-archive

GTC 2026

NVIDIA GTC is starting March 16 – attend virtually for free.
Presenting the latest breakthroughs in generative AI, accelerated computing, simulation technology, and more.
My top sessions: OpenUSD Crash Course (DLIW82272), Fundamentals of GPU-Accelerated Workflows (DLIW82265) and more
Win an RTX Pro 6000 GPU and see my full session recommendations here

RenderDoc - Version v1.43

introduces a new custom annotation system that enables rich context information on a per-event or per-object basis
adds a shader viewer panel showing where debug symbols were loaded from and the paths searched, with support for embedding symbols within captures

wayback-archive

How to Use Vulkan Debug Printf

explains how to use Vulkan’s Debug Printf feature using VK_KHR_shader_non_semantic_info
covers implementation in GLSL (debugPrintfEXT), HLSL/Slang (standard printf), and direct SPIR-V instructions, with output viewable in RenderDoc 1.14+ or through Validation Layers
describes format string restrictions, including limited specifiers, vector support, and limitations

wayback-archive

New Vulkan Game Engine Tutorial: Build Your Own Production-Ready Rendering Engine

presents a new tutorial that builds on the Core Vulkan Tutorial to guide developers through more advanced concepts
addresses aspects such as debugging, profiling, CI/CD, and packaging
additionally covers dynamic rendering, timeline semaphores, and engine design aspects

wayback-archive

Intel will be at GDC in San Francisco (9–13 March), and we’re hosting a series of public technical talks for game developers at the AMA Center in the Marriott Marquis — just a short walk from the main conference.

Each session runs about 30–40 minutes and is designed to be interactive and informal. Expect real technical deep dives, live discussion, and plenty of time for questions — jump in, challenge us, share your experience. We’re aiming for useful conversations, not slide marathons.

If you’re around, we’d love to see you there! Click the link and register for the session(s) you’re interested in.

[video] Vulkanised 2026: GPU-Driven Rendering in the Quest 2 and 3

presents implementation strategies for GPU-driven rendering pipelines optimized for Meta Quest 2 and Quest 3 mobile VR hardware
discusses techniques for reducing CPU overhead and maximizing GPU utilization within the power and thermal constraints
covers Vulkan API features that enable efficient indirect drawing and compute-heavy rendering approaches

[video] Shading Languages Symposium 2026: Gigi - A Rapid Graphics R&D Platform

introduces Gigi as a rapid prototyping platform for graphics rendering research and development, designed to accelerate experimentation workflows
demonstrates approaches for streamlining graphics programming iteration cycles and enabling faster testing of rendering algorithms and shader techniques

[video] Terrain Advanced Auto Material - Terrain Shaders - Episode 16

demonstrates creating an advanced terrain auto material combining angle blend, height blending, and altitude blending for realistic surface variation
provides implementation patterns applicable to both Unreal Engine material graphs and Unity shader graphs

Thanks to Graham Wihlidal for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 429 - February 22nd, 2026

Sun, 22 Feb 2026 04:00:00 +0000

The Art of Render Graphs

comprehensive guide to implementing a render graph system using Vulkan
explains the complete pipeline, including pass dependency recording, resource lifetime computation, graph construction using topological sorting, and automatic pass culling
covers advanced features like texture aliasing within frames, multi-threaded command buffer recording, and automatic barrier generation between passes

wayback-archive

Vulkanised 2026

Vulkanised 2026 talk video and slices have been released
presentations covering topics from machine learning, performance, system integration, and more
additionally contains talks about developers using the API for various requirements across various platforms

wayback-archive

Vulkanised 2026: Vulkan Now and Then (for Hobbyists)

an accessible overview aimed at hobbyists: history and practical advice for getting started with Vulkan
highlights helper libraries and learning resources recommended for newcomers

Runtime Mipmap Generation

discusses implementing runtime mipmap generation on the GPU
presents techniques for correct linear-space filtering using sRGB texture views and high-quality low-pass filters
explains alpha-weighted filtering to prevent color bleeding, as well as coverage preservation techniques to maintain alpha-tested geometry visibility

wayback-archive

IBL Optimization Study III: Shared memory and Latency Hiding

explores optimization techniques for GGX prefiltering in image-based lighting, targeting low-end hardware
details how using group shared memory to compute Hammersley sequences and GGX samples to reduce per-thread work
achieves significant performance improvements through partial loop unrolling, tangent-space math, and precomputing LODs

wayback-archive

Jobs

Graphics & Tools Programmer
Remote Work

Marmoset is looking for skilled programmers to join our team building Toolbag, our industry-leading real-time rendering and authoring application.

You’ll work with artists and developers to design, implement, and optimize rendering, baking, and texture authoring features in Toolbag. This role is ideal for someone who loves visual computing and creating powerful tools for artists. If you’re passionate about real-time graphics and love building the tools that artists rely on, we’d love to hear from you.

Would you like to advertise your job openings here too? More information

FragCoord

GLSL shader editor designed for efficient shader development (similar to Shader Toy)
features a built-in inspector to visualize variables and functions directly in the viewport
includes a snippet library for common operations, custom uniform support, and a tuner for adjusting numerical values with sliders

HIP Threads: GPU power for teams without GPU experts

introduces HIP Threads, a C++ concurrency library that enables AMD GPU acceleration using familiar CPU threading patterns
presents how to transition a simple example to execute on the GPU

wayback-archive

Adventures in Neural Rendering part 2: Cooperative vectors

explores using DirectX Cooperative Vectors to access Tensor cores for neural network inference
explains how matrix-multiply-accumulate operations on Tensor cores provide significant speedups for MLP evaluation compared to compute shaders
demonstrates massive speedup, especially on large networks

wayback-archive

Real-time Rendering with a Neural Irradiance Volume

presents Neural Irradiance Volume (NIV), a neural-based technique for real-time rendering of diffuse global illumination
uses neural compression to create an adaptive representation of irradiance

wayback-archive

TL;DR: An efficient and research-friendly Gaussian Splatting framework

presents Faster-GS, an optimized 3D Gaussian Splatting framework that consolidates strategies from prior research
investigates underexplored aspects, including numerical stability, Gaussian truncation, and gradient approximation

wayback-archive

Texel Splatting | True 3D Pixel Art

demonstrates “texel splatting”: rendering 3D-looking pixel art by projecting and blending texels in 3D space
shows the visual effect of the various stages of the implementation, showing issues encountered along the way

How to Not be Scared of SPIR-V

Introduction to SPIR-V that explains its role as a portable shader/intermediate representation for Vulkan and other APIs
provides an explanation of the SPIR-V concepts and helps to understand them
shows practical examples via reading and explaining the disassembly

wayback-archive

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 428 - February 15th, 2026

Sun, 15 Feb 2026 04:00:00 +0000

Khronos at 25: Shaping Visual Computing with Open Standards

blog post that looks back at Khronos Group’s 25-year history of enabling graphics programming across platforms
traces the evolution from OpenGL and OpenGL ES through WebGL, Vulkan, and OpenXR to modern standards like Slang for neural rendering
closes with a look at the next years of collaboration

wayback-archive

Shades of Halftone

comprehensive walkthrough of implementing halftone effects as shaders from basic circular dot grids to advanced variants
explores multichannel halftoning with RGB and CMYK color separation
presents techniques for breaking grid constraints, enabling surface tension effects
additionally shows how to integrate interactivity

wayback-archive

[video] niagara: Descriptor heaps

recording of a live stream showing a walkthrough on how to update a Vulkan app to use the new Descriptor Heaps extension
showing the necessary definitions in the spec and how to integrate it into an application

[video] The Compute Shader // Vulkan For Beginners #28

tutorial on using the Vulkan compute‑shader pipeline to render a Shadertoy‑style by integrating compute work into the application
walk-through covers all the required pieces of the API and how they interact
full source code is available

Adventures in Neural Rendering

explores using small multilayer perceptrons (MLPs) to encode graphics data like radiance, irradiance, depth, and BRDF information
compares MLP-based encoding against traditional methods like Spherical Harmonics
discusses trade-offs in storage size and quality, as well as implementation challenges

wayback-archive

Learnings from creating a GUI library

documents insights from building an immediate-mode GUI library
covering interactions and layout logic as well as rendering constraints
presents a tile-based SDF-based renderer to dispatch specialized shaders for improved occupancy

wayback-archive

An Updated Sponza glTF

presents an updated Sponza glTF model with cleaned-up uncompressed PNG textures
compares AVIF texture compression with runtime GPU compression via Spark against precompressed KTX formats
demonstrates memory and quality comparisons

wayback-archive

Standardizing HLSL

announces the formation of a Ecma Technical Committee to standardize HLSL as a cross-platform shader language
traces HLSL’s evolution from DirectX 9, DXC, Clang integration, and the importance of Google’s SPIRV code generation contributions
commits to public development on GitHub with conformance test suite

wayback-archive

State of HLSL: February 2026

details progress on Clang HLSL implementation, including improved root signature diagnostics
explains the rationale behind standardizing HLSL through Ecma TC 57 to address cross-platform shader build pipeline complexity and quality issues
announces new features to combine Cooperative Vector and Wave Matrix capabilities for efficient neural network evaluation in shaders

wayback-archive

Metal Single Pass Downsampler (SPD)

implements AMD’s FidelityFX Single Pass Downsampler for Apple Metal API, generating depth pyramid mipmaps in one compute pass
explains threadgroup organization with 16×16 threads processing 64×64 pixels using threadgroup memory to avoid device memory round-trips

wayback-archive

Forget Superresolution, Sample Adaptively (when Path Tracing)

presents an adaptive sampling and denoising pipeline designed for less than one sample per pixel path tracing systems
introduces stochastic sample placement formulation enabling gradient estimation
demonstrates consistent improvements over uniform sparse sampling, particularly in reconstructing specular highlights and shadow boundaries using tonemapping-aware training

wayback-archive

How Michael Abrash doubled Quake framerate

analyzes Michael Abrash’s hand-crafted x86 assembly optimizations in Quake’s software renderer
details key techniques including FPU pipeline parallelization, hiding multiplication latency, self-modifying code, and overlapping FDIV with integer pipelines

wayback-archive

Fitting Code Driven Displacement Revisited

derives mathematical equations for estimating stopping/starting times and distances from critical spring damper character movement systems
uses Lambert W function (product logarithm) to solve for stopping times from spring parameters
presents methods to fit spring half-life parameters from measured animation data, including “true half-life” definition based on exact halfway-point timing

wayback-archive

Thanks to Aras Pranckevicius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 427 - February 8th, 2026

Sun, 08 Feb 2026 04:00:00 +0000

The Road to Substance Modeler: VR Roots, Desktop Reinvention

details the development journey of Adobe’s Substance Modeler from its origins as Oculus Medium to a professional desktop sculpting tool
describes the sculpting engine’s voxel-based SDF architecture with marching cubes tessellation and the rendering engine’s COW-based deduplication for handling billions of polygons
discusses the challenges of supporting both VR and desktop workflows

wayback-archive

[video] Terrain Altitude Blending - Terrain Shaders - Episode 15

tutorial showing how to blend between two terrain layers based on height
covers practical remapping and smoothing to avoid hard transitions
part of a longer series of terrain shading

Simplifying Vulkan One Subsystem at a Time

introduces the Khronos Working Group’s new strategy to combat API complexity through complete subsystem replacements
presents VK_EXT_descriptor_heap as the first implementation of this approach, fully replacing the descriptor set subsystem with a simpler memory-based model where descriptors are just data
emphasizes broad industry collaboration across the working group and invites feedback before finalizing as a KHR extension

wayback-archive

[video] How to optimize (almost) anything

concise guide to investigating performance problems: start with profiling and measurement to find real hotspots rather than guessing
surveys practical techniques (data-oriented layouts, instancing, background workers, frame spreading, cache-friendly changes) and gives small, actionable examples
emphasizes pragmatic trade-offs, verifiable wins and beware optimizations that appear to help for the wrong reasons

Khronos Announces glTF Gaussian Splatting Extension

release candidate for KHR_gaussian_splatting to store 3D Gaussian splats in glTF
describes Gaussian splatting (sparse, optimized 3D points with position/scale/orientation/color/opacity) as a fast, scalable format suited to geospatial capture, digital twins and photoreal 3D capture workflows
designed to be extensible and compression-friendly

wayback-archive

SIMD Started It, SIMT Improved It

traces the evolution from SIMD to SIMT execution models, starting with NVIDIA’s G80 architecture in 2006
explains how SIMT preserves SIMD efficiency while managing divergent control flow through hardware-controlled serialization and masking of inactive threads within warps
shows how AMD, Intel, and newer GPU vendors adopted similar thread-based execution models
modern APIs like Vulkan, DirectX 12, and Metal provide subgroup abstractions that map to underlying SIMT hardware

wayback-archive

Nanite Tessellation

introduces Nanite Tessellation as a system for dynamically tessellating and displacing meshes using shader graphs, extending Nanite’s virtualized geometry capabilities
discusses the motivation for geometry amplification including data compression advantages of displacement maps and improved artist workflows for procedural content
explains how displacement is particularly valuable for film-style workflows as well as games requiring scalability across platforms

wayback-archive

It's Not About the API - Fast, Flexible, and Simple Rendering in Vulkan

presents a talk challenging the perception that Vulkan is overly complex and not worth engaging with as an indie developer
argues that proper GPU abstraction design matters more than the choice of API
demonstrates how to build fast, flexible, and simple rendering systems in Vulkan

wayback-archive

Normal Map Compression Revisited

examines practical aspects of normal map compression, including the evolution from DXT5/BC3 swizzled encodings to BC5’s capabilities
discusses Z reconstruction methods and tangent space discontinuities
presenting solutions for UNORM encoding offsets to represent flat normals at UV seams properly
explains the tradeoffs between UNORM and SNORM formats

wayback-archive

Same Image, Different Score?

investigates how decoder implementations and chroma upsampling post-processing affect perceived image quality beyond encoder efficiency alone
tests various decoders, including FFmpeg, jpegli, ImageMagick, dwebp, and dav1d, with different chroma handling strategies
demonstrates that filtered FFmpeg decoding with Lanczos scaling and accurate chroma interpolation achieves efficiency improvements compared to baseline approaches

wayback-archive

Replicating the Shadowglass 3D pixel-art technique

analyzes and replicates the Shadowglass technique for achieving stable first-person pixel art without shimmer by rendering to low-resolution cubemaps from fixed positions
implements reprojection using cubemap depth buffers to raymarch and offset samples based on camera movement, creating parallax effects while maintaining pixel stability
describes optimizations including different cubemaps for varying distances and resolutions
presents how to handle transitions between the cubemaps

wayback-archive

Ray Tracing using HIP

AMD technical report introducing ray tracing fundamentals and a HIP-based GPU implementation
highlights Orochi for runtime HIP/CUDA backend switching
explains core algorithms (ray-triangle intersection, BVH construction and traversal, ambient occlusion, path tracing and next-event estimation) and performance considerations
provides code examples

wayback-archive

Thanks to Nathan Reed for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 426 - February 1st, 2026

Sun, 01 Feb 2026 04:00:00 +0000

Inside Mesa 26.0's RADV RT improvements

details improvements to RADV’s ray tracing pipeline compilation in Mesa 26.0, introducing function calls to the compiler stack
presents how separately compiling any-hit and intersection shaders instead of inlining them into megashaders dramatically reduces compilation times
Additionally, it can resolve pipeline stutter in Unreal Engine games

wayback-archive

[video] Complex numbers are multivectors | Geometric algebra episode 4

explains complex numbers from a geometric algebra perspective
demonstrates key properties with an example-driven lecture

[video] Simple Terrain Auto Material - Terrain Shaders - Episode 14

tutorial showing a simple auto material that layers terrain materials based on slope angle, part of an ongoing Terrain Shaders series
covers implementation details and references earlier episodes for implementation details

[video] SIGGRAPH Thesis Fastforward 2026

SIGGRAPH’s Thesis Fast Forward, where Ph.D. students present research pitches
includes a range of topics such as Monte Carlo PDE solvers, robust winding-number/SDF algorithms, point-cloud reconstruction, and more

[video] Texel Density Explained

practical tutorial on texel density: what it is, how to choose appropriate densities for different player POVs, and set targets
presents how to measure real-world references, visualizing texel density in UE5
additionally presents a Maya texturing workflow with recommendations and scale references

Gyms, Zoos, and Museums: Your documentation should be in-game

presents a workflow design approach for maintaining game documentation spatially within the game engine itself
demonstrates how in-game documentation avoids the common problem of external documentation becoming outdated, enabling developers to instantly verify metrics, test systems, and debug assets without searching through external documents
additionally covers techniques for automated testing and the generation of these documentation levels

wayback-archive

Vulkan Ecosystem and SDK Survey - February 2026

annual survey looking for feedback from Vulkan developers to improve the SDK and ecosystem
asks about developer role and experience, target platforms, SDK usage, and other ecosystem pain points to guide future work and priorities
closes Feb 25, 2026

wayback-archive

Surfel-based global illumination on the web

implements a complete surfel-based global illumination pipeline in WebGPU, including surfelization, spatial acceleration structures, ray tracing, and temporal filtering
employs advanced techniques such as surfel-guided light sampling to reduce noise, multi-scale mean estimators for temporal stability, and radial depth atlases to prevent light leaking through thin geometry

wayback-archive

The State of Vulkan on Apple – Jan. 2026

provides an updated overview of Vulkan support on Apple platforms through layered implementations on Metal, comparing MoltenVK and the newer fully conformant KosmicKrisp
details the structure for packaging Vulkan applications on macOS and iOS, including proper placement of the Vulkan loaders

wayback-archive

Choosing Texture Formats for WebGPU applications

compares texture format options for WebGPU applications, weighing traditional image formats (WebP, AVIF), GPU block-compressed formats (BC7, ASTC), and universal formats (Basis Universal)
introduces spark.js as a solution for real-time GPU transcoding
This allows developers to ship efficient compressed web formats while transcoding to block-compressed GPU textures at runtime

Thanks to Nathan Reed for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

wayback-archive

Graphics Programming weekly - Issue 425 - January 25th, 2026

Sun, 25 Jan 2026 04:00:00 +0000

Vulkan Introduces Roadmap 2026 and New Descriptor Heap Extension

presents the Vulkan Roadmap 2026 milestone, which requires features such as variable-rate shading, shader clock queries, and higher descriptor limits
announces the VK_EXT_descriptor_heap extension, which exposes direct access to descriptor memory while retaining compatibility with existing descriptor sets

wayback-archive

Dithering Series - Part 2

explains ordered dithering using threshold maps (Bayer matrices) to convert grayscale images into black-and-white patterns
compares threshold-map families (Bayer, cluster-dot, and void-and-cluster/blue-noise) and their characteristic visual textures
shows how matrix size affects smoothness and previews the next part on error-diffusion dithering

wayback-archive

Reflective materials in Block Game

presents a system for adding reflections in the Block Game by rendering a back-facing view and applying it via spherized matcaps
uses reflected rays in view space instead of surface normals to correctly sample the environment map
implements stochastic blue noise blur for roughness effects and discusses limitations

wayback-archive

[video] Terrain Texture Node Parameters - Terrain Shaders - Episode 13

demonstrates using the Terrain Texture Node in Unity’s Shader Graph to import terrain-system parameters for material layer settings
shows how to adjust layer properties (color tint, opacity, etc.) and notes practical Inspector/HDRP quirks

[video] How To Use Marching Cubes Practically In Games [DeepDive][Part 1]

covers practical challenges of using Marching Cubes at scale (performance, mesh transitions, LOD) in large games
discusses integration strategies (e.g., Transvoxel, streaming meshes) and common pitfalls for scalability
includes demos, time-coded chapters, and links to implementation resources for further reading

[video] Particle Collision // Physics For Game Dev #2

presents sphere-based particle collision detection and response, with practical code examples and a demo
explains momentum, kinetic energy, collision types, and coefficient of restitution, including a 1D→3D generalization

Thanks to Nathan Reed for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 424 - January 18th, 2026

Sun, 18 Jan 2026 04:00:00 +0000

Software occlusion culling in Block Game

presents a CPU-based software occlusion culling system for voxel rendering
uses hierarchical subchunk levels (8x8x8 down to 1x1x1 blocks) to efficiently render occluders at varying distances
presenting optimization steps

wayback-archive

ASCII characters are not pixels: a deep dive into ASCII rendering

explores shape-based ASCII rendering using 6-dimensional sampling vectors to capture character geometry
introduces directional and global contrast enhancement techniques to sharpen edges between color boundaries
implements GPU-accelerated sampling and k-d tree lookups with caching

wayback-archive

Optimizing spatiotemporal variance-guided filtering for modern GPU architectures

presents memory access optimizations for the à-trous wavelet transform used in SVGF denoising
achieves 1.3-2.5x performance improvement by optimizing for modern GPU cache hierarchies
maintains filtering quality while reducing execution time without imposing filter configuration limitations

wayback-archive

High-Level Vulkan RHI

introduces VRHI, an immediate-mode Vulkan RHI with DX11/DX9-style API design
includes transient staging buffers, cached descriptor sets/PSOs, and threaded backend support
described as AI-generated educational material intended to inspire better RHI implementations

wayback-archive

bgfx WebGPU backend, second take!

documents the reimplementation of bgfx’s WebGPU backend using Tint for SPIR-V to WGSL shader translation
critiques WebGPU’s design choices (versioning chaos, texture format tiers, structure chaining) while praising simplified buffer/texture management
discusses Dawn/Tint bugs encountered and provides build instructions for native WebGPU development

wayback-archive

Pico GPU

virtual GPU designed for learning and experimenting with shaders in a constrained 300KB memory environment
supports 640x480 rendering at 60 FPS with vertex/fragment buffers, render targets, and GPU-based sound synthesis
includes save/load functionality as PNG screenshots containing all application data for easy sharing

wayback-archive

Mastering GFXReconstruct: Part 4

explains the structure and contents of .gfxr capture files for Vulkan, Direct3D, and OpenXR applications
details what gets captured (API calls, memory snapshots, pipeline state) and achieving replay across platforms
discusses portability considerations and additional tools that are using the format

wayback-archive

[video] Learn to Read + Edit HLSL in 40 min

beginner-friendly HLSL tutorial that builds a custom shader from scratch
covers shader structure, properties & variables, vertex vs fragment shaders, interpolators, vertex streams, and writing/animating effects

[video] Adding Terrain Detail Meshes - Terrain Shaders - Episode 12

demonstrates using built-in tools in Unreal and Unity to add foliage and detail meshes to terrain and landscapes
discusses practical workflows (painting vs procedural placement), performance trade-offs (instancing vs SRP batching) and LOD considerations for large scenes
part of a Terrain Shaders playlist with step-by-step demos and recommended resources for terrain detail pipelines

Thanks to Nathan Reed for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 423 - January 11th, 2026

Sun, 11 Jan 2026 04:00:00 +0000

Thoughts on No Graphics API

discusses Sebastian Aaltonen’s “No Graphics API” article
examines which graphics-specific functions might be stripped and the implications for multi-device/multi-process setups
highlights practical concerns (write-combining memory pitfalls, deadlock avoidance, and 32-bit compatibility)

wayback-archive

Shader To Human

introduces Shader2Human, a lightweight HLSL/GLSL library that exposes debugging tools directly from shaders
provides macros and helpers to make shader diagnostics and rapid iteration easier without heavy capture tooling
slides walk through usage patterns and examples for faster shader development

wayback-archive

GPU Memory Fundamentals

tutorial on GPU memory concepts, covers movement between VRAM and compute units, and the role of memory speed, interface width and bandwidth
explains memory-bound vs compute-bound operations via arithmetic intensity and practical tinygrad benchmarks, with concrete optimization guidelines
includes hands-on examples and timing tips for accurate GPU benchmarking and optimization

wayback-archive

Practically Utilizing Neural Networks in CPU-based Production Rendering

demonstrates how lightweight neural networks can be integrated into CPU-based production path tracers to improve memory, speed, and image quality under low-latency constraints
discusses practical inference considerations on CPU and the trade-offs when bringing ML into offline rendering pipelines

wayback-archive

Sample Decorrelation in BRDF Preconvolution for Image Based Lighting

investigates a seam artifact in HDRP’s LD preconvolution caused by reusing identical sample sequences per pixel combined with local-frame singularities at cube-face boundaries
suggests practical fixes and recommends decorrelation as a pragmatic patch

wayback-archive

Efficiently sorting gigabytes: the Deferred Merge Sort

presents a low-memory approach for globally sorting mostly-ordered event streams
leverages data patterns (nearly sorted streams, local disorder) to prefetch and hide I/O, making global sorting cheaper
discusses comparisons to k-way lazy merge and proposes a hybrid JIT-sort fallback

wayback-archive

Graphics Programming Conference 2025 - slides released

GPC 2025 archive with session descriptions and slides from a wide range of real-time graphics talks
inluding Shader2Human (shader debugging), Blender Cycles architecture, real-time path tracing, neural shading, profiling & platform optimization talks

wayback-archive

[video] I'm making a game engine based on dynamic signed distance fields (SDFs)

showcases an SDF-based engine for high-fidelity, non-destructive world edits
covers architecture & optimizations:
discusses ray-marching performance issues, physics/collision integration, terrain as SDF and practical trade-offs versus triangle meshes

Indirect Rendering // Vulkan For Beginners #27

practical tutorial on implementing indirect rendering in Vulkan, covering vertex/index/uniform buffer offsets, indirect buffers, and vkCmdDrawIndirect
demonstrates a new pipeline class and shows how to enable indirect rendering

[video] Coding Adventure: Analyzing Audio

walkthrough of programmatic audio analysis: techniques for computing FFTs, spectrograms and extracting features from audio signals
includes code examples and visualizations to illustrate frequency vs time behaviour and practical tips for real-time analysis

Thanks to Eric Haines for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 422 - January 4th, 2026

Sun, 04 Jan 2026 04:00:00 +0000

OpenPBR: Novel Features and Implementation Details

companion document to the OpenPBR specification providing deeper implementation guidance for the standardized uber-shader
covers slab-based layering, statistical mixing, and microfacet theory with mathematical derivations and code examples
discusses physical components including metallic, dielectric, subsurface substrates, thin-film iridescence, and planned extensions like hazy specular reflection

wayback-archive

State of GPU Hardware (End of Year 2025)

analysis of GPU market share and D3D12 feature support using Steam Hardware Survey and D3d12infoDB
examines adoption rates for DXR, Shader Model 6.6-6.8, Mesh Shaders, Enhanced Barriers, VRS, and Work Graphs across GPU architectures

wayback-archive

ACM's Transition to Full Open Access

announces ACM’s transition to fully open access publishing model
makes all ACM research content freely available

wayback-archive

Bindless Oriented Graphics Programming

advocates for bindless rendering as an accessible gateway to GPU-driven rendering with lowered complexity
demonstrates how bindless resources enable event-driven draw management with reduced CPU involvement
proposes treating GPU data as database tables with compute shaders only modifying tables for simplified renderer architecture

wayback-archive

How to Vulkan in 2026

extensive tutorial demonstrating modern Vulkan 1.3 programming with simplified features like dynamic rendering and buffer device address
creates functional 3D rendering application with textured meshes, lighting, and user interaction in single-file example
leverages recent API improvements including descriptor indexing, synchronization2, and Slang shader language to reduce verbosity

wayback-archive

A Couple 3D AABB Tricks

presents practical techniques for working with axis-aligned bounding boxes including slab-based min/max representation for simpler merging operations
demonstrates an approach to extract individual vertex coordinates from AABB using vertex index without floating-point math
explains efficient ray-AABB intersection test

wayback-archive

TinyDiffRast project

educational course implementing differentiable triangle rasterization from scratch inspired by tiny renderer
teaches inverse rendering techniques allowing 3D scene parameters to be learned from 2D images through gradient-based optimization
covers automatic differentiation, discontinuity handling, and practical applications including optimizing geometry, materials, lighting, and camera parameters

wayback-archive

Improving Direct Lighting Material Occlusion - Part 1

analyzes limitations of traditional micro-occlusion texture baking for material-level direct lighting occlusion
compares micro-shadowing approaches from Naughty Dog and Activision with analytical formulas and visual results
proposes improved analytical alternative using cone angle calculations with better handling of full occlusion and roughness variation

wayback-archive

A silly diffuse shading model

proposes alternative diffuse lighting formula that avoids completely black unlit areas
provides simple one-liner solution for test projects that preserves geometric detail without complex lighting setups

wayback-archive

An Experimental Approach to printf in HLSL

presents a prototype implementation of printf debugging for HLSL shaders
uses compile-time string table extraction and builtin functions to convert format strings into buffer offsets
implemented entirely in HLSL using variadic templates

wayback-archive

Early-bird deadline for the Shading Languages Symposium 2026

conference program has been released
Combined passes for the Shading Languages Symposium + Vulkanised are available
Early bird ticket sales are still available

wayback-archive

[video] SIGGRAPH 2025 Advances in Real-Time Rendering in Games: Fast as Hell: idTech8 Global Illumination

presentation detailing the path-traced global illumination system in idTech8
discusses optimizations for dynamic lighting, material complexity, and scene complexity

[video] Getting started with BGFX

video tutorial series introducing BGFX, a cross-platform graphics rendering library
covers setup, basic rendering concepts, and how to create simple graphics applications

[video] Painting Holes in Terrain - Terrain Shaders - Episode 10

video tutorial showing how to create holes or cutouts in terrain geometry
demonstrates shader techniques for masking and clipping terrain based on texture data
covers practical applications like caves, tunnels, or dynamic terrain destruction

Realtime Raytracing in Bevy 0.18 (Solari)

details improvements to Bevy’s dynamic raytraced lighting system in version 0.18
adds specular material support with GGX BRDF including importance sampling and proper handling for mirror surfaces
fixes energy loss bugs, reduces ReSTIR resampling correlations, and improves world cache performance with adaptive blend factors and lifetime management

wayback-archive

Thanks to Aras Pranckevicius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 421 - December 28th, 2025

Sun, 28 Dec 2025 04:00:00 +0000

No Graphics API

very detailed blog post that discusses the reality of modern GPU hardware
presenting the disconnect between API models and hardware
proposes a minimalistic modern graphics API design that reduces complexity while maintaining performance
blog post contains an example of what such an API might look like

wayback-archive

OpenUSD Core Spec 1.0 is Here: Now We Need You

announces the release of the OpenUSD Core Specification 1.0 defining formal semantics for scene descriptions
specifies six essential pillars including grammar, composition algorithm, and compliance framework
provides sample implementations and conformance testing tools for validating implementations

wayback-archive

Secrets of Direct3D 12: The Behavior of ClearUnorderedAccessViewUint/Float

investigates behavior of ClearUnorderedAccessViewUint and ClearUnorderedAccessViewFloat functions
reveals inconsistent type conversions across NVIDIA, AMD, and Intel GPUs for various buffer formats
demonstrates that unsigned integer clears work differently than documented in DirectX 11

wayback-archive

[video] Filtering -vs- Graphics Round 2

continues the series with practical solutions and sample patterns for real-time renderers
shows shader-level techniques (sample distributions, MSAA-aware approaches) and links to Shadertoy experiments for direct testing
covers trade-offs between artifact reduction and performance, with suggestions that are implementable in real-time

CUDA Tile IR

introduces an MLIR-based intermediate representation for CUDA kernel targeting tensor cores
provides domain-specific operations for tile-based computations with Python bindings
includes bytecode serialization format

wayback-archive

Nexels: Neurally-Textured Surfels for Real-Time Novel View Synthesis with Sparse Geometries

presents a novel representation combining surfels with neural texturing for view synthesis
achieves quality matching 3D Gaussian splatting using 9.7x fewer primitives on outdoor scenes
aims to improve render times compared to existing methods by selectively texturing high-weight samples

wayback-archive

[video] Parallax Occlusion and Nanite Displacement - Terrain Shaders - Episode 9

walkthrough of parallax occlusion mapping (POM) techniques for Unity
integrating Nanite displacement for terrain rendering and how Nanite displacement changes displacement workflows
discusses performance implications and offers tips for balancing quality vs cost in terrain shaders

[video] Filtering -vs- Graphics Round 3

short talk focused on micro-optimizations to the filter kernel and their real-world impact
examines kernel tweaks that reduce aliasing artifacts while keeping shader cost low

[video] Basic Framework - Physics For Game Dev #1

sets up an initial physics framework and demonstrates simple particle dynamics
walks through application/physics system classes and a short demo showcasing the physics update
rendering is implmeneted using OpenGL

[video] niagara: Cooking geometry

live stream focused on making scene loading faster by caching optimized geometry on disk and adding compression
walks through implementing a basic scene cache, switching to memory-mapped loading, adding compression, and profiling cold/hot runs and page-fault behaviour
practical andf focused session with profiling runs, implementation details and trade-offs for robust cache/IO design

[video] Sparse Radiance Cascades: goodbye screenspace

presents the results of replacing the screenspace raymarcher implementation with a hardware-accelerated raytracer enabling offscreen lights and more stable GI
achieves real-time per-frame GI (no denoiser) on a 4090

Thanks to Aras Pranckevicius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 420 - December 14h, 2025

Sun, 14 Dec 2025 04:00:00 +0000

meshoptimizer v1.0 GitHub

highlights improvements to clusterization algorithms, producing higher-quality meshlets and better partitioning for hierarchical structures
stabilizes all experimental features with API, ABI, and behavior compatibility guarantees
additionally announces the inclusion of clusterlod, a single header library for continuous level of detail generation

wayback-archive

Optimizing mannequin

details performance optimizations for a VR title on Quest 2
describes improved culling and draw call reduction strategies
presents solutions for reducing draw calls through manual instancing, Custom Primitive Data, and LOD bias techniques

wayback-archive

Around The World, Part 28: Scaling up

discusses a simple world wrapping implementation using a chunk-based hierarchy in Godot
presents a terrain LOD system with skirts to prevent cracks
additionally presents tree impostors for distant vegetation using billboards

wayback-archive

MeshSplatting: Differentiable Rendering with Opaque Meshes

presents a mesh-based reconstruction approach that jointly optimizes geometry and appearance through differentiable rendering
uses restricted Delaunay triangulation to enforce connectivity and creates smooth surfaces with opaque triangles

wayback-archive

[video] Filtering -Vs- Graphics

The video discusses filtering considerations when implementing real-time graphics
compares against cinema quality and presents what causes games to have a specific look
additionally presents games that achieved particularly good results in image clarity

Eliminate Slope Stretching - Terrain Shaders - Episode 8

The video presents how to update the texture projection logic so that it can better deal with horizontal slopes
approaches the problem by projecting textures from the front and sides instead of only the top
shows how to implement the technique in both Unreal and Unity visual scripting

Sample Space Partitioning and Spatiotemporal Resampling for Specular Manifold Sampling

extends Specular Manifold Sampling for interactive caustic rendering using tile-based sample space partitioning
restricts expensive Newton iterations to the vicinity of seed paths by building per-frame prior distributions
applies ReSTIR spatiotemporal resampling to amortize sample generation costs and achieve variance reduction

wayback-archive

Implicit Position-Based Fluids (IPBF)

introduces a novel incompressible SPH scheme using second-order implicit descent
demonstrates improved incompressibility and stability compared to velocity-based methods like IISPH and DFSPH
remains unconditionally stable even for large time steps while avoiding the compression artifacts of standard position-based methods

wayback-archive

Thanks to Matt Pharr for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 419 - December 7th, 2025

Sun, 07 Dec 2025 04:00:00 +0000

Focus on Your Algorithm—NVIDIA CUDA Tile Handles the Hardware

introduces CUDA Tile, a tile-based programming model launching with CUDA 13.1
provides developers with cuTile Python for accessible GPU programming and CUDA Tile IR for building custom DSL or libraries

wayback-archive

VK_EXT_present_timing: the Journey to State-of-the-Art Frame Pacing in Vulkan

introduces VK_EXT_present_timing extension to enable precise frame pacing control in Vulkan
provides timing feedback from previous frames and allows specifying target presentation times for future frames

wayback-archive

Minimalist ray-tracing leveraging only acceleration structures

presents a low-quality ray tracing mode using ray queries and data stored in acceleration structures
eliminates ray pipelines, shader binding tables, and texture access by storing average diffuse color in TLAS instanceCustomIndex
uses VK_KHR_ray_tracing_position_fetch to compute face normals from triangle vertex positions

wayback-archive

GSWT: Gaussian Splatting Wang Tiles

proposes a tile-based framework for synthesizing large-scale terrains from 3D Gaussian Splatting exemplars
builds on Wang Tiles with boundary constraints to enable seamless tiling of Gaussian fields

wayback-archive

AMD GPU Debugger

presents a walkthrough of implementing a GPU debugger for AMD hardware
explains how to use registers and trap handlers to pause GPU execution and inspect register state
demonstrates stepping through shaders, examining variables, and integrating with SPIR-V compilation through RADV’s ACO compiler

wayback-archive

libGPUCounters Machine Readable Specification

provides a machine-readable specification for Arm Mali GPU performance counters starting from Mali-G71
offers Python wrappers that resolve symbolic counter references for any supported GPU
enables structured iteration through counters based on various orders

wayback-archive

A series of tricks and techniques I learned doing tiny GLSL demos

shares techniques learned from creating four tiny GLSL demos constrained to 512 characters
covers isometric projection setup, smooth minimum operations, and various domain warping techniques for procedural generation

wayback-archive

[video] New GPU Profiler and RHI Submission Pipeline | Unreal Fest Stockholm 2025

presentation covering improvements to Unreal Engine’s GPU profiler
discusses the redesigned RHI submission pipeline architecture and implementation
shows how to leverage these tools for performance analysis, optimization and crash debugging

[video] Better Tile Breakup - Terrain Shaders - Episode 7

video tutorial on techniques to reduce tiling artifacts in terrain textures
demonstrates methods to break up repetitive patterns in large-scale terrain rendering
part of an ongoing series on terrain shader development

Thanks to Leonardo Etcheverry for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 418 - November 30th, 2025

Sun, 30 Nov 2025 04:00:00 +0000

Boosting Ray Tracing Performance with Shader Execution Reordering: Introducing VK_EXT_ray_tracing_invocation_reorder

announces the multi-vendor Vulkan extension VK_EXT_ray_tracing_invocation_reorder for Shader Execution Reordering (SER) to reduce divergence in ray tracing workloads
explains how SER uses hit objects to separate ray traversal from shader invocation and allows the GPU to reorder invocations for improved coherence
provides best practices, GLSL/Slang code examples, and how to profile with NVIDIA and AMD tools

wayback-archive

Shader Execution Reordering Benchmarked

benchmarks Shader Execution Reordering (SER) using the Evolve pipeline path tracing benchmark across NVIDIA, AMD, and Intel GPUs
tests reordering strategies based on material index and material properties mask to improve wave coherence
shows significant performance improvements on NVIDIA hardware, while AMD and Intel showed minimal or no improvement

wayback-archive

Spatial hashing for raytraced ambient occlusion

implements a spatial hash structure to cache and accelerate ray-traced ambient occlusion for static scenes
presents hash functions using PCG and xxhash32 with position and normal quantization to create cells that accumulate AO samples
discusses distance-based cell sizing, conflict resolution via linear probing, and temporal management to handle hashmap capacity limits

wayback-archive

Introducing AMD GI-1.2 with multibounce indirect real-time rendering

announces AMD GI-1.2 as part of the Capsaicin Framework v1.3
extends the ray path by adding 2nd bounce hash grid cells to capture light from further bounces
presents the algorithm steps for radiance accumulation and filtering

wayback-archive

[video] Demystifying Vulkan Ray Tracing

video presentation covering the fundamentals of ray tracing
covers the overview of the Vulkan API
presents and explains ambient occlusion as a practical use case

Spectral rendering, part 3: Spectral vs. RGB

compares RGB rendering against spectral rendering using various illuminant types from white light to monochromatic spectra
demonstrates how spectral rendering accurately handles color shifts under different light sources
discusses the advantages of spectral rendering for production workflows

wayback-archive

Lighting mannequin

describes a lighting workflow for the Quest 2 that uses Lumen for fast iteration and GPU Lightmass for final bakes
presents techniques to fake light shafts without volumetric fog using Geometry Script-generated meshes and bloom effects without Mobile HDR
covers solutions to enable dynamic shadows on PC while keeping static lighting on mobile hardware

wayback-archive

Finger Shadows in Compose

demonstrates using Android’s RuntimeShader API to simulate soft shadows projected by the user’s finger onto the UI
models the finger as a 3D capsule and computes soft shadow visibility by calculating the spherical caps’ intersection
provides the complete AGSL shader implementation, including optimized trigonometric functions

wayback-archive

2D axis aligned bounding boxes

provides a collection of 2D axis-aligned bounding box (AABB) functions for SDF primitives to enable culling and pruning
covers triangles, oriented boxes, segments, pies, quadratic and cubic Bezier curves, parabolas, cut disks, eggs, stars, and vesica segments
includes Shadertoy demos for each primitive

wayback-archive

[video] Introducing geometric algebra

first video in a series introducing geometric algebra as a framework for manipulating geometric objects through algebraic calculations
provides an overview of applications, advantages over traditional linear algebra approaches, and common educational pitfalls
covers the distinction between parallel and orthogonal components and sets up the foundation for deeper exploration

Notes about VK_EXT_custom_resolve

explains the new VK_EXT_custom_resolve Vulkan extension that allows custom shaders for resolving multisample images
describes how the extension enables combining resolve operations with post-processing like tone-mapping in a single shader
covers the dynamic rendering support via vkCmdBeginCustomResolveEXT

wayback-archive

All Sources of DirectX 12 Documentation

provides a comprehensive guide to all D3D12 documentation sources
covers the primary Microsoft documentation, Functional Specification, DirectX-Specs, etc

wayback-archive

[video] SIGGRAPH Asia 2025 - Technical Papers Trailer

official trailer showcasing the technical papers presented at SIGGRAPH Asia 2025
previews the latest research in computer graphics and interactive techniques
presents a short overview of the various papers presented

Early-bird deadline for the Shading Languages Symposium 2026

conference program has been released
Combined passes for the Shading Languages Symposium + Vulkanised are available
Early bird ticket sales are still available

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 417 - November 15th, 2025

Sat, 15 Nov 2025 04:00:00 +0000

[video] SIGGRAPH 2025 Advances: STOCHASTIC TILE-BASED LIGHTING IN HYPEHYPE

SIGGRAPH 2025 presentation on stochastic tile-based lighting techniques implemented in HypeHype
cover motivations for the technique and how it compares against other solutions
detailed discussion of the implementation
covers how it interactics with other effects such as shadows

Spectral rendering, part 2: Real-time rendering

presents techniques for implementing spectral rendering in real-time applications using Monte Carlo integration
describes importance sampling strategies for wavelength selection based on illuminant spectra and color matching functions
demonstrates that spectral rendering introduces only modest overhead compared to RGB rendering

wayback-archive

The Geometry Behind Normal Maps

explains the mathematical foundations of tangent space and its role in normal mapping
details how UV coordinates define the orientation of the tangent frame on surfaces
presents the construction of the TBN matrix and its application in transforming texture-space normals to surface space

wayback-archive

[video] Terrain Tiling Break-Up - Terrain Shaders - Episode 4

discusses techniques to hide or reduce visible tiling patterns in terrain shaders
presents shader based solutions
additionally discusess alternative art authoring solutions

[video] Neural Shading Course: Part 1 - Introduction

introductory video for a course on neural shading techniques
first part of an 11 video part series exploring what neural shaders are, what hardware they provide access to

Introducing the Vulkan Drivers Tab

introduces a new Vulkan Drivers tab in the Vulkan Configurator (vkconfig)
provides a graphical interface to add additional drivers, force specific physical devices, and reorder device enumeration
streamlines multi-GPU testing and debugging by eliminating manual JSON configuration and environment variable tweaks

[video] Descriptor Indexing // Vulkan For Beginners #26

video tutorial covering descriptor indexing in Vulkan
explains how to access shader resources dynamically without binding individual descriptors
demonstrates the modern approach to managing textures and buffers in Vulkan applications

[video] Optimizing RTX Mega Geometry with Nsight Graphics GPU Trace

demonstrates how to use Nsight Graphics GPU Trace to profile and optimize RTX Mega Geometry
shows detailed view of the available performance counter
provides practical workflow for analyzing shader performance and identifying bottlenecks

bc_crunch

tiny dependency-free C99 library (~700 LOC) for lossless compression of GPU-compressed texture blocks (BC1, BC3, BC4, BC5)
exploits spatial patterns, endpoint deltas, and Morton-ordered indices specific to BC formats achieving compression ratios of 1.5x-6x
features deterministic bit-exact reconstruction with no malloc or external dependencies

wayback-archive

[video] Making GPUs Actually Fast: A Deep Dive into Training Performance

deep dive into GPU performance details and why GPUs are effective for neural network training
contains high level overview of gpu achitecture
identifies common bottlenecks (memory bandwidth, kernel-launch overhead, CPU–GPU imbalance) and how to overcome them

GNN From Scratch

tutorial on implementing Graph Neural Networks from scratch
provides step-by-step explanation of GNN architecture and components
covers fundamental concepts and practical implementation details

wayback-archive

Thanks to Graham Wihlidal for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 416 - November 9th, 2025

Sun, 09 Nov 2025 04:00:00 +0000

RenderDoc - Version v1.41

major release adding threaded shader debugging support for D3D11, D3D12, and Vulkan
correctly simulates wave/subgroup operations, group-shared memory, and whole-workgroup interactions
includes numerous bugfixes for pixel history, descriptor buffers, and multi-GPU scenarios

wayback-archive

CudaForge: An Agent Framework with Hardware Feedback for CUDA Kernel Optimization

presents a multi-agent workflow for automatic CUDA kernel generation and optimization
uses LLM agents to iteratively generate, correct, and optimize kernels while integrating Nsight Compute metrics

wayback-archive

Spectral rendering, part 1: Spectra

introduces spectral rendering for more accurate color reproduction
explains how to obtain illuminant spectra from databases and convert RGB textures to reflectance spectra using Fourier sRGB
presents the mathematical foundations of spectral upsampling that enable working with existing assets

wayback-archive

Coding This is Us

technical post-mortem of graphics techniques used in the “This is Us” demo presented at Revision 2025
describes real-time path tracing implementation using radiance caching with spatial hashing and ReSTIR GI
presents SPH fluid simulation using tiled approach with LDS pre-fetching and marching cubes meshing

wayback-archive

Inline vs Pipeline Ray Tracing

compares inline and pipeline ray tracing approaches with detailed explanations
benchmarks both methods on AMD, NVIDIA, and Intel Arc
shows AMD achieves significantly better performance with pipeline ray tracing, while NVIDIA and Intel perform similarly with both approaches

wayback-archive

How animation hides LOD Transitions

investigates how animation affects the visibility of LOD transitions in 3D models
finds that animated models can switch LODs much closer to the camera compared to static models
demonstrates that animation effectively masks geometry changes, potentially eliminating the need for cross-fade transitions

wayback-archive

Registration now open for the Shading Languages Symposium 2026

Registration for the Shading Languages Symposium 2026 is open
The program has been published and features keynotes and sessions covering Slang, SPIR-V, HLSL, GLSL, WGSL, Gigi, WESL, and more
aimed at attending work on shader languages, compilers, tools, or rendering pipelines

wayback-archive

[video] Fixing GLSL HLSL

The video discusses additional shader hints that the author would like to see expressed in shader code
explains the reasoning and advantages of the various requests
demonstrates suggested shader code syntax

[video] Terrain Shader Structure - Terrain Shaders - Episode 3

third episode in a series on terrain shader development
explains how to extend a single-layer material into a 4-layer blend setup
presents a height-based blending approach between layers

[video] Vertex Shaders & Tessellation | Unity Shader Code Basics 05

explains how to use vertex shaders to animate a simple wave
shows that vertex density affects the quality of the effect
provides a detailed walkthrough on how to set up the mesh tessellation pipeline using Unity

Tellusim Core SDK - Open Source

announces open source release of Tellusim Core SDK for cross-platform graphics and compute development
provides unified C++ API with bindings for C#, Rust, Swift, Python, Java, and JavaScript
includes comprehensive examples covering meshlets, ray tracing, UI, and more

wayback-archive

Thanks to Eric Haines for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 415 - November 2nd, 2025

Sun, 02 Nov 2025 04:00:00 +0000

Why do we need dithering?

explains how dithering techniques trick spatial averaging in human vision to perceive more colors than are actually present
covers ordered dithering using Bayer matrices and error diffusion methods like the Floyd-Steinberg algorithm
discusses how dithering was historically necessary for limited color palettes but has now become primarily a retro aesthetic choice

wayback-archive

Mastering GFXReconstruct: Part 2

comprehensive guide to installing and setting up GFXReconstruct for capturing and replaying Vulkan and DirectX 12 API calls
covers both prebuilt binaries from the Vulkan SDK and building from source for custom configurations
provides detailed troubleshooting steps and verification tests for both Vulkan and DirectX 12 workflows

wayback-archive

ONNX and DirectML execution provider guide - part 1

demonstrates how to build native inference pipelines on AMD GPUs using ONNX Runtime with DirectML execution provider
explains sharing the DirectX 12 context between DirectML and user code to avoid CPU-GPU data transfers
shows how to map resources directly into ONNX Runtime tensors for efficient preprocessing and postprocessing

wayback-archive

Introduction to Clustered Meshlet Optimization

introduces Simplygon’s clustered meshlet optimizer for dividing models into independently cullable parts with continuous LOD
explains that streaming levels contain partial data requiring a combination of all lower levels for full detail
provides complete implementation examples, including Python generation scripts and Unity C# visualization code

wayback-archive

Iterative Lightmap Updates for Scene Editing

Pacific Graphics 2025 paper presenting an iterative algorithm to update lightmaps when objects are inserted or removed efficiently
focuses on updating only the paths affected by scene changes rather than full recomputation
implements an importance sampling scheme on a GPU suitable for interactive scene editing scenarios

wayback-archive

Jackknife Transmittance and MIS Weight Estimation

SIGGRAPH Asia 2025 paper introducing a biased transmittance estimator with significantly reduced bias compared to naive ray marching
applies the UMVU estimator based on nearly normally distributed optical depth estimates from stratified jittered sampling
extends the theory to estimate MIS weights and proposes two new integrators combining MIS with improved transmittance estimation

wayback-archive

Evaluating and Sampling Glinty NDFs in Constant Time

SIGGRAPH Asia 2025 paper presenting a method for rendering glint effects from microfacet geometry in constant time
represents faceted geometry as a 4D point process on a multiscale grid to find highlight-causing facets efficiently
supports various appearances, including anisotropic materials and individually colored particles, while converging to standard NDFs like GGX

wayback-archive

[video] Depth | Unity Shader Code Basics 04

video tutorial explaining how to work with depth information in Unity shaders
covers fundamental concepts like the depth buffer, depth textures, and their use in effects
provides practical examples and shader code for implementing depth-based visual effects

[video] Advanced Physically Based Rendering With ClearCoat

tutorial on implementing a transparent coat layer for physically based rendering (PBR) materials
explains the principles behind simulating a transparent coating over a base material
demonstrates the shader implementation and shows how it enhances the realism of surfaces like car paint or polished wood

[video] Demetri Spanos – Foliated Distance Fields – BSC 2025

presents a BSC 2025 talk on Foliated Distance Fields for representing and rendering complex geometry
discusses how this technique can be used for high-quality, real-time rendering of intricate surfaces
explores the implementation details and performance characteristics of the approach

Thanks to Eric Heines for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 414 - October 26th, 2025

Sun, 26 Oct 2025 04:00:00 +0000

[video] npacking Terrain Textures - Terrain Shaders - Episode 2

video tutorial demonstrating how to unpack terrain textures efficiently
explains creating terrain layer subgraphs using only two texture samples
shares optimization techniques to improve terrain shader performance

[video] Shape Shader Functions WITHOUT Knowing Math!

demonstrates how to use Desmos to visualize functions and transform them into shader code
provides various examples of the transformation steps
additionally presents how to use the functions to distort UVs to create interesting visual effects

Calculating the Bounding Rectangle of a Circular Sector

presents an algorithm for calculating bounding boxes of circular sectors in 2D
provides a GLSL implementation using vector operations
useful for area-of-effect queries in game development, such as attacks or spell casting

wayback-archive

Ghost of Yōtei – tech deep dive

Sucker Punch details the rendering technology behind Ghost of Yōtei
discusses GPU compute rendering for vast landscapes with large instance counts
covers advanced features including terrain tessellation, volumetric fog with cloud shadows, and PS5 Pro ray-traced global illumination

wayback-archive

ReGIR - An advanced implementation for many-lights offline rendering

comprehensive deep-dive into implementing ReGIR for efficient many-lights sampling
explains Reservoir-based Grid Importance Resampling using hash grids and spatial/temporal reuse
demonstrates significant performance improvements over power sampling and light hierarchies in complex scenes

wayback-archive

NITRO GEN OMEGA: Bringing the art style of spaghetti anime to life with UE5

An interview with the developers of “NITRO GEN OMEGA”
Discusses how they achieved the “spaghetti anime” art style in Unreal Engine 5
Covers the use of cel shading, stylized VFX, and other techniques to create a umique look

wayback-archive

Thanks to Peter Kohaut for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 413 - October 19th, 2025

Sun, 19 Oct 2025 04:00:00 +0000

SIGGRAPH 2025: Hands-on Vulkan Ray Tracing with Dynamic Rendering

hands-on tutorial series for implementing ray tracing with Vulkan
implements ray-query-based shadow rays with alpha-test transparency support
includes debugging tips using RenderDoc and Nsight Graphics

wayback-archive

Physically Based Content

comprehensive guide covering physically based approaches for geometry, materials, lighting, and cameras
discusses the various material properties with real-world examples
covers physically based lighting units, including candela, lumen, nit, and lux, with practical measurement techniques
emphasizes the importance of physically based content for reusable assets and consistent results across lighting conditions

wayback-archive

Field Guide to TSL and WebGPU

comprehensive guide to Three.js using WebGPU
presents three.js Shading Language (TSL) as well as WGsl for web graphics development
provides practical examples, including displacement, glass materials, particles, and post-processing effects

wayback-archive

[video] Texturing & UVs | Unity Shader Code Basics 02

video tutorial covering texture sampling in Unity shader code
explains the concept of UV coordinates, texture samplers
shows how to implement texture mapping into a simple shader

Heterogenous AoS instance encoding for a GPU-driven renderer

presents a per-instance encoding technique for GPU-driven rendering with varying instance data requirements
instances use type discriminants to allow different memory layouts within a unified buffer
reduces memory bandwidth and footprint by eliminating unused fields
allows different instance types to coexist efficiently in the same buffer

wayback-archive

[video] GPU Side Input

video exploring GPU-side input handling (late latching)
discusses how to efficiently manage input data directly on the GPU with cache-line-sized packets
covers practical implementation and how to avoid mid-frame cache flushes from the CPU

[video] Vulkan WORM

video demonstrating a write-once read-many model (WORM) for authoring compute workloads
presents how Vulkan compute code can be written to take advantage of the cache structure to ensure no cache flushes are required
discusses considerations when designing the data model to match hardware caches

Sharp Bilinear Filters: Big Clean Pixels for Pixel Art

explains the sharp bilinear filtering technique for scaling pixel art without blur
solves common artifacts from nearest-neighbor and standard bilinear filtering
Derives the mathematical formulas behind the shader implementation step by step

wayback-archive

Mini: 3D Rotation

tutorial covering Euler angles and axis-angle rotation methods for 3D graphics
explains how to stack 2D rotations for yaw, pitch, and roll transformations
presents axis-angle rotation formula using mix, cross product, and trigonometric functions

wayback-archive

Fast calculation of the distance to cubic Bezier curves on the GPU

details the mathematical approach to computing distance from a point to cubic Bézier curves
presents and compares recent algorithm improvements
providing GLSL implementations of the presented techniques

wayback-archive

Thanks to Peter Kohaut for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 412 - October 12th, 2025

Sun, 12 Oct 2025 04:00:00 +0000

Dynamic levels of detail in Evolve

details a GPU-driven LOD system using solid angle calculations on camera unit spheres
projects mesh AABBs onto the unit sphere to estimate screen coverage for LOD selection
implements bindless rendering with unified vertex/index buffer access across all LOD levels

wayback-archive

Variable-Rate Texture Compression: Real-Time Rendering with JPEG

demonstrates a technique to use JPEG textures for real-time integration using OpenGL and CUDA
uses deferred rendering to identify required JPEG blocks before collaborative workgroup decoding
presents the pipeline that is defined by geometry, mark, decode, and finally the resolve pass

wayback-archive

A Tour of Cute Framework's Renderer

comprehensive overview of a 2D renderer that unifies sprites, shapes, and text in single draw calls
presents runtime sprite atlas compilation that automatically manages texture packing for the user
uses signed distance functions for shape rendering with unified antialiasing, rounding, and stroke support

wayback-archive

[video] Cubemaps // Vulkan For Beginners #25

tutorial covering cubemap implementation in Vulkan
explains cubemap texture setup and sampling techniques
demonstrates environment mapping to render a skybox around the viewer position

Converting SSE intrinsics code to Neon. Burst masked occlusion culling

details the process of translating SSE intrinsics to Neon for Unity’s Burst compiler
presents optimization techniques that improved performance by 2.3x through removing allocations
discusses challenges with instruction equivalence and shows SIMD vectorization achieving 7-15x speedups

wayback-archive

[video] Coding Adventure: Simulating Smoke

video walkthrough of implementing a fluid dynamics simulation for smoke
covers the mathematical foundations and implementation details of smoke simulation
covers Navier-Stokes equations as well as dynamic simulation with pressure solving and velocity interpolation

Better sRGB to greyscale conversion

presents an improved formula for converting sRGB colors to greyscale in gamma space
explains why the standard Rec. 709 coefficients are technically incorrect when used with gamma-corrected values
compares alternative coefficients optimized for nonlinear color space with visual examples

wayback-archive

[video] Your First Shader | Unity Shader Code Basics 01

introductory video tutorial on writing shaders in Unity
covers the fundamental concepts of shader programming for beginners
walks through creating a basic shader from scratch

WebGPU and the price of compiling WGSL

introduces a diagnostic tool for measuring WGSL shader compilation times in WebGPU
provides complexity sliders to generate shaders of various sizes for benchmarking
reveals significant differences between cold and warm compilation timings across browsers

wayback-archive

SIGGRAPH 2025 Materials Now Available: Recordings and Resources from Our Events

announces the availability of recordings and materials from Slang’s SIGGRAPH 2025 sessions
includes hands-on lab materials covering language fundamentals, modules, and automatic differentiation
provides access to neural shading course materials as well as a session presenting how developers use the technology

wayback-archive

[video] Reinforcement Learning 04 : Motion Fields For Interactive Character Animation

video presentation on the Motion Fields for Interactive Character Animation paper
discusses reinforcement learning techniques for generating responsive character movements
present a practical implementation of the technique with an in-depth explanation

[video] But what is a Laplace Transform?

video explaining the intuition and mathematics behind Laplace transforms
presents the transform as a tool for converting differential equations into algebraic ones
shows visual interpretations of the mathematical concepts

Thanks to Keith O’Conor for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 411 - October 5th, 2025

Sun, 05 Oct 2025 04:00:00 +0000

A case for learning GPU programming with a compute-first mindset

proposes teaching GPU programming through compute shaders before graphics pipelines
demonstrates starting from simple compute shaders in Vulkan, and using RenderDoc debugging as an essential teaching tool
presents how to develop from this to understand the execution model, binding model, and how to integrate shader toy examples
additionally presents next learning steps

wayback-archive

Ocean Rendering, Part 1 - Simulation

details the theory and mathematics behind FFT-based ocean simulation
covers oceanographic spectra including JONSWAP and TMA, directional spreading functions, and dispersion relationships
presents implementation details for cascaded simulation and FFT using compute shaders

wayback-archive

Nintendo Switch 2 DLSS Image Quality Analysis: Tiny DLSS/Full-Fat DLSS Confirmed

video analyzing DLSS image quality on Nintendo Switch 2
compares different DLSS implementations and their visual quality

Avowed: A GPU Technical Retrospective | Unreal Fest Orlando 2025

presentation covering the GPU rendering optimization process in Avowed using Unreal Engine
shares insights from the development process and technical challenges encountered
covers aspects from art authoring, material optimization, ray tracing, nanite tweaks, and much more

ADAPTIVE VOXEL-BASED ORDER-INDEPENDENT TRANSPARENCY

presents an adaptive voxel-based approach for order-independent transparency rendering
demonstrates performance and quality against other OIT methods

wayback-archive

RAY TRACING THE WORLD OF ASSASSIN'S CREED SHADOWS (Advances in Real-Time Rendering SIGGRAPH 2025)

video presentation on ray tracing implementation in Assassin’s Creed: Shadows
focuses on the algorithms and implementations
followed by the challenges specific to AC and a look at performance
additionally discusses the limitations of the presented techniques

GPU Instanced Grass Breakdown

tutorial covering GPU instancing for rendering of grass efficiently
explains setup using Graphics.RenderMeshPrimitives and compute buffers for instance data
includes GPU frustum culling implementation and optimization techniques for Unity

wayback-archive

Code golfing a tiny demo using maths and a pinch of insanity

presents the creation of a 448-character GLSL procedural demo featuring mountains, clouds, and fog
explains techniques for generating noise using sine waves, rotation matrices, and FBM accumulation

wayback-archive

Descriptors are Hard

XDC 2025 talk providing an overview of resource mapping from API and hardware perspectives
discusses the differences in approaches to descriptors and how varios drivers map it onto the hardware
additionally presents a preview of the new descriptor model coming to Vulkan

wayback-archive

Billions of triangles in minutes

details optimization work improving meshoptimizer’s hierarchical clustered LOD generation
achieves 3.5x speedup through addressing memory sparsity, thread balancing, and SIMD optimizations
demonstrates processing NVIDIA’s 1.64 billion-triangle Zorah scene in under 3 minutes, down from 30 at the start of the article

wayback-archive

Inside NVIDIA GPUs: Anatomy of high performance matmul kernels

comprehensive guide covering GPU architecture fundamentals, including memory hierarchies and compute pipelines
explains PTX/SASS assembly languages and analyzes compiler-generated code from CUDA kernels
progresses from warp-tiling synchronous kernels to SOTA Hopper asynchronous implementations using TMA and tensor cores

wayback-archive

Series Summary and What's Next - Game Optimization - Episode 11

video summarizing the Game Optimization series of video tutorials
recaps key optimization techniques covered throughout the series
discusses future content directions and advanced optimization topics

Why complex exponents matter | Laplace Transform Prelude

video from 3Blue1Brown explaining the mathematical foundations of complex exponents
connects dynamics and Euler’s formula through visualization

Thanks to Nathan Reed for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 410 - September 28th, 2025

Sun, 28 Sep 2025 04:00:00 +0000

Figma rendering: Powered by WebGPU

details Figma’s migration from WebGL to WebGPU
presents challenges in modernizing the graphics interface, including shader processing, uniform buffer management, and cross-platform deployment
discusses the rollout strategy with dynamic fallback systems and device compatibility testing

wayback-archive

NVIDIA Vulkan Ray Tracing Tutorial

step-by-step tutorial series on implementing Vulkan ray tracing with KHR extensions
guides readers through acceleration structures, ray generation, and shader binding with practical code examples
highlights recent improvements: Vulkan 1.4 support, VMA integration, Slang shader compilation, glTF 2.0 asset loading, and a cleaner codebase

wayback-archive

Agility SDK 1.618: Advanced Shader Delivery and 1.716 out of preview

announces new DirectX Agility SDK release featuring the advanced shader delivery system
presents the various steps of the process
talks about pipeline data collection, offline compilers, as well as new APIs

wayback-archive

PIX 2509.25 – support for new D3D features and devices, and misc bug fixes

PIX tool update with support for tracking driver & application combination specific state
supports recreation of resource at specific virtual addresses for improved playback
additionally contains various other fixes

wayback-archive

Animating geometry with AMD DGF

introduces animation capabilities for AMD’s Dense Geometry Format (DGF) with linear vertex blending techniques
demonstrates the animation pipeline that overwrites vertex positions within DGF blocks each frame
shows quantization approaches and the effects on performance

wayback-archive

Towards GPU Parallelism Abstractions in Rust: A Case Study with Linear Pipelines

research paper introduces high-level GPU programming abstractions in Rust using procedural macros for automatic code generation
presents linear pipeline parallel patterns for simplified GPU execution
benchmarks against manual OpenCL implementations

wayback-archive

I Misunderstood Rejection Sampling All This Time

clarifies common misconceptions about rejection sampling techniques in statistical computing and graphics
explains the mathematical foundations and implementation considerations
showing how to combine multiple sample distributions to improve sample efficiency

wayback-archive

Anisotropic Scaling in Indiana Jones and the Great Circle and DOOM: The Dark Ages

The blog post discusses performance issues related to Anisotropic samples found on Indiana Jones and the Great Circle, as well as DOOM
presents an algorithm that can be used to vary AnisotropicSampleCount in a dynamic resolution scenario
additionally brings up the option of using the same technique for values where infrequent change, particularly with a moving camera, may go unnoticed

wayback-archive

Graphics Programming Conference - Schedule

announces the schedule for the Graphics Programming Conference in Breda, Netherlands, later this year
covers a large variety of topics

wayback-archive

[video] Shader Optimization - Game Optimization - Episode 10

video tutorial focusing on GPU shader optimization techniques
covers common shader bottlenecks, how to identify performance issues, and possible solutions
presents optimization scenarios in both Unreal and Unity

[video] Physically Based Rendering In OpenGL Using GLTF2

comprehensive tutorial implementing physically based rendering (PBR) in OpenGL using the GLTF 2.0 format
covers material property handling, including albedo, metallic, roughness, and normal mapping
demonstrates proper lighting calculations and implementation of the PBR shading model

[youtube] CRT Spatial Scaling

starts by providing an overview of the current landscape of upscaling techniques and associated performance and quality effects
explores CRT display emulation techniques, focusing on spatial scaling algorithms
demonstrates methods for accurately reproducing retro gaming visuals on modern high-resolution displays

Thanks to Stephen Hill for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 409 - September 21st, 2025

Sun, 21 Sep 2025 04:00:00 +0000

Realtime Raytracing in Bevy 0.17 (Solari)

comprehensive technical breakdown of Solari, a real-time raytracing system integrated into Bevy 0.17
discusses the motivation and development history
implements ReSTIR Direct and global illumination with a world-space irradiance cache
uses DLSS Ray Reconstruction for denoising and upscaling
presents a look at the performance of the various implementation steps

wayback-archive

Triple Buffering in Rendering APIs

explains how triple buffering improves frame pacing and throughput by preventing GPU stalls when VSync is enabled
provides practical implementation examples for Vulkan, DirectX 12, and OpenGL
briefly mentions the disadvantages of the techniques and common pitfalls

wayback-archive

Bezier Curve as Easing Function In C++

blog post introduces a library for implementing cubic Bézier curve representation in just 28 bytes
provides comparisons in time and quality against other implementations

wayback-archive

Jobs

Senior Simulation Software Engineer
Pittsburgh, PA

At Astrobotic, we’re building the future of space robotics, from lunar landers to autonomous systems- and simulation is central to that mission. We’re seeking engineers with strong skills in C++, graphics, and simulation to develop high-fidelity environments that enable spacecraft testing and mission operations.

Would you like to advertise your job openings here too? More information

BLAS Sharing for ray tracing cluster-based continous level of detail

presents techniques for reducing BLAS builds for cluster-based continuous level of detail systems
discusses BLAS Sharing, Caching, and Merging
releases the implementation of the techniques with a detailed discussion of the implementation choices
additionally presents performance and memory profiling results

wayback-archive

[video] What was Euclid really doing?

video exploring the foundational principles and methodologies behind Euclidean geometry
examines how Euclid’s systematic approach to mathematical proofs laid the groundwork for modern mathematical reasoning

[video] Easy Color Theory: A Beginner's Guide

introductory video covering fundamental color theory concepts for beginners
explains color relationships, harmony principles, and practical applications in design and digital art
provides accessible guidance on using the color wheel and understanding color interactions for improved visual compositions

The performance impact of vertex shader exports

detailed analysis of how increasing vertex shader exports affects rendering performance on NVIDIA GPUs and AMD integrated GPUs
demonstrates that drawcall costs can significantly increase when exporting more data to the vertex shader stage
uses Nsight Graphics profiling to show how bottlenecks and memory allocation patterns impact vertex-to-pixel data flow

wayback-archive

Towards Robust Agentic CUDA Kernel Benchmarking, Verification, and Optimization

introduces robust-kbench, a comprehensive benchmark for evaluating CUDA kernel performance and correctness across varied scenarios
presents an agentic framework that uses large language models to discover, verify, and optimize CUDA kernels automatically

wayback-archive

Thanks to Stephen Hill for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 408 - September 14th, 2025

Sun, 14 Sep 2025 04:00:00 +0000

Dot Noise

introduces a cost-effective alternative to 3D simplex noise using modified gyroid functions
provides code and presents practical examples of the technique

wayback-archive

Light beam shader in godot

tutorial implementing volumetric light beams using billboard techniques inspired by Half-Life 2
covers billboarding mathematics, proximity fade implementation, and procedural beam shape generation
includes gradient overlays and animated noise to improve the visuals further

wayback-archive

[video] The History of the GPU | GDEX 2025

presentation tracing the evolution of graphics processing units from early hardware to todays designs
covers key milestones in GPU development and their impact
additionally covers more recent hardware developments and what might be next

AMD's RDNA4 GPU Architecture at Hot Chips 2025

detailed analysis of AMD’s RDNA4 GPU architecture focusing on efficiency improvements in raytracing and compute
discusses enhanced memory subsystem, improved compression and memory barrier improvements

wayback-archive

How to Think About GPUs

comprehensive guide to understanding GPU architecture for machine learning applications
compares GPU and TPU design philosophies, covering memory hierarchies and networking topologies
provides practical analysis for scaling large language models on GPU clusters

wayback-archive

[video] Intel Just Changed Computer Graphics Forever!

the video explains how gaussian splats can be used to compress images
starts with a high level explonation of gaussian splats
takes this information as starting point to explain the compression process step by step

[video] Optimizing Individual Draw Calls - Game Optimization - Episode 9

video tutorial focusing on performance optimization for individual rendering draw calls
presents how to use PIX to identif long draw calls, investigate the pipeline state to detect performance issues
how to apply the investigation results back in the engine(s) and the effect of the optimizations

[video] Ed Catmull - SIGGRAPH Pioneers Featured Speaker 2025

presentation by computer graphics pioneer Ed Catmull at SIGGRAPH 2025 pioneers session
discusses the story of making Toy Story
followed by an extensive Q&A session

Thanks to Jhon Adams for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 407 - September 7th, 2025

Sun, 07 Sep 2025 04:00:00 +0000

Physically based rendering from first principles

provides a comprehensive introduction to physically based rendering, starting by explaining the physical concepts
explains the bidirectional reflectance distribution function (BRDF) and how light interacts with surfaces
demonstrates the mathematical foundations behind microfacet theory and importance sampling techniques

wayback-archive

What is a color space?

provides a comprehensive explanation of color spaces, color models, and gamuts in digital imaging
covers the mathematical foundations of how colors are represented and transformed between different systems
explains practical implications for developers working with color-accurate workflows and display technologies

wayback-archive

Video Game Blurs (and how the best one works)

a detailed article that covers the various steps that are required to understand blurs
provides interactive examples for the various components
analyzes different blur algorithms and their performance characteristics
closes with a discussion of Kawase blur technique and how it achieves high-quality blur effects with fewer texture samples than traditional methods

wayback-archive

[video] Advances in Order Independent Transparency for Real-Time & Virtual Production Workflows - P. Kakkar

explores modern techniques for achieving order-independent transparency in real-time rendering
discusses the challenges of transparent object rendering and various solutions to depth sorting issues
presents advances in per-pixel linked lists and weighted blended transparency methods
covers applications in virtual production workflows where accurate transparency is critical

Stop Shipping PNGs In Your Games

demonstrates the benefits of GPU-compatible texture compression for storage size, VRAM usage, and sampling performance
provides practical guidance on texture format conversion tools and automation workflows for game development

wayback-archive

[video] Multiple Frames In Flight // Vulkan For Beginners #24

demonstrates how to overlap CPU and GPU work by having multiple command buffers and synchronization objects
covers the synchronization challenges and resource management needed when multiple frames are being processed simultaneously

[video] Optimizing Based On Analysis - Game Optimization - Episode 8

demonstrates how to use profiling data and performance analysis to guide optimization decisions
covers systematic approaches to identifying bottlenecks in game performance
explains the importance of measuring before optimizing to avoid premature optimization pitfalls

Unreal Engine 5 is not just a performance problem, it is a UX problem

argues that often UE5 performance issues stem from a poor user experience design rather than just technical limitations
discusses how hidden system dependencies and lack of performance visibility make optimization difficult for teams
proposes better profiling tools and feature-level cost indicators to help developers understand what systems are active

wayback-archive

[video] MaterialX Virtual Town Hall 2025

presents updates and developments in the MaterialX open standard
discusses community contributions and adoption across different software and studios

Ten Years of D3D12

retrospectively examines the evolution of Direct3D 12 over its first decade since release
details the significant API additions, including ray tracing, mesh shaders, work graphs, and enhanced barriers
covers new shader features like wave operations, bindless resources, and HLSL language improvements
reflects on how development workflows and programming patterns have changed with modern D3D12 features

wayback-archive

Thanks to Angel Ortiz for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 406 - August 31st, 2025

Sun, 31 Aug 2025 04:00:00 +0000

Advances in Real-Time Rendering in Games

presents the Siggraph 2025 course collection on advances in real-time rendering techniques for games
discusses latest advances in ray tracing, global illumination, and hybrid rendering pipelines for interactive applications
Slides for most talks have been released

wayback-archive

Stochastic tile-based lighting in HypeHype

presents a stochastic approach to tile-based lighting
discusses probabilistic light sampling techniques that maintain visual quality while reducing computational overhead
demonstrates implementation details for integrating stochastic methods with existing tile-based deferred rendering pipelines

wayback-archive

Grass Rendering Series Part 4: Level-Of-Detail Tricks for Infinite Plains of Grass in Godot

presents techniques for implementing level-of-detail systems for grass rendering
demonstrates the creation of grass impostors using custom shaders that replicate albedo, ambient occlusion, and normal maps without geometry
shows how to implement smooth transitions between high-detail grass meshes and performance-optimized impostor representations

wayback-archive

Implementing a foil sticker effect

presents shader techniques for creating realistic metallic foil sticker effects using reflection and refraction
discusses texture mapping approaches for simulating the characteristic rainbow iridescence of holographic materials
shader code is included
additionally contains a real-time implementation in the browser that allows experimentation

wayback-archive

Blocky Planet — Making Minecraft Spherical

presents techniques for transforming cubic voxel worlds into spherical geometries using quad sphere mapping
discusses map distortion artifacts and how to overcome them for a Minecraft-like world
provides visual explanations of the issues and how to resolve them

wayback-archive

Functions: Mix

presents the mix() function used for linear interpolation between values
discusses practical applications, including color blending, texture transitions, and animation smoothing
demonstrates various practical use-cases

wayback-archive

[video] Analyze Your Game With PIX - Game Optimization - Episode 7

video tutorial demonstrating how to use Microsoft PIX to analyze game GPU performance
shows the necessary steps to set up the system
presents a first brief walkthrough of a GPU frame in Unity and Unreal using PIX

GPU utilisation and performance improvements

explores strategies for maximizing GPU VALU utilization and overall throughput by identifying and removing bottlenecks
discusses when to use different shader types (pixel vs compute) based on workload characteristics and hardware limitations

wayback-archive

Graphics Programming Conference

announces the Graphics Programming Conference tickets are on sale now
Many sessions are also already announced

wayback-archive

Recommended Programming Newsletters

presents a curated collection of programming newsletters covering various development topics (mine is included as well)
discusses newsletters focusing on graphics programming, game development, and rendering techniques

wayback-archive

Thanks to Angel Ortiz for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 405 - August 24th, 2025

Sun, 24 Aug 2025 04:00:00 +0000

[video] Elden Ring, scrolling textures, swirling tornadoes.

video explains the implementation of a tornado effect as found in Elden Ring
shows the modeling, UV manipulation, and shader work in Godot

[video] What to do if you're GPU Bound - Game Optimization - Episode 6

video tutorial covering optimization strategies when games are GPU-limited
presents techniques for identifying GPU bottlenecks and performance issues
demonstrates effects of lights, shadows, post-processing, as well as overdraw optimizations

This many points is surely out of scope!

The author explores GPU point rendering performance bottlenecks
investigates why millions of points cause dramatic slowdowns on Apple GPUs when heavily overlapped
compares regular point rasterization vs compute shader approaches across 30+ GPU models

wayback-archive

Neural Super Sampling

Arm releases a temporal super sampling model optimized for mobile Neural Accelerators
enables upscaling from 540p to 1080p
includes explanations on how to get started with the model as well as how to train and evaluate it

wayback-archive

Notes on AutoGrad

comprehensive guide to automatic differentiation in machine learning from a practical perspective
covers DAG computation graphs, dynamic graph building, and gradient computation using the chain rule
includes toy AutoGrad implementation in Python, demonstrating forward and backward passes
explores regularization techniques, skip connections, and gradient management in modern frameworks like PyTorch

wayback-archive

Big O

interactive tutorial on Big O notation explaining algorithm complexity analysis
covers O(1), O(log n), O(n), and O(n²) with practical examples including bubble sort and binary search
demonstrates performance implications through visual demonstrations

wayback-archive

Neural Visibility Cache for Real-Time Light Sampling

trained neural cache storing visibility between lights and 3D positions for direct illumination
integrates MLP with multi-resolution hash-grid encoding
feeds light visibility data to weighted reservoir sampling

wayback-archive

OKLCH colors

perceptually uniform color model based on OKLab color space, offering improved color manipulation
enables consistent brightness across different hues by maintaining the same lightness value
produces better gradients without muddy midpoints and predictable shades without hue drift
supports wider Display-P3 gamut colors beyond sRGB

wayback-archive

Introducing Advanced Shader Delivery

Microsoft’s solution to shader compilation stuttering by moving shader compilation to cloud infrastructure
creates State Object Database (SODB) from game data and Precompiled Shader Database (PSDB) for distribution
initially launching on ROG Xbox Ally devices and later broader through the AgilitySDK

wayback-archive

AMD FidelityFX SDK 2.0 launches our neural rendering technologies for developers

major revision introducing ML-based neural rendering technologies, including AMD FSR 4 upscaling
requires pre-built, signed DLL architecture with automatic hardware-appropriate fallback from FSR 4 to FSR 3.1.5
enables automatic driver-based technology upgrades for FSR 4 upscaling and upcoming FSR ML Frame Generation

wayback-archive

Introducing the MIP Explorer

Python tool for analyzing texture resolution requirements by examining mipmap level information distribution
calculates per-pixel differences between consecutive mip levels to identify needlessly large textures
helps to optimize texture memory usage and streaming performance by providing objective metrics for size reduction decisions

wayback-archive

Thanks to Matt Pharr for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 404 - August 17th, 2025

Sun, 17 Aug 2025 04:00:00 +0000

SIGGRAPH 2025 Course: Physically Based Shading in Theory and Practice

annual SIGGRAPH course covering the latest developments in physically based shading research and practice
features presentations on OpenPBR, EON energy-preserving diffuse reflection, spectral rendering in RGB workflows, and neural materials
additionally covers hair/fur shading models and tone mapping techniques from Gran Turismo 7

wayback-archive

SIGGRAPH 2025 Links

comprehensive collection of links to SIGGRAPH 2025 content including courses, talks, papers, and emerging technologies
covers session recordings, technical papers, and innovative demonstrations from the conference

wayback-archive

LunarG at SIGGRAPH 2025: Updates on Ecosystem and GFXReconstruct

LunarG’s SIGGRAPH 2025 presentations on Vulkan SDK updates and GFXReconstruct capabilities
details improvements to validation layers, new tooling features, and ecosystem advancements since 2024

wayback-archive

Spark 1.3 and spark.js

release of Spark 1.3 with full WebGPU support and introduction of spark.js for browser-based GPU texture compression
introduces new BC7 RGBA codec and improved quality across all formats
performance improvements for EAC compression on mobile GPUs and expanded platform support including older OpenGL versions

wayback-archive

Learning About GPUs Through Measuring Memory Bandwidth

Explains descriptors, buffer types, and texture units in practical terms
Walks through cache behavior (write-back/combining, globallycoherent) and latency hiding
Shares findings from a purpose-built microbenchmark across multiple GPU

wayback-archive

Anno 1800: Frame Analysis

in-depth technical analysis of Anno 1800’s custom rendering pipeline from terrain virtual textures to final output
explores techniques like GPU-driven rendering, compute-based particle systems, and async wave simulation
detailed breakdown of the forward rendering approach including depth prepass, shadows, and post-processing stack

wayback-archive

Derivatives, Gradients, Jacobians and Hessians – Oh My!

educational article explaining the relationships between derivatives, gradients, Jacobian matrices, and Hessian matrices
demonstrates practical applications in optimization, machine learning, and computer graphics
explains how these concepts are used in rendering techniques like gradient descent and SDF antialiasing

wayback-archive

Environment and Light in Godot: Setting Up For Photorealistic 3D Graphics

comprehensive guide to setting up realistic lighting and environments in Godot 4
covers WorldEnvironment setup, physical sky materials, HDR tone mapping, and global illumination techniques
explains practical aspects of ambient occlusion, bloom, fog, and color grading for achieving high-quality visuals

wayback-archive

[video] HDR And Tone Mapping Using OpenGL // Intermediate OpenGL Series

video tutorial explaining high dynamic range rendering and tone mapping implementation in OpenGL
covers the theory behind HDR color spaces and why traditional 0-1 RGB values are insufficient for realistic lighting
demonstrates practical implementation of tone mapping operators to convert HDR to displayable LDR formats

[video] I Tried Ray-Tracing Glass and Rainbows

video demonstrating ray tracing implementation for glass materials and dispersion effects to create rainbows
explores the physics of light refraction and how to simulate wavelength-dependent refractive indices
presents visual explanations of the pheonmenos and how to implement them

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 403 - August 10th, 2025

Sun, 10 Aug 2025 04:00:00 +0000

Get ready for FSR Redstone with AMD FSR 3.1.4 and our new UE 5.6 plugin

introduces FSR Redstone, AMD’s upcoming suite of ML-powered neural rendering techniques
includes Neural Radiance Caching for real-time global illumination, ML Ray Regeneration for restoring details from low sample counts, Super Resolution (FSR 4), including frame generation

wayback-archive

GPU Work Graphs Course

Siggraph course covering GPU Work Graphs for D3D12
starts with an in-depth look at graphics and API history and remaining limitations that work graphs aim to solve
provides detailed tutorials and examples for using the API and understanding related concepts
additionally explains how the driver implementation maps it onto the hardware

wayback-archive

SIGGRAPH 2025 Course: Physically Based Shading in Theory and Practice

2025 editions of SIGGRAPH courses on physically based shading
covers topics including OpenPBR implementation details, spectral rendering in RGB, strand shading for hair/fur/feathers, and neural materials
additionally features talks on EON rough diffuse reflection, tone mapping in Gran Turismo 7, and bridging the gap between offline and real-time rendering
Slides are already available

wayback-archive

A Texture Streaming Pipeline for Real-Time GPU Ray Tracing

presents Disney Animation’s solution for handling massive Ptex datasets (1.5 TB) in GPU ray tracing using only 2 GB of GPU VRAM
employs a fast LRU eviction scheme and caps GPU cache size to maintain zero-stall experience while preserving texture detail

wayback-archive

AMD releases Vulkan support for Dense Geometry Format

introduces VK_AMDX_dense_geometry_format, a provisional Vulkan extension for using pre-compressed DGF data in acceleration structure builds
eliminates performance and memory costs of separate decoding steps by providing DGF data directly to the GPU
improves BLAS build time and reduces memory footprint on hardware with native DGF support

wayback-archive

SIGGRAPH - NVIDIA Research Special Address

NVIDIA AI Research Leaders present the latest breakthroughs in computer graphics and Physical AI
Topics will include advancements in data generation, and their impact across industries from media to manufacturing

A Vulkan on Metal Mesa 3D Graphics Driver

announces KosmicKrisp, LunarG’s new Vulkan driver for Apple hardware built within the Mesa 3D framework
targets Vulkan 1.3 conformance level

wayback-archive

Khronos Group Announces Inaugural Shading Languages Symposium

announces the first-ever Shading Languages Symposium scheduled for February 12-13, 2026, in San Diego, California
Representative for GLSL, HLSL, MSL, OSL, Slang, SPIR-V, and WGSL will be in attendance
Call for submission is open

wayback-archive

Half-baked: Probe warping

explores a technique for “warping” probe data to approximate lighting information at different spatial locations
describes an algorithm that uses planes and ray intersections to reproject cubemap data, similar to parallax mapping but applied to spherical probes
presents a ShaderToy implementation that demonstrates the concepts

wayback-archive

[video] 5 Ways To Make An Awesome Skybox In Unity

video tutorial demonstrating five different techniques for creating compelling skyboxes in Unity
covers various approaches from basic cubemap setups to more advanced procedural and dynamic skybox implementations
provides practical tips for achieving high-quality atmospheric effects and environment lighting in Unity projects

[video] Analyze First, Then Optimize - Game Optimization - Episode 4

video emphasizing the importance of profiling and analysis before starting on the implementing of performance optimizations
discusses methodologies for identifying performance bottlenecks rather than making assumptions
provides guidance on using profiling tools and data-driven approaches to make informed optimization decisions

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 402 - August 3rd, 2025

Sun, 03 Aug 2025 04:00:00 +0000

Quadric-Based Silhouette Sampling for Differentiable Rendering

presents an improved technique for silhouette sampling in physically based differentiable rendering
introduces new rejection test methods using bounding boxes in dual space and dual quadrics
achieves significant variance reduction compared to previous edge sampling approaches

wayback-archive

Perfecting anti-aliasing on signed distance functions

explains techniques for implementing anti-aliasing with signed distance functions (SDFs)
compares linear, smoothstep, and smootherstep transitions for both pixel-wise AA and blur effects
demonstrates how to use numerical derivatives with fwidth() to maintain consistent AA regardless of perspective
additionally presents the effect of color space choices

wayback-archive

[video] Integrating ImGui with Vulkan: Step-by-Step Guide

Video showing detailed implementation of Dear ImGui into a Vulkan graphics engine
covers setup process including descriptor management, render pass integration, and input handling
presents how to use the system to allow parameter adjustments

Our Workflow with Blender and Godot

details the Studio’s Blender-based asset pipeline using Godot
explains their DCC-centric approach using glTF as the exchange format with collection exports for asset management
discusses custom extension code that handles automated export/import workflow and proper asset separation

wayback-archive

SIGGRAPH - OpenUSD Day

SIGGRAPH 2025 will feature a full day dedicated to OpenUSD sessions and hands-on labs
For the first time, NVIDIA will offer OpenUSD certification in person (free for attendees)
Sessions will explore how leading companies are leveraging OpenUSD for applications in simulation, robotics, and Industrial AI.

Debugging AMD-Specific Issues with Driver Experiments Tool

Introduces the Driver Experiments feature in the Radeon Developer Panel for debugging GPU issues
explains how to use the “Force NonUniformResourceIndex” experiment to detect missing shader qualifiers
details the experiments that allow disabling of color and depth compression to identify render target barrier issues

wayback-archive

gpu conditionals - 2025

explains why ternary operators and if statements don’t cause branch instructions for simple value selection
demonstrates through disassembly that these operations use conditional moves rather than actual branching

wayback-archive

Fun with MeshBlend!

proposes a screen-space approach similar to SSAO that samples and blends material properties from nearby surfaces
demonstrates how understanding the core concept of ideas can lead to innovative solutions

wayback-archive

Steerable Perlin Noise

presents a modification to classic Perlin noise, allowing directional control over the pattern generation
includes implementation details with ShaderToy examples showing practical applications
demonstrates how the technique can be used for creating oriented textures and controlled flow patterns

wayback-archive

Toroidally Progressive Stratified Sampling in 1D

introduces a technique that combines stratified sampling with golden ratio sequence ordering
creates sampling patterns that maintain good quality at any sample count and across sequence boundaries
compares error convergence with standard white noise

wayback-archive

[video] Preproduction Optimization Steps - Game Optimization - Episode 3

Third episode in a game optimization series focusing on strategic performance planning during pre-production
discusses establishing performance budgets across the target platforms
How to develop optimization strategies before production
explains how to identify potential bottlenecks early through prototyping and setting clear technical constraints

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 401 - July 27th, 2025

Sun, 27 Jul 2025 04:00:00 +0000

[video] The Graphics Pipeline and Rendering Types - Game Optimization - Episode 2

Second episode in a game optimization series covering the graphics pipeline and different rendering approaches
explains the stages of the graphics rendering pipeline
discusses the differences between deferred and forward shading and how they impact performance characteristics

Decoding: Phosphor

Technical breakdown of a 258-character shader that creates glowing, fluid particles using raymarching and turbulence techniques
explains how the compact code handles raycasting, 3D rotation, camera displacement, and particle distribution

wayback-archive

Profiling without Source code – how I diagnosed Trackmania stuttering

describes how to diagnose stuttering issues in Trackmania using profiling tools without access to the source code
uses Superluminal profiler to identify patterns and library calls to track down performance bottlenecks
demonstrating how performance analysis can work without debug symbols

wayback-archive

Neural Importance Sampling of Many Lights

SIGGRAPH 2025 paper presenting a neural approach for estimating spatially varying light selection distributions in many-light scenarios
uses a neural network trained to predict light selection distributions based on local information
integrates with light hierarchy techniques and introduces residual learning to accelerate convergence during training

wayback-archive

[video] But how do AI images/videos actually work? | Guest video by WelchLabsVideo

Educational breakdown of how AI image and video generation systems function under the hood
explains the mathematical and algorithmic foundations behind diffusion models and neural networks used for content generation
tries to explain and develop intuitions into the process from noise to coherent images, covering training methodologies and inference techniques

Jobs

Intermediate C++ Programmers
Remote (UK only)

Here at JECO, we’re building automated optimisation tools for all software, on any device, starting with video games - saving hours of developer time, costs and carbon emissions. We’re currently looking for purpose-driven and talented Intermediate C++ Programmers to join our team and work on developing our industry-first tools.

Would you like to advertise your job openings here too? More information

Shipping WebGPU on Windows in Firefox 141

announces Mozilla’s release of WebGPU support on Windows in Firefox 141, bringing modern GPU access to the web
built on the WGPU Rust crate, providing a unified interface to Direct3D 12, Metal, and Vulkan across platforms
discusses ongoing performance improvements

wayback-archive

[video] GPU Programming and Language Design with Chris Lattner

interview with LLVM and Swift creator Chris Lattner discussing GPU programming languages and their design challenges
explores the evolution of GPU programming models and the unique constraints that influence language design for parallel computing
focuses on the work on the Mojo programming language that allows CPU+GPU execution without CUDA

Graphics Programming Conference

The Graphics Programming Conference in Breda for November 18th-20th, 2025, has announced its first set of talks
covers topics ranging from real-time path tracing and volumetric rendering to GPU particle systems and mobile game optimization
There are still a couple of days left to submit a talk

wayback-archive

Thanks to Nathan Reed for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 400 - July 20th, 2025

Sun, 20 Jul 2025 04:00:00 +0000

[video] Game Optimization - Introduction & General Principles - Episode 1

first episode in a series covering game optimization principles
why you should optimize, who should optimize, and when you should optimize
introduces fundamental concepts and methodologies for optimizing game performance

[video] How to optimize your Niagaras - Paweł Charzyński || 11Bit Studios ||

presentation on optimizing Niagara particle systems in Unreal Engine
covers structures, material instances, shader, and emitter complexity
provides practical techniques to reduce GPU and CPU overhead in complex VFX

[video] Once Upon a Pixel: How Crysis Changed Real-Time Lighting Forever

The video presents a discussion of Screen Space Ambient Occlusion technique implementation
shows how to implement the technique using OpenGL and GLSL
explains the intermediate steps and required theory along the way

[video] Physically Based Rendering: Putting Pieces Together - Paweł Stolecki || CD Projekt Red ||

The talk focuses on he foundation and core concepts of physically based shading
focusing on the interconnection of concepts and making it easy to understand the concepts visually

Generative AI model for Global Illumination effects

presents a diffusion-based approach for generating reflective caustics
utilizes a latent-space diffusion model conditioned on geometry, material, and illumination data

wayback-archive

[video] Casey Muratori – The Big OOPs: Anatomy of a Thirty-five-year Mistake – BSC 2025

critical analysis of object-oriented programming paradigms and their impact on software development
examines historical context and technical drawbacks of OOP that have persisted for a long time
proposes alternative approaches for practical problem-solving

[video] Multiple Worlds, One Screen: recreating SplitFiction’s Trick in Unity

demonstrates how to implement a portal rendering technique such as found in SplitFiction
explains Stencil Buffer and how to use it to render multiple portal worlds
Implementation is shown using Unity
Portal shapes are implemented using SDF shapes

[video] The Future of Analytical Materials in a Neural World

presents a look at how real-life material complexity is approximated in rendering
discusses the importance of layered material models for the appearance
examines the evolving relationship between traditional analytical material models and neural rendering approaches
explores hybrid approaches that combine the predictability of analytical models with the expressiveness of neural networks

[video] SSAO, Close Enough since 2007 | A Brief History

discusses a history of Screen space ambient occlusion
shows visual examples of the techniques and how they affected the generated results
covering the developments from Crytek SSAO, over HBAO, GTAO, to VBAO

Thanks to Nathan Reed for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 399 - July 13th, 2025

Sun, 13 Jul 2025 04:00:00 +0000

Hallucinations on the future of real-time rendering

presents the argument that rendering industry is shifting from technology-driven growth to content delivery and user-generated content as primary revenue drivers
discusses the role of machine learning in rendering, noting its effectiveness in post-processing but limited impact on core algorithms due to existing analytical solutions
predicts future trends toward “more real-time, less baking” approaches and advances in dynamic data structures for optimal signal representation

wayback-archive

How does a screen work?

explores the technical foundations of digital display technology
covers the evolution from electron guns to modern displays
examines how pixels and color systems work in todays screens

wayback-archive

Using the Matrix Cores of AMD RDNA 4 architecture GPUs

explains how to use Wave Matrix Multiply Accumulate (WMMA) operations on AMD RDNA 4 GPUs
covers the simplified VGPR layout compared to RDNA 3 and the new intrinsics for 16x16 matrix operations
provides practical examples including multi-layer perceptron (MLP) implementation using WMMA for neural network inference

wayback-archive

Introducing Skia Graphite: Chrome's rasterization backend for the future

announces the launch of Skia Graphite as Chrome’s new rasterization backend
explains how Graphite improves upon the previous Ganesh backend with better multithreading and depth testing for 2D graphics
details performance improvements and future development plans

wayback-archive

The Art Of Packing Data

comprehensive guide to efficiently packing various data types commonly used in graphics programming
covers techniques for normalized data, floating point formats, bitfields, and specialized encoding methods for normals and world positions
provides HLSL code examples and GPU instruction analysis on RDNA hardware

wayback-archive

Lossless Float Image Compression

compares lossless compression techniques for multi-layer floating point images
evaluates OpenEXR, JPEG-XL, and a custom approach using mesh optimizer with zstd
presents that mesh optimizer combined with zstd provides really good performance-to-compression ratio results

wayback-archive

HyAB k-means for color quantization

presents a new approach to color quantization using the HyAB distance formula in CIELAB color space
compares results against exisitngs methods
demonstrates how a hybrid distance metric (absolute difference in lightness, Euclidean in chromaticity) improves color fidelity in quantized images

wayback-archive

Padding Transparent Textures for MIPs and Game Engines

addresses visual artifacts that occur with transparent textures have unintetional RGB values in transparent areas during mipmapping
presents a Python tool that pads transparent textures by bleeding opaque pixels outward to fix rendering issues
explains the difference between premultiplied and straight alpha workflows and their impact on texture processing

wayback-archive

[video] Matrices are tensors | Tensor algebra episode 4

video exploring the mathematical relationship between matrices and tensors
covers tensor algebra concepts that extend beyond traditional matrix operations
presents mathematical foundations useful for understanding advanced graphics and machine learning algorithms

Algorithms for making interesting organic simulations

detailed explanation of physarum-inspired algorithms for creating organic-looking simulations and visual effects
provides implementation details including GPU shader techniques, interactive experiments, and artistic applications for real-time organic pattern generation

wayback-archive

[video] I3D 2025 Papers Session 6 - Neural & Splatting

video recording of research paper presentations from the Interactive 3D Graphics and Games (I3D) 2025 conference
features cutting-edge research on neural rendering techniques and Gaussian splatting methods
showcases the latest developments in neural graphics and real-time rendering technologies

[video] I3D 2025 Papers Session 4 - Filtering & Reconstruction

research presentations from I3D 2025 conference focusing on advanced filtering and reconstruction techniques
covers state-of-the-art methods for image and signal processing in real-time graphics applications
presents novel approaches to improving quality and performance in interactive 3D rendering

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 398 - July 6th, 2025

Sun, 06 Jul 2025 04:00:00 +0000

The Sad State of Hardware Virtual Textures

Explains the concept and motivation behind virtual textures for efficient GPU memory use
Compares software and hardware implementations, highlighting current hardware limitations
benchmarks sampling and tile updating performance between different hardware and driver versions
shows that Intel’s drivers are the only ones with tile update performance that appears viable for real-time applications

wayback-archive

Real-time Image-based Lighting of Glints

Proposes a real-time method for rendering glints using image-based lighting
Introduces a fast environment map filtering technique for dynamic materials and lighting

wayback-archive

[video] Global Illumination for Poor People | TurboGI Devlog

the developers’ vlog discusses the implementation process of screen space global illumination
presents various techniques and stages of the implementation process
shows performance and quality differences between the various parts of the implementation

[video] REAC 2025 Introduction to the conference

The video introduces the REAC 2025 conference
discusses the underlying idea and philosophy of the conferences
provides an overview of the content and presents the schedule
All videos are available on the channel now

[video] The Magnetic Shadow Effect

The video provides a visual explanation for shadowing terms such as umbra and penumbra
shows how bokeh and lights for near and far objects interact to create the appearance that light and shadows are attracted by each other

[video] Intro To Terrain Generation

The video provides a high-level overview of how to implement a terrain generation vertex shader
discusses how to further develop this basic technique in various aspects
Additionally, announces a coding jam based on the project

[video] REAC 2025 Evolving Global Illumination in Overwatch 2

covers the Overwatch team’s journey to modernize their global illumination (GI) solution
discusses tradeoffs in quality, performance, and workflow for GI in a large-scale game
Details the transition to a new approach that improves artist workflow while maintaining visual quality
shares challenges and solutions for supporting a wide range of hardware

[video] REAC 2025 RE ENGINE Meshlet Rendering Pipeline

explains the meshlet rendering pipeline used in Dragon’s Dogma 2 and Monster Hunter Wilds
addresses challenges of rendering vast, dynamic environments with stable performance
Details the transition to meshlets across shared engine technology
compares early and current meshlet implementations and shares optimization results

[video] REAC 2025 Geometry rendering and shaders infrastructure in Warhammer 40000: Space Marine 2

Details the geometry rendering pipeline and data management in Swarm Engine for Space Marine 2
addresses challenges of rendering dense architecture, procedural vegetation, and many interactive entities
Discusses system organization for future optimizations and features
Explains shader infrastructure and managing the complexity of Uber shader permutations
shares lessons learned in balancing scalability, performance, and visual complexity

[video] REAC 2025 Anvil Rendering Architecture

presents Anvil’s evolution into a centralized engine powering multiple productions from a monorepo
discusses technical and organizational challenges: modularization, shader complexity, code divergence
details the rendering architecture as well as the GPU-driven mesh pipeline and frame graph
covers performance optimization, profiling tools, and data-driven tuning via a centralized platform manager

[video] REAC 2025 Dragon Age: The Veilguard - GI, RT, Character Creator and other systems

presents architectural challenges and decisions for GI, ray tracing, and character creator in Dragon Age: The Veilguard
covers probe baking system, team size, and asset constraints
discusses ray tracing implementation choices and support for a wide range of GPUs
details the technical and practical aspects of the character creator tool

Thanks to Peter Kohaut for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 397 - June 29th, 2025

Sun, 29 Jun 2025 04:00:00 +0000

Real-Time GPU Tree Generation

the paper presents a work graph-based procedural system for generating and rendering trees entirely on the GPU
shows how the model used to generate the tree structure
presents how this is mapped onto the work graph execution logic
additionally discusses how seasonal effects and wind effects are integrated

wayback-archive

Real-Time Importance Deep Shadows Maps with Hardware Ray Tracing

introduces Importance Deep Shadow Maps (IDSM), a real-time algorithm for rendering shadows of semi-transparent objects
adaptively distributes shadow samples based on camera importance
achieves significant speedups over hardware ray tracing while maintaining visual fidelity

wayback-archive

CUDA Ray Tracing 2x Faster Than RTX: My CUDA Ray Tracing Journey

an article discusses optimizing a CUDA-based ray tracer to outperform Vulkan/RTX implementations on the same hardware
demonstrates how aggressive inlining, branchless material evaluation, and custom RNGs yield significant speedups
provides benchmarks and practical advice for optimizing ray tracing performance
additionally, it presents a discussion of how to interpret the results

wayback-archive

Performance Profiling on AMD GPUs – Part 1: Foundations

provides an introduction to profiling and optimizing applications on AMD GPUs for ROCm workloads
outlines key tools in the ROCm ecosystem for tracing, counter collection, and kernel analysis

wayback-archive

Blackwell: Nvidia’s Massive GPU

provides an in-depth analysis of Nvidia’s Blackwell GPU architecture
compares Blackwell’s design, memory subsystem, and compute performance to AMD’s RDNA4
discusses architectural tradeoffs, cache design, and the implications for high-end GPUs

wayback-archive

Intent to ship: WebGPU on Windows

announces Mozilla’s plan to ship WebGPU in Firefox 141 on Windows
notes that WebGPU is already enabled in Firefox Nightly and will expand to other platforms

wayback-archive

Getting Started with Slang: Reflections API

virtual meet-up that will introduce the Slang shader reflection API
going to highlight common pitfalls and best practices for accessing shader metadata

wayback-archive

[video] RE ENGINE Meshlet Rendering Pipeline

the very detailed presentation discusses the geometry rendering pipeline on the RE ENGINE
covers meshlet rendering, software rasterization, visibility buffers, shadow rendering, and more
additionally contains Questions and Answers documents from the audience and developers

wayback-archive

[video] The Buffer Offset Alignment Crisis // Vulkan For Beginners #22

the video discusses the alignment requirements for Buffers in Vulkan
explains why a validation error message appears and how to resolve it
shows why the problem happens and how to resolve it in practice

[video] I3D 2025 Papers Session 3 - Animation & Voxels

video recording of I3D paper presentations
covering Hierarchical Neural Skinning Deformation with Self-supervised Training for Character Animation, Foveated Animations for Efficient Crowd Simulation
Aokana: A GPU-Driven Voxel Rendering Framework for Open World Games as well as Transform-Aware Sparse Voxel Directed Acyclic Graphs

Thanks to JanHaraldFredriksen for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 396 - June 22nd, 2025

Sun, 22 Jun 2025 04:00:00 +0000

Basic facts about GPUs

provides a concise overview of fundamental GPU concepts
covers topics such as memory hierarchy, compute units, and parallelism
includes practical notes for developers new to GPU programming

wayback-archive

No More Shading Languages: Compiling C++ to Vulkan Shaders

the paper presents the implementation of a C++ to SPIR-V compiler
discusses limitations of language constructs, how contracts are mapped onto SPIR-V
shows how raytracing callable shaders can be used to implement function-calling

wayback-archive

Enhancing AMD Radeon GPU Detective Output with DirectX Debug Information

explains how to enhance AMD Radeon GPU Detective output with DirectX debug information
details the process of mapping GPU crash dumps to HLSL source code for easier debugging
provides step-by-step instructions and practical tips for integrating debug info into the workflow

wayback-archive

Real-time rendering of animated meshless representations

the paper discusses methods to animate meshless representations efficiently
the paper suggests a coarse tetrahedral mesh surrounding the meshless objects, skinned as usual
this deformation of the rest pose is then applied to the full volume using interval shading

wayback-archive

Adaptive Tetrahedral Grids for Volumetric Path-Tracing

introduces adaptive tetrahedral grids for efficient volumetric path tracing
explains the grid construction and sampling process
demonstrates improved performance and quality in volumetric rendering tasks

wayback-archive

[video] SIGGRAPH 2025 Technical Papers Trailer

the video presents a brief overview of various papers that will be presented at SIGGRAPH 2025
covers a large number of various topics from Gaussian splatting, scene representations, soft body physics, and much more

REAC - 2025 Conference - Slides

slides from the 2025 REAC conference have been published
covers topics such as GI, meshlet rendering, anvil rendering architecture, and more

wayback-archive

Graphics Programming Conference - 2025 - Participate

an invitation to participate in the 2025 Graphics Programming Conference
outlines submission guidelines and participation opportunities
encourages community involvement and knowledge sharing

wayback-archive

Thanks to Vivitsu Maharaja for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 395 - June 15th, 2025

Sun, 15 Jun 2025 04:00:00 +0000

SIGGRAPH 2025 Course: Physically Based Shading in Theory and Practice

announces the latest SIGGRAPH course on physically based shading, featuring new research and practical advice from film and game production
covers topics such as energy-conserving models, spectral rendering, neural materials, and production hair shading
includes the course timetable and presenter list

wayback-archive

Khronos Announces Vulkan Video Decode VP9 Extension

introduces the VK_KHR_video_decode_vp9 extension for Vulkan, enabling hardware-accelerated VP9 video decoding
explains why VP9 is one of the simpler codecs to implement and recommends it for getting started
supported by major GPU vendors and open-source drivers, with SDK and sample updates coming soon

wayback-archive

VK_KHR_unified_image_layouts

presents a Vulkan extension that simplifies image layout management by allowing VK_IMAGE_LAYOUT_GENERAL to be used in most cases
reduces the need for explicit image layout transitions to simplify synchronization
discusses how some hardware doesn’t distinguish between image layouts, so not using the specific layouts doesn’t cause performance issues

wayback-archive

Derivatives of Spherical Harmonics

presents formulas for efficiently computing partial derivatives of any order for spherical harmonics
shows that intermediate results from the standard evaluation can be reused, reducing the computation cost significantly
includes links to a poster, supplemental document, and code for practical use

wayback-archive

Voronoi, Hashing and OSL

explores the optimization of Voronoi noise in Blender by switching from an older Jenkins hash to a faster PCG3D hash
highlights challenges with Open Shading Language (OSL) lacking unsigned integers and bit casts and how these were worked around
concludes with lessons learned about hash functions, code maintenance, and shading language limitations

wayback-archive

From SDR to Fake HDR: Mario Kart World on Switch 2 Undermines Modern Display Potential

analyzes Mario Kart World’s HDR implementation on Switch 2, revealing it uses static tone mapping and SDR color gamut
details the pitfalls of SDR-first pipelines and how they limit dynamic range and color volume
offers recommendations for developers to adopt HDR-first workflows and dynamic tone mapping for better results

wayback-archive

On Shaping Light

provides a comprehensive walkthrough of implementing volumetric lighting using raymarching and post-processing
covers coordinate system transformations, depth-based stopping, shadow mapping, and shaping light with SDFs
explores light scattering and multi-light setups with interactive demos and code examples
discusses practical applications and artistic effects achievable with these techniques in 3D scenes

wayback-archive

Rendering Crispy Text On The GPU

presents an approach to real-time text rendering on the GPU, focusing on quality and subpixel anti-aliasing
discusses a system that rasterizes glyph curves directly to an atlas with temporal accumulation
provides code samples, visual comparisons, and practical advice for high-quality, efficient text rendering

wayback-archive

[video] Aliasing... Or How Sampling Distorts Signals

the videos break down what aliasing is and why it happens when sampling signals
presents how this can lead to distorted or misleading results
shows a walkthrough with intuitive visualizations and concrete examples to show how high-frequency signals can appear misleading if sampled at a too-low frequency

[video] WWDC25: Unlock GPU computing with WebGPU | Apple

the video presents an overview of the WebGPU API
discussing the capabilities of the API, supported platforms, and limitations
additionally provides guidelines to follow for best performance

[video] Speaking the GPU's Language | Indirect Rendering

the video presents an overview of GPU architecture
explaining overhead in GPU processing
how indirect drawing allows more flexibility and enables more workloads to be executed efficiently
additionally discusses vertex optimizations for efficient rasterization

Thanks to Mike Turitzin for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 394 - June 9th, 2025

Mon, 09 Jun 2025 04:00:00 +0000

[video] Rendering Assassin's Creed Shadows

details the rendering techniques used in the latest Assassin’s Creed game
explores the GPU-driven rendering pipeline, micro polygon rasterization, global illumination implementation
presents how the weather system was implemented in a deferred pipeline fashion
additionally presents a brief look at how the team manages platform differences and performance tracking

[video] Quaternions - Freya Holmer | NGJ2025

talk from Nordic Game Jam 2025 providing an intuitive explanation of quaternion mathematics
breaks down quaternion concepts using visual examples and practical applications in game development
demonstrates techniques for visualizing rotations
additionally presents how rotation order/axis orders vary between different popular game engines

Fast camera space to screen space direction transform

presents a mathematical derivation for efficiently transforming direction vectors from camera space to screen space
reduces computation from 32 multiplies, 24 additions/subtractions, and four divides to just six multiplies and two subtractions

wayback-archive

[video] Coding Adventure: Software Rasterizer

walks through the implementation of a CPU-based software rasterizer
covers techniques for triangle rasterization, projections, depth buffering, basic lighting
explains the underlying theory with visual explanations before presenting the implementation

BVH Quality: Beyond SBVH

investigates techniques to improve Bounding Volume Hierarchy (BVH) quality
challenges common assumptions about binned vs. full-sweep SAH building and demonstrates that bin count significantly impacts performance
introduces Representative Ray Sets (RRS) for BVH quality assessment and optimization, showing that significant performance improvements ( >50% ) are possible
opening the discussion that offline builds of optimized static geometry BVHs might be worthwhile to explore

wayback-archive

Async compute all the things

explores asynchronous compute techniques to improve GPU utilization by executing compute and graphics workloads in parallel
explains the implementation details of scheduling work on separate command queues and synchronizing between them using fences
provides practical examples of work pairing that benefits from async compute and how to measure performance gains

wayback-archive

D3D12 Shader Execution Reordering

introduces Shader Execution Reordering feature for Shader Model 6.9
explains how SER allows application developers to provide hints that will enable drivers to optimize execution patterns for DXR workloads
provides example code that presents the feature in shader code and how to use it from the D3D12 API
additionally discusses the state of driver support

wayback-archive

D3D12 Opacity Micromaps

introduces Opacity Micromaps (OMMs) for DirectX 12 ray tracing to accelerate alpha-tested geometry
details how OMMs encode alpha mask information at different resolutions to skip unnecessary ray-triangle tests
provides implementation explanations, first example implementations, and performance data for foliage scenes

wayback-archive

D3D12 Cooperative Vector

presents DirectX 12’s new cooperative vector instructions
discusses how these instructions allow developers to take advantage of additional hardware features (such as Nvidia Tensor Cores)
shows how to check for the availability of support and how the API allows developers to encode the data into the hardware-required formats

wayback-archive

[video] Cloth Animation Using The Compute Shader

the video tutorial implements a physics-based cloth simulation on the GPU using compute shaders
discusses how to structure the mesh for connectivity as well as how to handle constraints solving to simulate springs
covers both the theory as well as the implementation

Shaders for Vulkan samples now also available in slang

announces the addition of Slang shader language support for the Vulkan samples repository
discusses the experience of using Slang for shader development

wayback-archive

Thanks to Robert Wallis for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 393 - May 25th, 2025

Sun, 25 May 2025 04:00:00 +0000

[video] Getting Started with Slang: Draw Your First Splat

introductory video tutorial on using Slang shader language to render a basic Gaussian splat
provides a beginner-friendly walkthrough from setup, to convering the Slang language essential and application iintegration
takes these concepts to explain how to render a basic Gaussian splat training process from python

[video] Dynamic Rendering // Vulkan For Beginners #21

tutorial on Vulkan’s dynamic rendering feature that simplifies rendering without framebuffers
explains how to transition from traditional render passes to the more streamlined dynamic rendering approach

logdahl.net / 27'000 dragons and 10'000 lights: GPU-Driven Clustered Forward Renderer

demonstrates the implementation of a GPU driven renderer
explains GPU-based culling, draw call generation using indirect drawing as well as buffer compaction
details implementation of clustered forward shading with optimized light assignment using subgroup operations

wayback-archive

SOBB: Skewed Oriented Bounding Boxes for Ray Tracing

introduces Skewed Oriented Bounding Boxes (SOBB) for ray tracing acceleration
presents an efficient algorithm for transforming standard AABB BVHs into SOBB representations
demonstrates performance improvements of 1.0-11.0x over AABB BVH and 1.1x over OBB BVH for secondary rays, with similar memory requirements to AABBs

wayback-archive

Particle Life simulation in browser using WebGPU

implements a WebGPU-based particle simulation that creates emergent life-like behaviors through asymmetric attraction/repulsion forces
describes optimization techniques like spatial binning and parallel prefix sum for computing inter-particle forces efficiently
discusses rendering approaches with anti-aliasing for both large and sub-pixel particles with glow effects

wayback-archive

Grass Rendering Series Part 3: Animating and Interacting With Grass in Godot

explains techniques for animating grass through wind effects by simulating gusts using noise textures
details how to implement player interaction with grass, making it bend away from objects and characters
also covers an approach for cutting grass dynamically

wayback-archive

[video] Colored Pencil Rendering - Custom Lighting Models - Episode 18

continues the custom lighting model series with techniques to simulate colored pencil art style
presents shader methods for recreating the grainy texture and stroke patterns of traditional colored pencil drawings
demonstrates implementation in both Unity and Unreal Engine using the visual shading language

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 392 - May 18th, 2025

Sun, 18 May 2025 04:00:00 +0000

A Zero-Level Set Preserving Technique for Signed Distance Function Computation from an Implicit Surface

presents a technique for computing signed distance functions (SDFs) from implicit surfaces
ensures the shape of the surface is maintained during the conversion
the proposed solution uses neural networks to minimize loss functions characterizing the SDF

wayback-archive

JCGT is moving along

Eric Haines shares updates on the Journal of Computer Graphics Techniques (JCGT)
presents the updates behind the scenes that allowed nine papers to be published so far this year
maintains “Diamond Open Access” with authors retaining copyright under Creative Commons licensing

wayback-archive

Path Tracing Optimizations in Indiana Jones™: Opacity MicroMaps and Compaction of Dynamic BLASs

details GPU optimizations that improved path tracing performance in Indiana Jones
presents how Opacity MicroMaps (OMMs) reduced overhead for alpha tested geometry and which issues they ran into during the integration
additionally mentions that compaction of Bottom-Level Acceleration Structures (BLASs) halved the memory consumption for vegetation meshes

wayback-archive

Temporal Super Resolution via Multisampling

builds upon upsampling via multisampling by adding a temporal component
renders a 4x MSAA image at 1080p and upsamples to 4K using a 4-frame jitter pattern
presents a detailed look at the sample distribution, implementation and discusses quality and limitations

wayback-archive

Traditional and Neural Order-Independent Transparency

Eurographics 2025 tutorial on Order-Independent Transparency (OIT) techniques
covers traditional approaches (exact, approximate, and hybrid) and deep learning-based methods
compares performance, accuracy, and practical applications for rendering transparent objects

wayback-archive

Palette lighting tricks on the Nintendo 64

describes a technique that applies lighting to color palettes instead of individual texels
enables normal mapping and directional lighting effects on limited N64 hardware
shows techniques to hide inherent limitations with the technique

wayback-archive

Drawing Landscape

the article presents a walkthrough on how to render a 3D terrain using SDFs
discusses how to generate the terrain, apply texturing and shading
interactive source code examples are provided

wayback-archive

[video] Measuring Custom Lighting Performance - Custom Lighting Models - Episode 17

video covering how to setup a test to measure the performance of lighting models
presents how different features of the shading model affect the performance
shows the visual results of the different combinations

Neural Image Reconstruction for Real-Time Path Tracing

presents a walkthrough of research building a unified neural denoising and supersampling technique
shows the development steps, integration into existing rendering pipelines and results in various test scenes
discusses challenges in preserving texture details, reducing flickering, and handling disocclusions

Lipschitz Pruning: Hierarchical Simplification of Primitive-Based SDFs

introduces an efficient method for simplifying tree-based analytical Signed Distance Fields (SDFs)
leverages the Lipschitz property to create simplified equivalents for specific regions of space
proposes a new technique for sphere tracing of complex SDFs composed of thousands of animated primitives
the included video visualizes the technique and shows results on various test cases

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 391 - May 11th, 2025

Sun, 11 May 2025 04:00:00 +0000

Importance-Sampled Filter-Adapted Spatio-Temporal Sampling

JCGT paper presenting a technique for generating optimized samples with good spectral properties
presents the improved results for depth of field with complex bokeh shapes
shows how to calculate the samples and the effect on quality and performance

wayback-archive

Reservoir Sampling

Clear explanation of reservoir sampling for selecting k random samples from data streams of unknown size
Uses interactive visualizations to demonstrate the algorithms and its behaviour
Additionally presents how the technique can be applied to a log processing service

wayback-archive

Mipmap selection in too much detail

Comprehensive exploration of how GPUs select appropriate mipmap levels when sampling textures
Discusses linear filtering, anisotropic filtering, trilinear filtering, and mathematical foundations with visual comparisons
Many visual examples to visualize the equations discussed

wayback-archive

Noise is Beautiful: Part 1: Procedural textures

open access book focusing on the foundations and applications of procedural noise for texture generation
Focuses on theory and implementation of algorithms that enable procedural texturing workflows
Demonstrates how basic primitives can be combined to create natural-looking textures for various applications

wayback-archive

Neural Two-Level Monte Carlo Real-Time Rendering

The paper introduces a two-Level monte carlo estimator for global illumination(GI)
Discusses the Neural Incident Radiance Cache (NIRC) that uses a small neural network that is trained on-the-fly to learn incoming light from all directions

wayback-archive

Understanding The Math Behind ReSTIR GI

Technical deep-dive explaining the mathematical foundations of ReSTIR GI for efficient real-time path tracing
Includes code snippets, visualizations, and mathematical derivations making the concepts more approachable
additionally clarifies the limitations of the technique

wayback-archive

ReSTIR-Sampled Shadow Maps

The paper combines ReSTIR (Reservoir-based Spatio-Temporal Importance Resampling) with shadow mapping for complex lighting
the selection strategy generates shadow maps for lights with the strongest contributions to pixels in the current camera view
and falls back to imperfect shadow maps to provide low-resolution shadow approximations

wayback-archive

Using Neural Networks for Geometric Representation

The article explores neural representations for 3D geometry
Discusses the Neural Intersection Function that allows BVH traversal to operate as part of the raytracing pipeline
Discusses the limitations and how Locally-Subdivided Neural Intersection Function can overcome these

wayback-archive

Implicit UVs: Real-time semi-global parameterization of implicit surfaces

The paper presents a technique for creating UV mappings directly on implicit surfaces without traditional mesh parameterization
Uses local-uv fields that are smoothly blended to enable continuous parameterizations

wayback-archive

Meshlets and Mesh Shaders

exploration of mesh shader implementation and performance benefits in modern graphics pipelines
Provides benchmarks with different meshlet/thread group configurations and code examples for amplification and mesh shaders
uses nvidia hardware counters to present the results of the various experiments

wayback-archive

Boosting GPU Radix Sort performance: A memory-efficient extension to Onesweep with circular buffers

The blog post discusses GPU radix sort techniques
Starting with a classical radix sort implementation and an overview of the improved onesweep implementation
Explains how this technique can be extended to work within a fixed memory footprint through the use of a ring buffer for look-back storage

wayback-archive

Conquering FidelityFX FSR4 – Enabling the pretty pixels on Linux through maniacal persistence

Blog post describes the journey implementing AMD’s FidelityFX Super Resolution 4 (FSR4) on Linux
Presents how DXIL expresses instruction extensions
Discusses steps required to support 8-bit float and wave matrix multiply accumulate(WMMA) required for the compute shaders

wayback-archive

Minimal GPU video decoding sample for Vulkan and DX12

GitHub repository with minimal implementation examples for hardware-accelerated video decoding with Vulkan and DX12 for H264 videos
Shows how to decode video streams directly on the GPU
Demonstrates interfacing with platform-specific video APIs and synchronizing between decoder and graphics pipeline
source code contains many comments to explain the pitfalls and undocumented behaviours

wayback-archive

Assassin's Creed Shadows

GDC presentation from Ubisoft’s rendering team on advanced graphics techniques in Assassin’s Creed Shadows
Discusses the GPU accessible scene representation (database), GPU driven rendering pipeline and new micropolygon rasterization
Overview of the GI implementation, raytracing abstraction and deep-dive into the implementation
Lastly discusses the deferred weather system

wayback-archive

Thanks to Graham Wihlidal for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 390 - May 4th, 2025

Sun, 04 May 2025 04:00:00 +0000

A Taxonomy for Rendering Engines.

presents a classification system for rendering engines based on their architectural approaches
focuses on the importance of context to discuss decisions and tradeoffs

wayback-archive

Derivation and Intuition behind Poisson distribution

article explaining the foundation of the Poisson distribution
develops an intuitive way to help understanding first and then derives the mathematical model from this

wayback-archive

[video] Sobol' Sequences with Guaranteed-Quality 2D Projections, supplementary video

supplementary video for a research paper on improving Sobol’ sequence quality
visualizes the differences between traditional Sobol’ sequences and ones with guaranteed quality 2D projections
explains the process how to generated improved sequences

testing FBX

benchmark comparing FBX file format parsing libraries: ufbx, Autodesk FBX SDK, AssImp, and OpenFBX
identifies significant performance issues with the official Autodesk FBX SDK, and shows that ufbx is a lot faster

wayback-archive

D3d12info app and online GPU database

introduces a new website displaying D3D12 GPU feature support information across different hardware and drivers
allows easy identification of supported DirectX 12 features on specific hardware configurations
asks developers to submit information to make more data available to the community

wayback-archive

Load-store conflicts

detailed technical article examining performance issues in the index decoder
explores CPU microarchitecture issues related to store-to-load forwarding that occur in specific compiler-generated code patterns
explains how seemingly innocuous code changes by compilers can create serious performance bottlenecks in high-performance code

wayback-archive

Correct application of the Lanczos filter in 2D

comprehensive technical resource clarifying common misconceptions about 2D Lanczos filtering
proves that the correct 2D application of Lanczos is separable and not a radial basis function
addresses practical implementation issues like “deringing”
particularly useful for temporal anti-aliasing and upscaling applications like those in FSR and SGSR

wayback-archive

Real-Time Markov Chain Path Guiding for Global Illumination and Single Scattering

research paper presenting a novel lightweight path guiding algorithm for real-time applications
uses a von Mises-Fisher mixture model controlled by a Markov chain process to represent light distribution
demonstrates effective guiding for both global illumination and single scattering in participating media, with demos in a Quake path tracer

wayback-archive

[video] Mastering Reflection & Refraction In OpenGL

video tutorial on implementing reflection and refraction effects in OpenGL
covers environment mapping, Fresnel effects
explains both the theoretical foundations and practical shader implementations

[video] PS1 Graphics Deep Dive: Implementing Silent Hill Fog In My Real PS1 Game

detailed technical analysis and implementation of the iconic fog effect from Silent Hill on original PlayStation hardware
explains the technical constraints and creative workarounds used in the original game
detailed discussion how to the effect is implemented on PS1 hardware

[video] Film Noir Custom Lighting - Custom Lighting Models - Episode 15

part of an ongoing series about custom lighting models in real-time graphics
focuses on recreating the distinctive high contrast black and white imagery lighting style of film noir
covers techniques for dramatic shadows, stylized highlights, and atmospheric lighting effects
presents the implementation in Unity and Unreal

REAC 2025 Conference - Registration open

announces open registration for REAC 2025, scheduled for June 10-11, 2025 online

wayback-archive

[video] I3D 2025 Papers Preview

preview video showcasing upcoming papers from the I3D 2025 conference
covers a wide range of topics from weather simulation, physics effects, crowd animation, voxel rendering and much more

Thanks to Graham Wihlidal for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 389 - April 27th, 2025

Sun, 27 Apr 2025 04:00:00 +0000

ePBR: Extended PBR Materials in Image Synthesis

this paper introduces a framework that extends PBR materials to handle transparent surfaces like glass and windows
addresses limitations of traditional reflection models that struggle with highly specular and transparent materials
combines advantages of physically-based methods with efficiency by focusing on intrinsic image decomposition
provides deterministic, interpretable control for material editing while maintaining physical plausibility

wayback-archive

[video] Fast Custom Lighting - Custom Lighting Models - Episode 14

This tutorial demonstrates techniques for implementing efficient custom lighting models
targets low-powered mobile devices, or augmented reality headsets
part of an ongoing series exploring custom lighting techniques
shows which features to remove for more efficient calculations

LinPrim: Linear Primitives for Differentiable Volumetric Rendering

this paper explores alternative scene representations using transparent polyhedra (octahedra and tetrahedra) with triangular faces
presents a differentiable rasterizer that efficiently runs on GPUs, enabling end-to-end gradient-based optimization with real-time rendering
achieves comparable quality to state-of-the-art volumetric methods like 3D Gaussians while requiring significantly fewer primitives
the bounded nature of these primitives creates natural compatibility with traditional mesh-based tools for downstream applications

wayback-archive

When Gaussian Meets Surfel: Ultra-fast High-fidelity Radiance Field Rendering

this research introduces Gaussian-enhanced Surfels (GESs), combining 2D opaque surfels for coarse geometry with 3D Gaussians for fine details
the novel two-pass rendering approach is entirely sorting-free, eliminating the computational bottleneck of Gaussian sorting
achieves both ultra-fast frame rates and avoids the popping artifacts commonly seen in other real-time radiance field rendering methods
includes extensions like Mip-GES for anti-aliasing, Speedy-GES for faster rendering, and 2D-GES for compact storage

wayback-archive

[video] Why Did PS1 Games Look Like That?

This video explores the technical reasons behind the distinctive visual appearance of PlayStation 1 games. Especially explaining the effects of the Silent Hill series
focuses on explaining projection from world into projection space, vertex shading, color quantization etc.
Explains the hardware limitations that led to the characteristic polygon wobbling and texture warping

[video] Essential Machine Learning and AI Concepts Animated

this animated video breaks down essential machine learning and AI concepts in a visual, accessible way
uses animations to explain complex algorithms and mathematical foundations behind modern AI systems
helps viewers develop an intuitive understanding of key AI concepts without requiring advanced mathematical background

Thanks to Manish Mathai for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 388 - April 20th, 2025

Sun, 20 Apr 2025 04:00:00 +0000

Reading Math Papers

An approachable guide that demystifies mathematical notation commonly found in graphics research papers
Explains basic notation including summations, products, boolean algebra, and various representations for scalars, vectors, matrices, and tensors
Bridges the gap between mathematical notation and programming implementations, helping shader developers understand and implement published algorithms

wayback-archive

Ubisoft’s Colorblind Simulation Tool, Chroma, Now Available For Public Use

Ubisoft has open-sourced Chroma, their in-house colorblind simulation tool
The tool applies filters over game screens to simulate various types of color blindness in real-time
Designed to help developers assess and improve game accessibility

wayback-archive

NVIDIA GDC talks

Collection of NVIDIA’s latest technical sessions and presentations from Game Developers Conference 2025
Covers a wide range of topics including ray tracing, AI-assisted rendering, graphics optimization techniques as well as more generic AI techniques
Provides insights into how to path trae nanite content

wayback-archive

Combining Shaders

A practical guide to effectively combining multiple shader effects into a single shader pass
Presents a checklist for determining shader compatibility based on performance, sample count, coordinates, textures, and inputs
Explains how to convert shader code into functions and handle the ordering of effects for optimal results

wayback-archive

Monte Carlo Crash Course - Case Study: Rendering

Detailed exploration of Monte Carlo integration techniques applied to rendering, focusing on a simplified 2D light transport model
Covers direct lighting, indirect lighting, and specular reflection with thorough mathematical explanations
Discusses common challenges like fireflies and variance reduction in path tracing implementations

wayback-archive

Machine Learning for Inverse Graphics

Comprehensive course materials from MIT’s “Machine Learning for Inverse Graphics” (6.S980)
Covers fundamental topics in computer vision, graphics, and geometric deep learning, with a focus on neural scene representations
Provides lectures on image formation, 3D scene representations, neural rendering, and self-supervised learning approaches

wayback-archive

DirectX State of the Union: Raytracing and PIX Workflows (Presented by Microsoft)

Microsoft’s latest DirectX roadmap presentation highlighting API advancements and tool updates
Shows updates to work graphs, neural rendering, raytracing 1.2 micromaps and shader execution reodering
summary of Agile SDK updates as well as plans for the HLSL future developments
additionally provides a look at new PIX capabilties as well as PIX API preview release

Loading Models With Assimp // Vulkan For Beginners #20

Part of a Vulkan tutorial series focusing on integration with the Assimp library for model loading
Demonstrates how to process imported model data into Vulkan-compatible vertex and index buffers
Covers handling of materials, textures, and transformations when integrating external 3D assets

Building a Fast, SIMD/GPU-friendly Random Number Generator For Fun And Profit

Detailed exploration of creating efficient random number generators optimized for SIMD and GPU execution
Discusses implementation of a Linear Congruential Generator (LCG) with xorshift operations
additionally presents how to author an SIMD optimized variant

wayback-archive

Thanks to Manish Mathai for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 387 - April 13th, 2025

Sun, 13 Apr 2025 04:00:00 +0000

The Eras of GPU Development

The blog post provides a discussion how hardware and graphics APIs developed over time
Presents performance changes as well as capabilities changes

wayback-archive

To Early-Z, or Not To Early-Z

The article presents a detailed discussion of z-testing in modern GPU hardware
Shows when the hardware is able to move the execution of z-testing before pixel shader invocation and when not
Shows the impact on performance and correctness
Closes with a table showing a summary of the various features that can affect the behavior

wayback-archive

Monte Carlo Crash Course - Sampling

The series on Monte Carlo’s related techniques continues with Monte Carlo Sampling
Presents how to convert Pseudo-Random Numbers into samplers for more complex domains
Covers Uniform Rejection Sampling, Non-Uniform Rejection Sampling, Inversion Sampling, Marginal Inversion Sampling
Additionally talks about Changes of Coordinates and Sample Efficiency

wayback-archive

Improved Stochastic Texture Filtering Through Sample Reuse

Reuse and share samples between different lanes in a shader wave, avoiding memory traffic
Presents a method to improve the quality of stochastically-filtered magnified textures compared to traditional texture filtering

wayback-archive

Bilinear interpolation on a quadrilateral using Barycentric coordinates

The article presents an algebraic solution for bilinear interpolation using Barycentric coordinates to allow improved sampling across triangulated edges
Shows an explanation of the derivation of the method
Additionally contains the code for the implementation

wayback-archive

Reinventing feathering for the Vectorian era

The article presents a discussion of how to approach blurs for vector graphics
Discusses how to rethink the approach instead of using Gaussian blurs
Links to the implementation is provided

wayback-archive

Thanks to Dirk Dörr for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 386 - April 6th, 2025

Sun, 06 Apr 2025 04:00:00 +0000

Grass Rendering Series Part 1: Theory

This series examines various techniques for rendering realistic grass
Part 1 focuses on the theoretical foundations needed to create believable grass
Part 2 demonstrates the practical application of these theories using a geometry-based grass shading model in Godot

wayback-archive

Exponentially Better Integration

This blog post provides a clear explanation of Quadrature and Monte Carlo Integration techniques
Interactive exploration scenarios help readers develop an intuitive understanding of the concepts
The author also explains important statistical concepts like Bias and Consistency

wayback-archive

Graphics programming like it's 2000 – An esoteric introduction to PlayStation 2 graphics – Part 1

This article explores the programming techniques for the PlayStation 2 GPU architecture
The author uses a compute shader emulator to demonstrate how the register-based packet stream draws triangles

wayback-archive

Measuring acceleration structures

This blog post provides an in-depth analysis of raytracing acceleration structures across various hardware platforms and drivers
The author compares structure sizes across different manufacturers and hardware generations
A detailed discussion highlights how hardware vendors and drivers differ in data representation (based on publicly available information)

wayback-archive

[video] Bindless Textures // Intermediate OpenGL Series

This OpenGL programming series continues with an exploration of bindless texture concepts and implementation
The video covers necessary implementation changes for both C++ and GLSL code

Sims 4: Mirrors

The article presents a visual walkthrough of how mirrors are commonly implemented in video games
It uses Sims 4 as a practical example to demonstrate mirror rendering techniques

wayback-archive

Neural Graphics in an Afternoon

This blog post demonstrates how to implement a 2D Gaussian Splatting algorithm using Python
The author explains both the Python and Slang implementation details
The implementation prioritizes clarity and ease of understanding over performance

wayback-archive

Dynamic Register Allocation on AMD's RDNA 4 GPU Architecture

The article examines the new dynamic register allocation capabilities in AMD’s RDNA4 architecture
It details the new instructions and their interaction with wave execution
The author clarifies the limitations of this technique and compares it with NVIDIA and Intel implementations

wayback-archive

Improved filtering added to the Vulkan Hardware Database

This blog post highlights updates to the filtering capabilities of the Vulkan Hardware Database
New filtering options allow users to search by minimum Vulkan version, report age, device types, and layered implementations

wayback-archive

Thanks to Aras Pranckevičius for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 385 - March 30th, 2025

Sun, 30 Mar 2025 04:00:00 +0000

Optimizing copy of null descriptors in D3D12

The blog post analyzes the CPU overhead caused by copying D3D12 descriptors
It demonstrates how to use available APIs to reduce this overhead significantly
Discusses how different hardware tiers handle uninitialized descriptors differently
Explores how various shader compiler options affect performance outcomes

wayback-archive

The DDA Algorithm, explained interactively

The blog post provides an interactive explanation of the Digital Differential Analyzer (DDA) algorithm
Through step-by-step visualizations, it breaks down how the algorithm traverses a grid
Focuses on the 2D case to build intuition before discussing more complex applications

wayback-archive

[video] Forward Plus Additional Lights - Custom Lighting Models - Episode 11

This video tutorial demonstrates how to extend a forward lighting shader to support multiple dynamic lights
Implementation is shown using Unity’s rendering pipeline
Explains the performance considerations and optimizations for handling many light sources

Modern SSAO in a modern run-time

The blog post details the integration of Screen Space Ambient Occlusion into Use.GPU, a reactive GPU authoring system for the web
Showcases the debug pass inspector integration for visual analysis
Explains the technical considerations and implementation choices behind their SSAO approach

wayback-archive

The Mean-ing of Loss Functions

The blog post explores the mathematical and statistical foundations behind common loss functions
Starting with squared error loss, it explains the connection between loss functions and probability distributions
Provides practical guidance on selecting appropriate loss functions based on the underlying assumptions of your data

wayback-archive

RDNA 4's Out-of-Order Memory Accesses

The blog post presents experimental results comparing RDNA3 and RDNA4 memory access models
Demonstrates how RDNA4 resolves false cross-wave dependencies that exist in RDNA3
Includes comparative benchmarks against NVIDIA and Intel hardware to highlight architectural differences

wayback-archive

Thanks to Warren Moore for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 384 - March 24th, 2025

Sun, 23 Mar 2025 04:00:00 +0000

I want a good parallel computer

the blog post discusses the history of parallel GPU hardware developments over time
talks about the limitations of current programming models
as well as upcoming developments like work graphs and other GPU-driven execution models

wayback-archive

Assassin's Creed Shadows: inside the technologically revamped Anvil Engine

the article presents a short interview about the technology of Assassin’s Creed Shadows
the included video contains a lot more details, including debug view insights into the virtualized geometry system
discusses how and why AC ships with two different Global illumination systems

wayback-archive

CUDA: New Features and Beyond

recording from the GTC presentation is available
discusses the current state of the CUDA stack and future developments for performance optimizations across the whole stack
introduces new Python libraries, JIT compilation
additionally introduces cuTile, a new CUDA extension that allows the expression of problems at the tile level

GTC 2025

NVIDIA GTC is happening now – attend virtually for free.
Presenting the latest breakthroughs in generative AI, accelerated computing, simulation technology, and more.
Register to attend and enter my RTX 6000 Ada giveaway
My session recommendations: An Introduction to OpenUSD, CUDA: New Features and Beyond, and more here

Announcing DirectX Raytracing 1.2, PIX, Neural Rendering and more at GDC 2025!

the blog post shares D3D12 announcements from GDC
DXR 1.2 will bring support for opacity micromaps (OMM) and shader execution reordering (SER)
additionally, shares upcoming PIX updates as well as support for Cooperative vectors

wayback-archive

[video] Custom Lighting Fog - Custom Lighting Models - Episode 10

the video continues the development of a custom lighting model
this part introduces how to integrate fog into the shading model
implementation is done using the visual shading language in Unity 6

How to use Geometry Shader in Unreal Engine 5 with AddMeshPass Plugin

a short tutorial on how to use Geometry Shaders from Unreal Engine 5
shows the necessary C++ and shader code

wayback-archive

MeshPad: Interactive Sketch-Conditioned Artist-Designed Mesh Generation and Editing

the paper presents a discussion of techniques used to convert 2D sketches (interactively) into 3D base meshes
the technique is based on a transformer architecture that iterates on results through additions and deletions
still has context length limits that restrict triangle counts to thousands

wayback-archive

[video] Implicit Surfaces & Independent Research

the video presents how to render Implicit surfaces
starting from the basic ideas and showing how to deep dive into research on the same idea. Explaining the developments in implicit surfaces
additionally presents how to interact with the researcher community

Thanks to Warren Moore for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 383 - March 16th, 2025

Sun, 16 Mar 2025 04:00:00 +0000

Estimating variance reduction in importance sampling

the article provides an overview of Monte-Carlo and the Importance of sampling
discusses how to derive the variance reduction of the Importance sampling technique
shows how different approximations can present very different convergence behavior

wayback-archive

Dithering in Colour

The article provides an overview of dithering colored images
Discusses the importance of color spaces and human perception of the results
Additionally, it provides a link to a separate article that focuses on monochrome dithering

wayback-archive

Not Obviously Bad, and Obviously Not Bad

the blog post discusses the consideration of performance when designing general-purpose code
discusses various approaches to thinking about the problem
concludes that APIs should be designed to be “Not Obviously Bad” - avoiding obvious waste, such that if a random profile is taken, performance issues shouldn’t immediately stand out

wayback-archive

GTC 2025

NVIDIA GTC is happening now – attend virtually for free.
Presenting the latest breakthroughs in generative AI, accelerated computing, simulation technology, and more.
Register to attend and enter my RTX 6000 Ada giveaway
My session recommendations: An Introduction to OpenUSD, CUDA: New Features and Beyond, and more here

Reading AMD RDNA™ and CDNA™ Architecture Disassembly is a Breeze with AMD Radeon™ GPU Analyzer v2.12

the blog post presents improvements to the Disassembly view in the GPU Analyzer
can now present register pressure, branch visualization as well as tooltips explanations for the instructions

wayback-archive

AMD Radeon™ GPU Profiler 2.4 adds support for AMD Radeon™ RX 9000 Series, pure-compute applications, DirectML applications (and more!)

the blog post presents new improvements to the AMD GPU Profiler
this includes support for profiling compute-only applications (without present calls)
as well as improved support for work graphs and DirectML workloads

wayback-archive

[video] Screen Space Ambient Occlusion - Custom Lighting Models - Episode 9

the video tutorial explains how to implement Screen Space Ambient Occlusion using Unity
presents how to make the ambient component of the lighting pass aware of the ambient occlusion terms

[video] Depth Buffering // Vulkan For Beginners #19

presents how to add support for a depth buffer into a basic Vulkan application
explains how to set the resource creation, clear the depth target as well as the changes required to the object shaders

Thanks to Stephen Hill for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 382 - March 9th, 2025

Sun, 09 Mar 2025 04:00:00 +0000

[video] Modular Lighting System - Custom Lighting Models - Episode 8

This video tutorial demonstrates how to refactor monolithic lighting shaders into modular, reusable components
It showcases the tools available in both Unity and Unreal Engine for creating flexible visual shader architectures

Compression of Spectral Images using Spectral JPEG XL

This paper introduces an innovative method for compressing spectral images using existing JPEG XL encoders
It demonstrates how cosine transforms in the wavelength domain, significantly compressing the dynamic range
The authors present comprehensive compression results with quality comparisons across different parameters
They also outline future improvements currently constrained by limitations in the reference JPEG XL implementation

wayback-archive

New content released on GPUOpen for AMD RDNA™ 4 on-shelf day

AMD has published comprehensive documentation about their upcoming RDNA4 architecture
The release includes updates to FSR technology and the Capsaicin prototyping framework

wayback-archive

2D Rendering with SDF's and Atlases

This article provides a practical overview of runtime atlas construction for sprites and text elements
It explores using signed distance fields (SDFs) for efficient dynamic shape packing
The author explains techniques for seamlessly joining polyline segments to create continuous shapes without gaps

wayback-archive

[video] Vulkanised 2025: Slang is for Neural Graphics - Shannon Woods

This video provides a comprehensive overview of Slang and its capabilities for differentiable programming
It explains how Slang enables automatic differentiation, enhancing neural-based graphics techniques
The presentation also demonstrates the interoperability between Slang and Python codebases
It includes a practical example using gradient descent to train a Gaussian splatting implementation

[video] Soft body procedural animation

This video introduces the fundamentals of physics integration for graphics applications
It extends basic concepts to implement practical soft-body physics simulations
The tutorial demonstrates how to construct character animations using soft-body physics

[video] Real-Time Cloud Shadows in Unity: Optimized Shader Graph Workflow for Mobile & VR

This tutorial demonstrates an efficient technique for implementing cloud shadows in Unity scenes
The approach generates shadow mask textures through render-to-texture techniques
The final effect modulates the main directional light, creating convincing cloud shadow patterns

Thanks to Aras Pranckevičius for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 381 - March 2nd, 2025

Sun, 02 Mar 2025 04:00:00 +0000

[video] How to Sample Your Signals? Sampling Theorem and Anti-aliasing Explained

the video explains the theory underlying the resampling of continuous signals into distinct samples
presents how various aliasing artifacts are caused and how sampling and reconstriction filters prevent them
explains the examples of image resampling

FastAtlas: Real-Time Compact Atlases for Texture Space Shading

the paper presents a GPU-based method for the generation of dynamic texture atlases for texture-space shading
explains the limitations of existing methods and how this algorithm aims to improve it
presents performance and quality comparison against existing methods

wayback-archive

[video] Are Current Generation Graphics A Bit Of A Let Down?

the video discusses the challenges facing modern game graphics development
focuses on how different approaches to world and game design affect what techniques are possible

[video] How Clay's UI Layout Algorithm Works

the video explains how to design a flexbox-like layout algorithm
visually explains the flow of layout operations in a multi-pass structure
explaining all the tools required to implement relatively complex layouts

GTC 2025

GTC is happening March 17-21, virtually and in San Jose. Presenting the latest breakthroughs in generative AI, accelerated computing, simulation technology, and more.
Register for free to enter my RTX 6000 Ada giveaway
This post contains more details and my session recommendations

Infinity Nikki: Mysterious Shadow Drop

the article provides a look at the special case shadow handling for Infinity Nikki
discusses the various shadow systems, how they interact with other features and limitations
explains how many unique case systems can help to achieve game design requirements

wayback-archive

Call for Submissions

REAC 2025 is looking for talk submissions until March 28
the paper describes what topics the organizers are looking for and how to apply

wayback-archive

[video] Vulkanised 2025

video recordings of Vulkanised 2025 talks have been released
covers a large number of topics from updates to HLSL, neural networks, swap chain management to GPU-driven command generation
slides are available

[video] Vulkanised 2025: Device-Generated Commands in Vulkan - Ricardo Garcia

the talk provides an introduction to the Vulkan Device-Generated Commands API
explains the steps required on the C++ side to record and execute commands
covering command buffer management, synchronization, API restrictions as well as limitations

[video] How Game Engines Make Shaders Easy

the video explains the shader abstractions that can be found in Unity but are missing in Godot
provides an open-source implementation that aims to re-implement certain features for compute shader

tensara

a platform similar to Leetcode for CUDA applications
provides challenges and allows developers to submit and compare implementations

wayback-archive

Thanks to Aras Pranckevičius for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 380 - February 23rd, 2025

Sun, 23 Feb 2025 04:00:00 +0000

State of HLSL: February 2025

the blog post presents the latest development in HLSL development
shows that first basic HLSL shaders can be compiled in clang mainline
provides an overview of upcoming HLSL language revisions and upcoming changes
additionally introduces that public HLSL meetings are taking place reguarly

wayback-archive

GPU Friendly Laplacian Texture Blending

the paper introduces a new blending method to smoothly blend textures and materials while preserving local contrast and texture details without ghosting or blurring
presented techniques uses simple image processing and computational photography techniques without additional preprecessong steps
WebGL demo is provided

wayback-archive

Signed Distance Fields

the blog post gives an introduction into Signed Distance Functions
providing a high level overview of the technique and what can be created using them
additionally provides information on where to find further information
as well how to modify functions for further effects

wayback-archive

[video] Godot 4: Raymarching, part 1 (tutorial)

the video tutorial provides an overview of the Raymarching algorithmn
then presents a walkthrough on how to implement the technique in Godot shading language

Infinity Nikki: One-way Window

the article presents a couple of small optimizations Infinity Nikki
presents how windows are only one-sided
additionally presents how animations stop when outside the view range

wayback-archive

Introduction to Stochastic Calculus

the blog post provides an introductionn into Stochastic Calculus
explains developing applications in the field
starts the explanation from a statistics calculus examples and expands to more advanced examples

wayback-archive

Display Scaling in Godot 4

the article provides a detail discussion of considerations when designing UI for various devices and screens
explains the different resolutions and scale factors that appliaction developers need to know
presents practical examples of various ways to deal with the challenges
shows which Godot tools are available to help

wayback-archive

GTC 2025

GTC is happening March 17-21, virtually and in San Jose. Presenting the latest breakthroughs in generative AI, accelerated computing, simulation technology, and more.
Register for free to enter my RTX 6000 Ada giveaway
This post contains more details and my session recommendations

GPU Texture Compression Everywhere

the article provides the history of compressing textures on the GPU into block compressed formats
discusses the various challanges of getting this working reliable on various Vulkan devices and drivers
additionally presents how it can be achived on D3D12, OpenGL and Metal

wayback-archive

LLVM 20 Promotes SPIR-V To Official Backend, Enabled By Default

the article introduces that LLVM has added offical support for SPIR-V as a backend generation target

wayback-archive

[video] Indirect Rendering // Intermediate OpenGL Series

the video provides an overview on how to use glMultiDrawElementsIndirect to draw a scene
provides a discussion of the technique and shows how to integrate it into an exisitng OpenGL application
showing how it affects the C++ and GLSL shaders

[video] Light Color & Shadow - Custom Lighting Models - Episode 6

the video tutorial continues the development of a custom lighting model in Unity and Unreal Engine
in this part it presents how to intercept light information from the main scene light
additionally presents how to improve ambient lighting

Thanks to Keith O’Conor for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 379 - February 16th, 2025

Sun, 16 Feb 2025 04:00:00 +0000

Learn Shader Programming with Rick and Morty

The article provides a step-by-step tutorial that presents how to create the head of Rick using a pixel shader.
Introduces the necessary SDF operations slowly and shows how to combine them with animation.
Each step is presented as interactive shader challenges that can be edited to learn along the way.

wayback-archive

[video] Simple Lighting Model - Custom Lighting Models - Episode 4

The video tutorial presents how to combine specular, diffuse, and ambient lighting to create a custom shading model.
Presents the various stages, how to ensure correct vector spaces, and the effect of various parameters.
The implementation is shown using Unity and Unreal visual shader graphs.

Chromaticity preserving analytic approximations to the CIE color matching functions

The paper presents an analytic approximation for the CIE 1931 color space and the more modern CIE 170-1:2006.
Shows the approximation process and how it compares against existing approximations.
Source code is available in C++ and Python.

wayback-archive

Surface-Stable Fractal Dither on Playdate

The article provides a deep dive into getting Surface-Stable Fractal Dither running on a simple 1-bit display console.
Presents a breakdown of how the dithering algorithm is created from various passes.
Discusses various software rasterization methods and how they compare to the GPU reference implementation.
Additionally, it presents several applied optimization steps and how they affect performance.

wayback-archive

Anno 1800: Shadows of Beauty

The article discusses a small trick used by Anno 1800 that always aligns the sun’s direction relative to the camera.
Presents how much it affects the scene’s beauty as it prevents worst-case lighting setups.

wayback-archive

WebGPU - Notes

The presentation covers a complete walkthrough on using WebGPU from JavaScript.
Starts by explaining the basics and proceeds from a high-level overview into the implementation details.
Covers the full rendering pipeline, including shader authoring.

wayback-archive

[video] Ray Tracing Harmonic Functions (Extended Talk)

The talk introduces a novel sphere tracing algorithm tailored for harmonic functions.
The method allows for larger step sizes than traditional ray marching.
Demonstrates applications in visualizing surfaces reconstructed from point clouds and polygon soups without requiring linear solves or mesh extraction.
Expands visualization capabilities to handle nonplanar polygons with holes and complex mathematical objects such as knots and links.

Vulkan GPU-assisted validation startup time improved by >10X

The blog post describes how LunarG optimized the startup time of GPU Assisted Validation.
Combines driver hints and more fine-grained validation code and moves logic to later stages in the application lifecycle.

wayback-archive

Fast GPU Matrix multiplication

The article provides a detailed walkthrough of optimizing a 4096x4096 matrix multiplication for RDNA3.
Shows how to calculate theoretical expectations for performance and compares against all tested implementations.
Presents how a highly optimized routine can be 50x faster than a naive implementation.
Always present hardware performance captures and explain how to understand them and optimize the bottlenecks observed.

wayback-archive

The Vulkan SC Emulation driver stack

The blog post introduces the Vulkan Safety Critical Emulation stack.
Shows how the stack interacts between the user code and driver code.
Is meant to guide developers in developing applications by emulating SC constraints on consumer hardware.
The source code for the stack is open source.

wayback-archive

Thanks to Cort Stratton for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 378 - February 9th, 2025

Sun, 09 Feb 2025 04:00:00 +0000

NVIDIA RTX Mega Geometry Now Available with New Vulkan Samples

The blog post announces the release of the Mega Geometry SDK
This entry provides a summary of the various samples and libraries

wayback-archive

NVIDIA Neural Texture Compression SDK

Nvidia released a beta version of Neural Texture Compression
A neural network is used to compress all textures of a PBR set together
This can either be decompressed at sample time or be transcoded into BC during texture load
The readme provides a brief explanation and example data

wayback-archive

UVGS: Reimagining Unstructured 3D Gaussian Splatting using UV Mapping

The paper introduces turning 3D Gaussian Splatting from unstructured into structured structure using spherical UV mapping
The paper presents how the mapping allows existing models to better operate on the image formats
Shows improvements in compression and quality

wayback-archive

Solving the Dense Geometry Problem

This blog post introduces the release of the AMD Dense Geometry Compression Format SDK
The format aims to be the equivalent to what BC/ETC is for textures but instead for geometry
Explains limitations of the current solution and how the format aims to overcome it
The SDK contains how to compress, view, and decompress the data (both on the CPU and GPU)

wayback-archive

[video] Unity | How to Create Dynamic World Changing Effects

The video tutorial presents how to implement a world space-based effect that allows blending between different world rendering styles
Implementation is done using a mix of visual shading language as well as HLSL
Presents simple shapes as well as texture-driven outlines

Game engines and shader stuttering: Unreal Engine's solution to the problem

The blog post provides a high-level discussion of why Unreal Engine games commonly encounter micro stutter related to shader loading
Discusses the various systems Unreal Engine contains and introduces new methods to reduce the problem
Additionally, it discusses available debug options that should help developers verify the efficiency and introduce solutions during development

[video] What Kind of Math Should Game Developers Know?

The video visually explains the most common mathematical concepts that are encountered in game development
Covers interpolation, trigonometry, vectors, dot-product, matrices, quaternions
Presents each concept with practical and visual examples

Generating Tilesets with Stable Diffusion

The article discusses a technique that uses Stable Diffusion to generate a tileset
Discusses how to drive the model to generate the transition tiles between a known set of materials
Presents the limitations and issues with the developed model

wayback-archive

Simplified pipeline barriers

The article presents a simplified model for Vulkan and D3D12 Extended Barriers
Discusses both textures and buffers and how different hardware interacts with them
The code for the implementations is available

wayback-archive

Post-Processing Shaders as a Creative Medium

The article presents a series of post-processing effects that build upon the same underlying techniques
Each effect is explained and presented with detailed visualizations
Additionally, each effect is demonstrated as a real-time implementation that can be interacted with directly on the website

wayback-archive

[Video] Texture Mapping // Vulkan For Beginners #18

This video tutorial series covers the implementation of a Vulkan renderer
In this episode, you will learn how to create, load, and sample a texture

Thanks to Angel Ortiz for supporting this series

Would you like to see your name here too? Become a Patreon of this series

Graphics Programming weekly - Issue 377 - February 2nd, 2025

Sun, 02 Feb 2025 04:00:00 +0000

Raymarching The Gunk

the detailed article provides an overview of the implementation of the Goo-like in “The Gunk”
explains the underlying voxel-based implementation, how it’s represented and interacts with gameplay
describes how it’s authored and rendered integrated into UE
additionally presents how the effect is rendered using a ray-marching-based approach

wayback-archive

Sample for cluster-based continuous level of detail rasterization or ray tracing

the sample is part of Nvidia RTX Mega Geometry and presents how to use a continuous Level of detail through mesh clustering
presents how to rasterize using mesh shaders and use the new VK_NV_cluster_acceleration_structure for raytracing
provided documentation provides a detailed walkthrough of the sample code and the underlying implementation

wayback-archive

DirectX 12 Agility SDK 1.716.0-preview Explained

the blog post provides an overview of the latest released features in the D3D12 Agility SDK update
the SDK introduces Shader hash bypass, reduced alignment requirements for buffers, as well as the recreation of resources at specific virtual addresses
as well as shared links to updates to the d3d12 video encoding functionality

wayback-archive

[video] Calculating Specular Highlights - Custom Lighting Models - Episode 3

continuation of custom lighting model using Unreal and Unity
this part covers Phong, Blinn formula, as well as Half Lambert, diffuse
implementation is shown using visual shader language

Agility SDK 1.716.0-preview: New D3D12 Video Encode Features

the blog post presents new features for D3D12 video encoding
allows developers to provide additional hints (such as motion vectors or dirty rectangles) to speed up the encoder processing
also now allows frames to be split into sub-regions with individual progress tracking and data access control

wayback-archive

Now Available: Matrix-vector operations using tensor cores in Slang

first, experimental support for Cooperative vectors has been added to Slang
the blog post explains the features and presents two examples of how to use it
additionally provides a link to the SPIR-V extension

wayback-archive

nv_cluster_lod_builder

Nvidia open-sourced a mesh processing library that allows meshes to be split into meshlets and calculate LOD cluster that allows for continues LODs
documentation explains the API, how the implementation approaches the decimation and split steps
additionally, explain the limitations (there are a number of them at this time)

Thanks to Angel Ortiz for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 376 - January 26th, 2025

Sun, 26 Jan 2025 04:00:00 +0000

[video] Surface-Stable Fractal Dithering

The video provides a detailed explanation of the work done to apply fractal dithering on objects stably.
It starts with a review of dithering concepts, discussing various methods and issues.
The technique is developed from the start, showing the various stages of implementation along the way.

[video] Vertex Lighting - Custom Lighting Models - Episode 2

The video explains how to implement a custom lighting model in Unity/Unreal.
This part focuses on the integration of vertex-based shading.
Implementation is shown using a visual shader authoring workflow.

Jobs

Senior C++ Programmers
Relocate, Remote, ideally based in the UK

At GREEN-BiT, we’re on a mission - we’re building a new, innovative software to help reduce the carbon impact of software, first starting with games. We want to empower developers with a Green SDK and toolset to democratise performance optimisation. We’re currently looking for purpose-driven and talented Senior Programmers to join our team and work on developing our groundbreaking tools!

Would you like to advertise your job openings here too? More information

Surfel Maintenance for Global Illumination

The blog post discusses the process of a world-space-based surfel distribution pipeline.
It provides a high-level overview of the concept and implementation.
It shows how the various stages have been implemented and presents performance results.
Additionally, it provides pointers to further information.

wayback-archive

FFT Bloom Optimized to the Bone in Nabla

The blog post explains FFT optimization for bloom effects in the Nabla engine.
It covers acceleration via convolution in the frequency domain.
It presents detailed overviews of the optimizations applied.
Additionally, it looks at what could be further improved in the future.

wayback-archive

tinybvh – Manual – Basic Use

The article provides an overview of how to use the tinybvh open-source library.
It provides a high-level overview of the API and design considerations.
It then shows how to use the basic API and how to refit the BVHs for animation support.

wayback-archive

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 375 - January 19th, 2025

Sun, 19 Jan 2025 04:00:00 +0000

Radiometry, part 2: Spectra and photometry

The article explains spectral radiometric quantities.
Presents how it relates to human perception to create photometric quantities.
Additionally covers techniques to efficiently deal with spectral rendering implementations.

wayback-archive

Dynamic Rendering local read

The Vulkan example presents how to use the VK_KHR_dynamic_rendering_local_read and VK_KHR_dynamic_rendering extensions to replace the need for render passes.
Explains how dynamic rendering compares to Vulkan 1.0.
Shows how local reads can be used to implement a deferred renderer with a composition pass.

wayback-archive

[video] Particle System Using The Compute Shader // Intermediate OpenGL Series

The video provides a high-level introduction to compute shaders with OpenGL.
Shows how to apply the concepts to the implementation of a particle system.
Explains how to implement the shader, connect it to OpenGL, and execute the work.

Issues with Color Spaces and Perceptual Brightness

The blog post calls out that color spaces such as CIELAB don’t offer perceptual brightness for all colors.
Explains how certain colors appear brighter to humans than others at the same hue.

wayback-archive

Massaging the Shader Compiler to emit Optimum Instructions

The blog post provides examples of how different HLSL implementations cause very different codegen results.
Shows that unintuitive implementations can be required to allow the compiler to map to native instructions.
Suggests that compiler pattern matching hinders performance and it could be beneficial to expose native instructions as intrinsics.

wayback-archive

Free Learn OpenUSD Trainings

NVIDIA released an interactive and free course about learning OpenUSD concepts.
Structured into modules, the course combines written guides and video tutorials for a comprehensive learning experience.
Hands-on Jupyter notebooks let you explore practical examples and deepen your understanding of key topics.
Just released: Applied Concepts courses on composition arcs, asset structure principles, and data exchange pipelines.

wayback-archive

[video] RTX Mega Geometry Is A Big Deal... But What Does It Actually Do?

The video provides an overview of the Mega Geometry technique by Nvidia.
Aims to solve the issue of streaming clusters into acceleration structures without BVH rebuilds.
Discusses new possibilities of the presented demos.
Currently an Nvidia-only API.

[video] Full Introduction to Compact Poisson Filters for Fast Fluid Simulation -- SIGGRAPH 2022

The video recording of a talk that discusses Compact Poisson Filters to allow fluid simulations for interactive applications.
Explains the solver technique and implementation steps in detail.
Presents performance and demos of the technique.

Dissolve shader: VFX's bread and butter

The blog post explains how to implement a dissolve shader.
Presents examples of different methods for the implementation and compares them visually.
Additionally provides examples of the technique when applied to particles.

wayback-archive

Technically Art: Issue 141 (17.1.2025)

Collection of blue sky posts covering tech art.
Contains videos and pictures of in-progress projects.
Additionally contains a number of links to tutorials and posts covering a variety of topics.

wayback-archive

The blog post discusses different classes of HLSL instructions and associated costs on RDNA hardware.
Presents how many instructions are required for the various patterns.
Additionally presents insights into other patterns that can affect the performance of generated code.

wayback-archive

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 374 - January 12th, 2025

Sun, 12 Jan 2025 04:00:00 +0000

[video] From Texture to Display: The Color Pipeline of a Pixel in Unreal Engine | Unreal Fest 2024

A detailed discussion of the rendering color pipeline in Unreal Engine
Explains color spaces, color encoding, and various stages of color conversion
Presents post-processing effects and the importance of proper color handling

Radiometry, part 1: I got it backwards

An explanation of radiometry concepts such as Radiance, Solid angle, Irradiance, Radiant flux, and Radiant energy
Ties these concepts together in the context of a renderer’s camera

wayback-archive

Exploring ways to mipmap alpha-tested textures

A look at various techniques to generate mipmaps for vegetation textures
Discusses the problem of losing coverage and shape with classical downsampling techniques
Compares various techniques and suggests their pros and cons

wayback-archive

WebGPU Sponza Demo — Frame Rendering Analysis

An overview of techniques defining a WebGPU implementation
Provides a high-level overview of the shader pipeline, culling, shadow rendering, and more
Discusses light implementation, skybox, screen space reflection, etc.
Source code is available

wayback-archive

Viewing images

A detailed discussion on the complexity of image format loading and display
Insights into the image format landscape and tone mapping HDR formats correctly
Additional topics include cursor rendering and optimizations

wayback-archive

Free Learn OpenUSD Trainings

NVIDIA released an interactive and free course about learning OpenUSD concepts
Structured into modules, the course combines written guides and video tutorials for a comprehensive learning experience.
Hands-on Jupyter notebooks let you explore practical examples and deepen your understanding of key topics.
Just released: Applied Concepts courses on composition arcs, asset structure principles, and data exchange pipelines

wayback-archive

How to improve MSAA performance of MTKView

An overview of different MSAA modes in the Metal API
How to adjust the MTKView wrapper to create a memoryless MSAA target
Shows the effect of this change on memory usage

wayback-archive

Dynamic Resolution Scaling (DRS) on PC

Challenges developers face when implementing DRS on PC
Covers hardware and OS interaction, latency, and user input variability
Briefly discusses approaches to solving these issues on PC

wayback-archive

[video] Uniform Buffers // Vulkan For Beginners #17

Video tutorial on implementing uniform buffers in a Vulkan application
Explanation based on code changes from previous iterations
Shows how to use the concepts to implement a 3D flythrough camera

Enabling Neural Rendering in DirectX: Cooperative Vector Support Coming Soon

Announcement of Cooperative Vector Support extensions for D3D
Exposes hardware-accelerated matrix by vector operations
Enables access to Tensor Cores with neural shading in new RTX50 series GPUs

wayback-archive

NVIDIA Reflex 2 With New Frame Warp Technology Reduces Latency In Games By Up To 75%

Discusses updates to the Reflex 2 system
Explains how changing camera views are applied by reprojecting the camera into the new camera space
Shows how unfilled areas are filled through neural reprojection techniques

wayback-archive

Thanks to Stephen Hill for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 373 - January 5th, 2025

Sun, 05 Jan 2025 04:00:00 +0000

Spline Distance Fields

the blog post discusses a technique to use splines to drive the creation of terrain meshes
including the history and a discussion of how to generate meshes from the splines
additionally, present screenshots of an in-development game that uses a system based on the idea

wayback-archive

Recollecting the history of offline rendering.

the article provides a look back at the development of offline rendering techniques
presenting which techniques got used, how they changed over time, and when the first path tracers appeared
additionally providing additional thought as to why things developed the way they did

wayback-archive

MaterialX Interior Mapping

the project presents how to implement Material Mapping using MaterialX
the included demo video shows the effect
code is provided

wayback-archive

We see colors differently

the blog post discusses how colorblindness affects how humans perceive colors
presents a tool that aims to replicate how different limitations affect the appearance
includes links to color palettes that maintain contrast for full vision and those with colorblindness

wayback-archive

Tools for GPU Codec Development

the author presents an overview of the tools used to develop the Spark codecs
discussing the importance of tooling and automation for efficient development
additionally discusses how A/B testing algorithm changes are integrated into the codebase

wayback-archive

[video] Shader Creation for Everyone! - An intro to Ben Cloward's YouTube channel

the video provides an overview of the various series covering shader development
provides a quick overview of each of the series available on the channel
additionally discusses the author’s background

Year of independence

the blog post provides the author’s experience of working independently after leaving Roblox
discusses changes to mesh optimizer, gltf-pack
additionally discusses the viability of sustainable open-source development models

wayback-archive

Thanks to Nia Bickford for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 372 - December 29, 2024

Sun, 29 Dec 2024 04:00:00 +0000

December 13th, 2024 PIX 2412.12 – Texture/Buffer/Visualizer improvements, Work Graph Shader Debugging, and many Timing Capture improvements

the blog post discusses changes in the latest release of Pix
adds support for VRS shading rate visualization, shader graph debugging, as well as improved custom shader support

wayback-archive

UNORM and SNORM to float, hardware edition

the article provides a detailed discussion of how hardware implements the UNORM/SNORM conversion rules
explaining special cases and how to deal with those
additionally, it presents a C++ implementation of the presented concepts

wayback-archive

Efficient Motion Blurred Spheres Using Texture Mapping

the paper presents a model of applying motion blur to spheres in a 2.5D setting
implemented by pre-generating an atlas of blurred spheres of varying radius and lighting angles and compositing these into the scene
explains the implementation and limitations
runnable example and source code is provided

wayback-archive

Moana 2

the blog post discusses changes done to the Disney Hyperion render since the prequel to the movie
provides published research papers on the discussed techniques
then presents the main challenges of the Moana 2 production and how they solved them

wayback-archive

Transforming normals: adjugate transpose vs inverse transpose

the blog post discusses the difference between adjugate transpose vs inverse transpose of normals
explains how it behaves on shading normals
presents the visual results of different methods

wayback-archive

[video] Game Engine Programming 074.1 - Brief introduction to importance sampling

the video provides an introduction into the mathematics of importance sampling
discusses how samples can approximate integrals
then applies the ideas to the diffuse shading integral

Noise, Neural Networks, and Flow-Matching

the article explains and shows how noise applied to a curve fitting application changes the results
additionally presents the same in a multi-modality model using flow matching
concluding that “noise cancels out, signal adds up” cannot always be relied upon anymore

wayback-archive

Visualize and understand GPU memory in PyTorch

the blog post presents tools available to visualize and understand memory usage in PyTorch
explains how to estimate memory usage before running a workload
additionally provides a small tool to help with the estimation

wayback-archive

Thanks to Nia Bickford for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 371 - December 21st, 2024

Sat, 21 Dec 2024 04:00:00 +0000

[video] Inside Indiana Jones and the Great Circle: The Ray Tracing Breakdown

the video provides a round-table interview with two developers of the team
covers which techniques are using ray-tracing implementations, how they are implemented, and what is affected most
discusses trade-offs of requiring hardware support as well as next steps

[video] Create your own Cubemap // Intermediate OpenGL Series

the video explains how to convert panoramic images with a 360-degree view to a cube map
presents the fundamentals of the involved coordinate space conversions and related math
additionally also presents how to implement the conversion using OpenGL

renderdoc - Version v1.36

the post announces that DXIL debugging and raytracing are now supported in RenderDoc
shows how DXIL is integrated and existing limitations
Ray tracing debugging is implemented using API debug features that are not yet implemented on all drivers
additionally, it contains a long list of fixes and improvements

Path tracing lectures

the blog post provides an introduction to the path tracing lectures available from the TU Delft
discussed what material is covered and the limitations
additionally discusses the technology used to implement the example implementation

Moon

the very detailed article covers the moon (physics, appearance, …) in great detail
shows curves of astronomical objects, effects of physics, projections, appearance, and much more
each example is accompanied by videos or interactive explorations of the concepts

wayback-archive

3DGUT: Enabling Distorted Cameras and Secondary Rays in Gaussian Splatting

the paper presents a reformulation of Gaussian Splatting to allow nonlinear camera projections
explains the concepts of Unscented Transform and how splatting can be reformulated using the method
additionally presents how the method allows the same representation to be used with raytracing implementations

wayback-archive

[video] Introducing Clay - High Performance UI Layout in C

the video provides a detailed introduction to Clay, a C-based layout engine for high-performance immediate mode UI
start by explaining the concepts, capabilities, and design goals
presents a walkthrough on how to develop a small starter application, showing code iterations along the way
all examples are accompanied by various animated visualizations

Thanks to Adalberto Bruno for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 370 - December 15th, 2024

Sun, 15 Dec 2024 04:00:00 +0000

You Are Going to Need It

the blog post presents the difficulty of creating microbenchmarks
shows the example in a simple example by looking at the generated code at different levels of the optimization pipeline

wayback-archive

Wicked Engine’s graphics in 2024

the blog post provides an overview of the graphics changes done to the Wicked Engine
covers forward rendering, meshlet-based rendering, visibility buffers, shadow rendering, wetness, and more
provides reasons, limitations, and performance numbers for the various aspects of the engine changes

wayback-archive

Transforming Normals

the blog post provides a detailed discussion of the adjugate matrix, an alternative form of transform for normals
discusses why normals need special handling under transformation visually
explains how geometric algebra allows the derivation of this behavior in a consistent framework

wayback-archive

DirectX 12 Resources – Key Concepts

the article summarizes the main concepts of D3D12 to provide a high level of understanding
covers Resources, Views, Heaps, Sub resources, and different buffer types

wayback-archive

A Statistical Approach to Monte Carlo Denoising

the paper presents an investigation into the Monte Carlo rendering method using statistical methods
the proposed model does not use any pre-trained data and is instead applied at runtime
presents the derivation and comparison against existing denoising models

wayback-archive

Meshtron: High-Fidelity, Artist-Like 3D Mesh Generation at Scale

a paper presents a novel mesh generation model that can generate meshes with up to 64K faces from point cloud data
provides an overview of autoregressive mesh generation that is the foundation of the model
explains the model development process and presents the results

wayback-archive

GPU Glossary

the website covered a glossary of standard terms found in graphics programming in a single location
broken down into Device Hardware, Device Software, and Host Software
explains concepts such as Warp Scheduler, Tensor Cores, Cuda, Thread Blocks, and much more

wayback-archive

[video] Ray Tracing Has a Noise Problem

the video presents a look at raytracing quality in various games
shows comparisons mainly focusing on shadows and reflections
some of the games featured are Cyberpunk 2077, Alan Wake II and Star Wars Outlaws
additionally shows the effect of denoising techniques on the quality and appearance

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 369 - December 8th, 2024

Sun, 08 Dec 2024 04:00:00 +0000

[video] Coding Adventure: Rendering Fluids

the video provides a detailed walkthrough on the process of rendering water based on the results of a water particle simulation
starts from an empty scene, covering mesh generation, raymarching, shading as well as interactions with the environment
additionally, it presents how to render foam and bubbles to the water’s surface

Refracting Pixels

the article presents an overview of different games that implement refraction into their rendering pipelines
compares the different approaches, discussing advantages and disadvantages
additionally presents how this interacts with anti-aliasing

wayback-archive

From the archive: Making a greener grass.

the blog post focuses on the visual side of grass rendering in Call of Duty Black Ops 4
shows different stages of the exploration and impact of the various components
discusses various hacks to simulate the effect of real-life effects within the restrictions of the runtime grass

wayback-archive

GFFE: G-buffer Free Frame Extrapolation for Low-latency Real-time Rendering

the paper presents an image upscaler that is designed to extrapolate from color, depth, and motion vector inputs to a variable number of frames
discusses the implementation of the motion estimation, background collection, adaptive rendering windows, and shading correction network modules
presents performance and quality against existing techniques

wayback-archive

[video] Graphics Programming Conference 2024

a collection of videos from the Graphics Programming Conference in Breda has been released
covers a large number of topics such as Porting Games, Vulkan best practices, Shader Occupancy, Occlusion culling, and much more

[video] Gigi: A Platform for Rapid Graphics Development and Code Generation

the talk presents an overview of the Gigi Platform
a tool and code generation that aims to improve programmer productivity by enabling rapid authoring of shader effects
shows how the tool was developed, what features it has, and what has been implemented using the platform so far

[video] Rendering Tiny Glades With Entirely Too Much Ray Marching

the talk presents an overview of the rendering pipeline in Tiny Glades
covers GPU-driven rendering, sky rendering, GI implementation, shadows, refractions, Depth Of Field, and more

Understanding Godot Light Shaders and Light Calculations by Implementing a Toon Light Shader

the blog post discusses Godot Light Shaders
presents where this type slots into the pipeline and what possibilities it enables
presents a walkthrough on how to implement tool shading into the Godot pipeline

wayback-archive

Khronos Streamlines Development and Deployment of GPU-Accelerated Applications with Vulkan 1.4

the blog post announces the release of Vulkan 1.4
increased guaranteed limits, required extensions, as well as
addition presents improvements to copying data while rendering

wayback-archive

Fixing the Loading in Myst IV: Revelation

the article presents a walkthrough of how the author approached optimizing loading issues in Myst IV
shows how he detected the bottlenecks, replaced texture loading logic
contains a comparison of the performance of various image-loading libraries

wayback-archive

Thanks to Robert Wallis for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 368 - December 1st, 2024

Sun, 01 Dec 2024 04:00:00 +0000

Behind the Pretty Frames: Detroit Become Human

the article provides a very detailed look at how a frame in Detroit Become Human is being drawn
presents insights into how the shading pipeline is implemented, details into implementation for the various resource passes, vertex formats, interactions with animations, effects implementation, etc
additionally shows a flow graph of how a full frame is structured with images of the resources involved in each pass

wayback-archive

Slang x WebGPU

the example project presents an example of how to use Slang with WebGPU
shows how to use CMake integration to compile shaders from slang to WGSL (WebGPU shading language)
additionally shows how to use the reflection API to generate binding helpers

wayback-archive

Fixing The GPU

In the working document, Timothy Lottes records and suggests solutions for GPU programming issues in a compute shader context
covers many problematic areas, from performance hints over shader compiler improvements, caching related, buffer access patterns, and much more
provides example cases that offer insights into current shortcomings, performance issues, and shader compiler bugs

wayback-archive

Optimizing a Rust GPU matmul kernel

the article presents how to use RustGPU to compile a compute kernel
discusses the implementation details and interactions with the ecosystem
additionally presents how RustGPU enables shader logic to be run on the CPU

wayback-archive

A guide to fast voxel ray tracing using sparse 64-trees

the article discusses the efficient implementation of Sparse Voxel Octrees
presents how to build the required tree structures and traverse the created trees
additionally provides advice to improve debuggability, performance, and robustness of the initial implementation

wayback-archive

Hidden Surface Removal in Immortalis-G925: The Fragment Prepass

The article presents the new Fragment Pre-pass hardware implementation available in upcoming Arm GPUs
explains how the technique works, what it enables, and what are the limitations
additionally, it discusses best practices for performance and shows some performance numbers

wayback-archive

My recommended Books

My list of recommendations for books
Covering Computer graphics, engine design, algorithms, collision detection, as well as knowledge management
contains resources for beginners as well as advanced programmers

wayback-archive

Differentiable Graphics with Slang.D for Appearance-Based Optimization

A summary of the chapter Differentiable Graphics with Slang.D for Appearance-Based Optimization included in GPU Zen 3
the article focuses on the practical usage of stochastic gradient descent and optimization from beginning to a working minification system for materials

wayback-archive

A simple way to scale pixel art games

the article presents insights into how to upscale retro pixel art games for higher resolutions than the source material
The suggested solution is using nearest for vertical and linear for horizontal

wayback-archive

Modern Vulkan Application Sample

the Vulkan code example presents how to use various modern Vulkan concepts to create compact sample applications
presents how to use descriptor management, specialization constants, timeline semaphores, ImGui integration, etc.

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 367 - November 24th, 2024

Sun, 24 Nov 2024 04:00:00 +0000

There’s a lot going on with Slang!

the blog provides an overview of changes to the Slang shading system ecosystem
Slang is now part of Khronos and adds support for Metal and WebGPU
additionally, improved type system, Unicode, as well as atomic support

wayback-archive

AAA - Analytical Anti-Aliasing

the article provides a look at various anti-aliasing techniques
presents many interactive examples to demonstrate the techniques and allows experimentation with them

wayback-archive

Khronos Announces Vulkan Video Encode AV1 & Encode Quantization Map Extensions

the blog post announces the release of a new encode AV1 extension
Vulkan Video now provides full decode AND encode acceleration for the H.264, H.265, and AV1 codec
additionally presents an overview of the Encode Quantization Map extension and how it allows applications to better control the encoding quality

wayback-archive

[video] GPU driven rendering in AnKi 3D Engine

the talk provides an overview of the GPU-based rendering implementation
presents an overview of how the different stages of a frame are implemented
covering scene representation, culling implementation, shadow rendering, mesh shading, and more
additionally presents an overview of the frame performance

Occupancy explained through the AMD RDNA architecture

the slides for a talk given at the Graphics Programming Conference 2024 have been released
provides an overview of AMD hardware execution patterns, what occupancy is, and how it affects performance
the slides don’t have speaker notes, so following them is a bit difficult at times

wayback-archive

CPU performance optimization guide – part 2

the article provides a high-level overview of how to use AMD profilers to investigate cache miss behavior
explains the different available hardware counters and how to interpret the results

wayback-archive

Frames In Flight Explained

the article explains the concept of in-flight frames in computer graphics applications
shows how the execution pattern between CPU and GPU requires synchronization
additionally discusses how it affects memory usage, latency, and execution performance

wayback-archive

[video] Vertex Buffers // Vulkan For Beginners #15

the video explains how to set vertex buffers using Vulkan
shows the implementation for allocation memory and uploading data for GPU access

[video] Game Engine Programming 073.1 - Sampling methods for pre-filtering diffuse Image Based Lighting

the video tutorial explains the theory behind image-based lighting
presents how to implement pre-filtering for the diffuse lighting component
shows many visualizations of the involved steps

What's next for WebGPU

the blog post provides an overview of what has been discussed for changes to WebGPU

wayback-archive

Thanks to Steven Cannavan for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 366 - November 17th, 2024

Sun, 17 Nov 2024 04:00:00 +0000

Sampling Safari

the tool allows the visualization of Monte Carlo samplers
many different methods can be selected
allows the exploration of settings through interactive controls

3D Gaussian Splatting: A new frontier in rendering

the article provides an overview of Gaussian Splatting support in V-Ray
explains the technique on a high level, advantages, and limitations
presents an example of how objects can be added to scanned scenes and interact with the scene around them

Efficient Scene Appearance Aggregation for Level-of-Detail Rendering

the paper presents a framework for volumetric scene prefiltering and level-of-detail rendering
to improve geometric fit of voxel approximations, it introduces a truncated ellipsoid primitive
shows how the technique allows accurate LoD rendering closely matching the ground truth at all scales.

keen games vulkan backend

keen games released a snapshot of their Vulkan Backend implementation
code is not compiling as it depends on code that has not been published
meant as a reference for others to see how concepts can be implemented

Virtual Geometry in Bevy 0.15

the article explains the changes that have been made to the Nanite-like Virtual Geometry system for Bevy
discusses software rasterization, improved LOD selection, memory reduction techniques, as well as performance optimizations
provides links to the various PRs and explains these, making it easy to follow along

Work Graph Playground: a learning framework for GPU Work Graphs

AMD released a shader toy-like application that allows exploration of D3D12 Work graphs
the application is compatible with D3D WARP (aka CPU emulation of D3D12)
provides tutorials of different complexity to showcase different capabilities
documented source code for all tutorials is provided

Innovating Strand by Strand for Lifelike Hair in Dragon Age: The Veilguard

the blog post provides a high-level overview of the hair rendering technique used in Dragon Age that uses strand-based rendering
presents that 6.5ms (at 30fps mode) and 3ms for 60fps are reserved for hair rendering
shows a demo video to present the technique results

An Overview of Game Engine Architecture

the slides discuss the design of the C4 Engine
present how the engine has been separated into separate components and what these components do

Harnessing Wave Intrinsics For Good And Evil

the presentation shows how to use HLSL Wave Intrinsics
explains what Wave Intrinsics are, what they can be used for, and the limitations
shows practical use-cases and how to implement example solutions
presents the generated code on AMD hardware and discusses pitfalls

Optimize effective bandwidth of a 3x3x3 blur

the Bluesky thread presents a detailed look at how to optimize a 3x3x3 blur
shows different stages of the optimization process
published performance numbers for the different optimized implementations
additionally presents how to use voxels to visualize the algorithm implementation

Thanks to Deepak Surti for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 365 - November 10th, 2024

Sun, 10 Nov 2024 04:00:00 +0000

Implementing Order-Independent Transparency

the article presents a technique for Order-Independent Transparency
the presented technique uses multiple passes over the geometry to generate transmittance coefficients
discusses how this turns the problem into an additive shading problem
presents the implementation details step-by-step, limitations and possible optimizations

wayback-archive

OpenGL is not Right-Handed

the article discusses the concept of coordinate systems and how it relates to column vs row-major matrices
provides into how the misconception is based on old fixed function style OpenGL concepts
overview of how matrix and vector convention are disconnected from memory layout
additionally shows how the Odin language supports these concepts on the language level

wayback-archive

From the archive: Vegetation in COD:BO4

the blog post provides an overview of the process of how procedural vegetation was implemented in COD Black Ops 4
discusses the design process and how different developments across the teams influenced the design of the system
provides insights into the noise generation process, placement logic as well as storage considerations

wayback-archive

Exact UNORM8 to float

the article goes into detail how to implement a floating point (0 to 1) conversion to 8bit and back without relying on division support
first presents the simple division method and then derives how to implement the same without division support
goes into detail about how floating point precision and ranges

wayback-archive

BC7 optimal solid-color blocks

the blog post provides insight into the BC7 texture compression format
explains how to best express constant color blocks within the constraint of the format

wayback-archive

Implementing a tiny CPU rasterizer

the article series about the implementation of a CPU rasterizer C++ continues
part 4 to 6 are released and add support for 3d transformations, projections, clipping, depth buffer, and perspective correct interpolation

wayback-archive

Introduction to Shaders

the blog post presents a beginner-focused introduction to shader programming
provides an overview of how shaders allow access to GPU resources, execution model, and restrictions
shows how classical rendering pipelines with vertex & pixel shaders are used

wayback-archive

SHforHLSL

single header HLSL library for spherical harmonics
implements support for L1 (2 bands, 4 coefficients) and L2 (3 bands, 9 coefficients) SH (spherical harmonics)

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 364 - November 3rd, 2024

Sun, 03 Nov 2024 04:00:00 +0000

Single-header BVH construction and traversal library.

first release of a single header library for the construction and refit of Bounding Volume Hierarchy
contains a generic C++ version as well as an AVX optimized variation

Implementing a tiny CPU rasterizer

start of a planned 12 part tutorial series on the implementation of a software rasterizer
currently available parts covers the steps required to render triangle as well as to interpoliate colors across a triangle

Meshlet compression

the article presents the findings of researach into compression of meshlet data for reduced memory usage
discusses the various techniques and the effects on compression ratios
additionally presents how they can be utilized my mesh and amplification shaders to decompress the data at runtime
presents the effects on performance

[video] Dan Baker How to Start a Career in Computer Graphics Programming

the video provides a look back at the speakers career in the video game industry
what they are looking for in graphis developers and programmers for video games in general
the QA section provides further insights into what developers are looking for in new hires

On Crafting Painterly Shaders

the article presents a walkthrough of the development of a painterly post-processing shaders
provides an in-depth discussion of Kuwahara filters and extensions
shows quality improvements for the various steps of the process
additionally presents runnable WebGL implementation of the techniques presented

Enterprise PBR Shading Model

the spec focues on the mathematical description of the shading model
model is a linear blend of a metallic and a dielectric BSDF
presents the parameters, derivations as well as visual examples of the visual quality

Thanks to atyuwen for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 363 - October 27th, 2024

Sun, 27 Oct 2024 04:00:00 +0000

My Ray Tracing Gems Chapters

collection of the author’s articles from Ray Tracing Gems published in one place
Ray Traced Shadows: Maintaining Real-Time Frame Rates, The Reference Path Tracer
Refraction Ray Cones For Texture Level Of Detail, Rendering Many Lights With Grid-based Reservoirs

Classic 3D videogame shadow techniques

the article provides an overview of shadowing techniques as they have been used by video games of the past
presents examples of the different techniques, including screenshots of these techniques
discusses a brief overview of each technique and its tradeoffs

(Yet another) Introduction to quaternions

the article provides a walkthrough of quaternions deviations for computer graphics
focuses on the formulas and algebra underlying the mathematical model
includes a cheat sheet of the covered topics at the end of the article

EON: A practical energy-preserving rough diffuse BRDF

the paper introduces Energy-preserving Oren–Nayar (EON) BRDF designed for rough surfaces
introduces analytical energy compensation and importance sampling via Clipped Linearly Transformed Cosine

Fundamentals of Radiance Cascades

the article provides an introduction to the Global Illumination technique called Radiance Cascades
focuses on the development of an intuition for the concepts that underly the technique
the steps are explained visually with animated examples

WebGPU Device Loss best practices

the post explains what a device lost event is and how to handle it from WebGPU
shows the exposed API and how to react to the events
discusses different approaches that can be taken to handle the event
additionally provides pointers for Chrome-specific considerations for development

The Ultimate Guide to Matrix Multiplication and Ordering

the article provides a detailed overview of matrix multiplication
starts with an overview of matrix multiplications
discusses Row-major vs. column-major, differences between shading languages
then focuses on multiplication ordering, space transformations as well as inversing

Texture-less Text Rendering

the article discusses a technique to render debug fonts without the usage of textures
presents how to embed glyph data into shaders and render from instanced draw calls
GLSL source code is provided

Thanks to Steven Cannavan for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 362 - October 20th, 2024

Sun, 20 Oct 2024 04:00:00 +0000

[video] niagara: Meshlets unchained

the video continues meshlet implementation and looks at task shader performance on AMD hardware
starts with an overview of the technique implementation and presents the performance problem encountered using the AMD profiler
explains how the driver implements task shaders and what causes the performance issue by patching the Linux drivers
From there, implement a solution that uses compute shaders to cull meshlets instead of using task shaders
presents performance and memory comparison against the native task shader solution

Emulating Workgraphs

the document explains how vkd3d-proton decides to emulate Vulkan Workgraphs using ExecuteIndirect
discusses different trade-offs and design decisions made
presents how the implementation compares against native implementations on both Nvidia and AMD
many workloads are currently more efficient using this emulation code path than the native driver version

Drawing Graphics on Apple Vision with the Metal Rendering API

the article describes how to use the native Metal rendering API for Apple Vision devices
explains how to interact with the OS for Variable Rate Rasterization based on eye positions, interact with projection matrix
shows different techniques exposed to render meshes to the two-eye views
presents how to structure the rendering frame architecture to reduce latency

GPU Work Graphs mesh nodes are now in Vulkan

the article announces the release of Work Graphs as experimental Vulkan extensions
provides links to the headers, spec, and code samples, as well as compiler support
additionally provides a list of current limitations

GPU Reshape Beta 2 Release

the article introduces the new features in Reshape, a tool for instrumentation of GPU operations with instruction level validation of potentially undefined behavior
explains in detail what AMD Waterfall’ing is, how the tool can detect NonUniformResourceIndex usage
updates to per-byte and pixel resource usage, as well as placed resource initialization

Scaling Points In a Specific Direction

the blog post presents two mathematical methods to scale points along a direction
the first method uses matrix operations, and the second uses dot products

[video] Graphics Pipeline Object // Vulkan For Beginner #14

the tutorial series on Vulkan continues by implementing Graphics Pipeline objects
presents the C++ code changes and Vulkan changes required
closes with a first triangle being drawn to the screen

[video] Upscaling Face-Off: PS5 Pro PSSR vs PC DLSS/FSR 3.1 in Ratchet and Clank Rift Apart

the video provides a comparison of different upscaling techniques for Ratchet and Clank Rift Apart
tries to match the PC and PS5 Pro rendering quality as closely as possible
compares the PS5 Pro upscaler technique against the AMD and Nvidia upscalers on PC

Thanks to Eric Haines for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 361 - October 13th, 2024

Sun, 13 Oct 2024 04:00:00 +0000

[video] Mesh Shaders - The Future of Rendering

the presentation provides a getting-started look at basic mesh shader implementations
discusses effects of meshlets, use-cases, and current technologies using it
additionally discusses remaining limitations

[video] GPU driven Rendering with Mesh Shaders in Alan Wake 2

the presentation provides a high-level view of the Mesh Shader implementation used on Alan Wake 2
The primary focus is on the culling efficiency that can be achieved through mesh shaders
presents the performance effects on different culling steps and the amount of final triangles
shows the implementation walkthrough of the mesh shader implementation

Jobs

Graphics Rendering Engineer
Relocate, Remote, Kuala Lumpur

General Arcade, a porting and co-development studio that has worked with a wide range of clients, from indies to AAA developers and publishers, including Larian, From Software, Capcom, Devolver Digital, TinyBuild, and others, is seeking a Software Engineer with a rendering emphasis.

This is a great opportunity to work with a passionate engineering team on cutting-edge industry technologies.

Would you like to advertise your job openings here too? More information

[video] How I animate 3Blue1Brown | A Manim demo with Ben Sparks

the video presents a walkthrough of a Python visualization framework for mathematical expressions
shows how to get started with a simple scene to more complex curve visualization over time
presents tips for workflows that allow the creation of animations efficiently

[video] GPU Reshape - Modern Shader Instrumentation and Instruction Level Validation

the talk provides an overview of instrumentation-based GPU Validation system
explains what kind of validation is currently supported, how operations are written in IL agnostic fashion
additionally presents how to develop your own features for the system
and presents a view into abilities that instrumentation could enable beyond validation (debugging, data visualization, profiling)

Opening the Development of Intel Rendering Toolkit Libraries

intel released the rendering toolkit as open source under Apache 2
the technologies include Embree, Open Image Denoising, OpenOSPRay, and others

Sampling From a Normal (Gaussian) Distribution on GPUs

the paper presents an overview of 3 methods to sample normal Gaussian distributions
discusses the implementation and trade-offs for the presented methods
presents a performance comparison of the implementations running on the GPU

Thanks to Manish Mathai for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 360 - October 6th, 2024

Sun, 06 Oct 2024 04:00:00 +0000

Let's talk about Animation Quality

the article presents a detailed look at the quality aspects that relate to animation
shows the importance of sampling rate for human motion
presents the impact of data precision on animation playback
additionally, it presents a detailed discussion of animation data sets and develops what is required for high-quality research results

Shader composition in Use.GPU

the presentation provides an overview of the difficulties related to the composition of GPU graphics techniques
presents how Use.GPU tries to solve the problems by making composition a first-class design goal
presents how implementation details require completely different implementations
shows solutions to the problems discussed

Interval Shading: using Mesh Shaders to generate shading intervals for volume rendering

the paper proposes the use of tetrahedrons as primitives for volume rendering using mesh shaders
uses mesh shaders to compute the depths of the front and back faces at the same time when interpolating vertex attributes and passing both depths to the rasterizer stage
additionally presents how to use the same idea to implement SDF tracing

Jobs

Graphics Rendering Engineer
Relocate, Remote, Kuala Lumpur

This is a great opportunity to work with a passionate engineering team on cutting-edge industry technologies.

Would you like to advertise your job openings here too? More information

Anisotropic Specular Image-Based Lighting Based on BRDF Major Axis Sampling

the paper proposes an anisotropic specular image-based lighting method that can serve as a drop-in replacement for bent normal techniques
derives an analytic formula to determine the two closest and two farthest points from the reflected direction on an approximation of the BRDF confidence region boundary
compares the method against bent normal technique and ground truth using the GGX specular BRDF

Introducing Driver Experiments to the AMD Radeon Developer Tool Suite

the blog post introduces the new Driver Experiments
this tool allows developers to enable/disable hardware features as well as optimization flags
the post explains what features are exposed and what these options control

Hierarchical Light Sampling with Accurate Spherical Gaussian Lighting

This paper presents an approximation of the importance based on spherical Gaussians (SGs) for light clusters
Each light cluster is represented as an SG light and analytically approximates the product integral of the SG light and a BRDF
presents how to use the method to reduce the MC variance for many light scenes

The Endless Grid

the video presents how to implement the rendering of a shader-based continuous grid system
explains how to generate the grid from a shader, deal with antialiasing, vary the grid sizes with distances, and much more
the implementation is shown and provided using OpenGL

Thanks to Manish Mathai for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 359 - September 29th, 2024

Sun, 29 Sep 2024 04:00:00 +0000

[video] Master Class: Being a Tech Art Detective

the talk presents an overview of the approach tech artists use to investigate effects in other developers’ works
shows how to use various tools, such as RenderDoc, Nsight, Intel GPA, etc. to analyze game content
presents an overview of various techniques from games

Join our speakers in the Netherlands this November for the inaugural Graphics Programming Conference

the blog post covers which sessions AMD will be presenting at the Graphics Programming Conference this November in Breda (Netherlands)
brief overview of the content of each talk (Occupancy and Work Graphs)
as well as which partner talks will be presented

wayback-archive

[video] Gigi Lightning Talks

the video presents a selection of short talks about different techniques and how it was implemented the Gigi framework
covers Reconstruct Materials (differential rendering), FFT 1D/2D, Gaussian Splat Viewer, Fractal Generation
each section provides an overview of the technique and shows the implementation

Device Generated Commands

the blog post provides a brief overview of the state of Vulkan Device Generated Commands
this extension allows applications to write GPU commands from other GPU shaders
lists which drivers currently support the extension

wayback-archive

Jobs

Graphics Rendering Engineer
Relocate, Remote, Kuala Lumpur

This is a great opportunity to work with a passionate engineering team on cutting-edge industry technologies.

Would you like to advertise your job openings here too? More information

Free Learn OpenUSD Trainings

NVIDIA released an interactive and free course about learning OpenUSD concepts
Broken into modules, it explains the different aspects of OpenUSD in written and video form
The provided Jupyter notebook gives the ability to explore the concepts in examples
Starts with the basics and develops into more advanced concepts such as animation and layer ordering rules

wayback-archive

Cache Points For Production-Scale Occlusion-Aware Many-Lights Sampling And Volumetric Scattering

the paper presents an in-depth description of a system for guiding direct light sampling of scenes with hundreds of thousands of lights
describes how the system can use online learning of visibility estimates and how it’s used for accelerating volumetric scattering cases
additionally provides insights into the production experience and limitations

wayback-archive

DeltaTime is a frame behind

the blog post discusses the limitations of a classic delta time-based approach for animations
explains why the techniques inherently are limited
provides a couple of ideas to smooth over the limitations

wayback-archive

FP8 data type - all values in a table

the blog post presents an overview of the various 8-bit floating point formats
shows the limits, precisions, and errors for all possible values in the representations

wayback-archive

[video] CUDA Programming Course – High-Performance Computing with GPUs

free course of 12 hours of content on CUDA development
presents how to get the system setup, explains the basics of GPU development concepts
extends the concepts from writing a first CUDA use-case to optimizing matrix multiplications to a full multi-layer perceptron model

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 358 - September 22nd, 2024

Sun, 22 Sep 2024 04:00:00 +0000

Why does vkMergePipelineCaches exist?

the article discusses how Vulkan Pipeline caches operate
presents how multiple threads creating pipeline create contention and how multiple caches can solve the problem
additionally discusses which flags are required to create truly independent caches between threads

wayback-archive

DirectX Adopting SPIR-V as the Interchange Format of the Future

the blog post introduces the start of the initiative to support SPIR-V in D3D going forward
the plan is to support SPIR-V shaders starting with Shader Model 7 release
discusses limitations with DXIL, how SPIR-V can solve some
additionally, it presents a history of shader intermediate languages

wayback-archive

Jobs

Graphics Rendering Engineer
Relocate, Remote, Kuala Lumpur

This is a great opportunity to work with a passionate engineering team on cutting-edge industry technologies.

Would you like to advertise your job openings here too? More information

GStex: Per-Primitive Texturing of 2D Gaussian Splatting for Decoupled Appearance and Geometry Modeling

the blog post introduces a technique to decouple the appearance and geometry of Gaussian
the approach decouples appearance and geometry through the use of per-Gaussian texture maps
presents a quality comparison against other Gaussian splatting techniques

wayback-archive

Graphics Programming Conference - Schedule

The schedule for the graphics programming conference was released
conference will happen in November in Breda, Netherlands
contains a mix of talks and courses

wayback-archive

Free Learn OpenUSD Trainings

NVIDIA released an interactive and free course about learning OpenUSD concepts
Broken into modules, it explains the different aspects of OpenUSD in written and video form
The provided Jupyter notebook gives the ability to explore the concepts in examples
Starts with the basics and develops into more advanced concepts such as animation and layer ordering rules

wayback-archive

Jobs

3D Programming Team Lead
Toronto or Montreal

As a 3D Programmer Team Lead, you will be responsible for leading a team of talented rendering programmers in the development of the next generation of the Far Cry branded games.

You will collaborate closely with tech artists and other programmers to implement advanced rendering techniques and create stunning visuals that enhance the overall gaming experience.

Your people and project management skills will be used to help the team achieve goals and create great tech.

This is a fantastic opportunity to work on Far Cry with an incredible team that has a wealth of experience and expertise.

Would you like to advertise your job openings here too? More information

GPU Debug Scopes

the article presents how to group API commands in Vulkan through the use of GPU markers
presents which extension exists, how to utilize RAII in different languages to manage the state required
additionally contains pointers to techniques for coloring the events

wayback-archive

AMD RDNA™ 3.5 Instruction Set Architecture (ISA) reference guide is now available

AMD has released an Instruction Set reference guide for RDNA 3.5
The guide covers the shader core execution model, various wave execution models, available instructions, and more

wayback-archive

Vector math library codegen in Debug

the blog post describes the debug build performance of various compilers
presents how different code structures allow the compiler to achieve different levels of optimizations
shows how C-style vector functions can generate more efficient code compared to C++ abstractions

wayback-archive

Gradient Progress Bar - Procedural Shapes and Patterns - Episode 13

the video tutorial presents how to implement a progress bar using SDFs
implementation is shown using Unity and Unreal Visual Shading languages

Thanks to Warren Moore for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 357 - September 15th, 2024

Sun, 15 Sep 2024 04:00:00 +0000

Towards Practical Meshlet Compression

the paper proposes a codec designed explicitly for meshlet compression within a mesh shader
presents how to find optimal generalized triangle strips on meshlets
discusses the lossless compression schema for index data
additionally presents a crack-free quantization for vertex attributes
performance results are presented, and the code is available

Shaders // Vulkan For Beginners #13

the video explains the shader authoring pipeline for Vulkan applications
discusses the different stages involved and how data is passed between stages
shows the C++ necessary to compile shaders from text and load binary compilation results

An introduction to workgraphs part 2: Performance

the article presents a detailed look at D3D12 work graph performance on Nvidia hardware
shows a comparison of classification & raytracing pass using compute shaders as well as workgraphs
uses Nvidia Nsight to collect reasons for the underwhelming performance

Multi-process profiling support in Timing Captures

the blog post shows how to profile an application with multiple processes using PIX for Windows

Surface vs Volume Formats in Tools

the blog post provides a look at different mesh representation formats
covering the pros & cons of various volumetric representations as well as implicit representations
concludes that for authoring workflows, volumetric representations are now feasible and offer various advantages

Jobs

3D Programming Team Lead
Toronto or Montreal

As a 3D Programmer Team Lead, you will be responsible for leading a team of talented rendering programmers in the development of the next generation of the Far Cry branded games.

You will collaborate closely with tech artists and other programmers to implement advanced rendering techniques and create stunning visuals that enhance the overall gaming experience.

Your people and project management skills will be used to help the team achieve goals and create great tech.

This is a fantastic opportunity to work on Far Cry with an incredible team that has a wealth of experience and expertise.

Would you like to advertise your job openings here too? More information

DMMs (displaced micro-meshes)

the paper presents a new method for the representation of skinned meshes with deformations for raytracing
method allows for a compact representation of micro-triangle geometry through the hierarchical encoding of displacements
shows how to animate base meshes and apply additional displaced movements on top

Learn GPU Programming in Your Browser

the blog post introduces WebGPU-powered puzzles that aim to teach graphics programming
different independent units explain concepts and allow users to write and interact with GPU concepts directly in the browser
teaches the fundamentals in text and expands during the different lessons

Freya's Guide to XYZ Axes and Handedness

a diagram that visually explains left-handed vs. right-handed coordinate systems
additionally presents which concepts are independent of the handedness

Thanks to Graham Wihlidal for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 356 - September 8th, 2024

Sun, 08 Sep 2024 04:00:00 +0000

Building Real-Time Global Illumination - Radiance Cascades

the blog post continues the discussion of the Radiance Cascades GI technique
presents how to use information from a low number of rays to reduce the number of artifacts as much as possible
shows the effect of the different steps and how multiple cascades are combined
source code and interactive experiments are available

wayback-archive

Summing Blue Noise Octaves Like Perlin Noise

the blog post presents the effects of combining multiple levels of noise
shows this for blue noise, white noise, box noise, and many more
additionally, it presents how the demo was made using the open-source Gigi prototyping platform

wayback-archive

Determinism

the blog post presents what is required to write deterministic algorithms
discusses algorithmic, multithreaded, and cross-platform considerations
shows how different compiler options and standard library implementation can affect the results

wayback-archive

[video] Explaining my game engine in 2024 - Part1: Triangle mesh tangent space, normal map identification

the video provides a summary of how normal maps can be used to augment surface detail
presents the derivation of the math that, such as tangent spaces, enables the augmentation
additionally presents a method that can be used to approximately detect if a texture contains normal map information

[video] Animated Loading Indicator - Procedural Shapes and Patterns - Episode 11

the video presents how to combine polar coordinates, tiling, and blending to create a procedural loading indicator
the implementation is shown using Unity and Unreal Visual shading languages

Khronos SIGGRAPH 2024 Rewind

the blog post provides a collection of Khronos talks that happened during SIGGRAPH 2024
provides a link to the slides as well as the videos

wayback-archive

EDIZ: A Critical Look at a Simplistic Image Upscaling Approach

the blog post discusses the EDIZ (Error Diffusion Image Zooming) algorithm for image upscaling
presents a high-level overview of the technique
discuss weaknesses and shortcomings
additionally, it presents an implementation of the technique in a code sample

wayback-archive

Adventures in Avoiding DAIS Buffers

the article presents the authors’ findings when exploring Visibility buffers and methods to access UV derivatives
presents the different methods, additional texture channels, ray-tracing into cached vertex transforms, and usage of LDS for short-term caching
presents code implementations of the techniques and presents quality comparison videos

wayback-archive

Screen Space Shadows

the author presents his idea for a screen-space shadow technique that relies on Hierarchical Depth Buffers for each shadow-casting light
starts with a brief overview of virtual shadow maps and the difficulties of debugging them that lead to the idea

wayback-archive

volk - 1.3.295

the release adds support for new Vulkan extensions
exposes VK_AMD_anti_lag, VK_KHR_calibrated_timestamps, VK_KHR_pipeline_binary and others

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 355 - September 1st, 2024

Sun, 01 Sep 2024 04:00:00 +0000

Bringing Explicit Pipeline Caching Control to Vulkan

the blog post provides an overview of the new VK_KHR_pipeline_binary that allows direct retrieval of binary data associated with individual pipelines
this extension allows applications to write custom caching, pre-compilation as well as loading mechanisms
The article explains what the extension allows, how it’s exposed, and considerations when designing a caching system

wayback-archive

The Neural Light Grid: A Scalable Production-Ready Learned Irradiance Volume

the paper introduces a new method for precomputing indirect lighting into a novel form of Irradiance Volume
It discusses how two approaches, one neural net and one parametric function based on ReLU fields
presents performance and memory usage information and presents comparisons against existing solutions
additionally discusses the limitations of the technique

wayback-archive

Software rasterizing hair

the author presents a discussion of how to apply software rasterizing to the problem of hair rendering
technique is based on the Frostbite technique from the presentation “Every Strand Counts: Physics and Rendering Behind Frostbite’s Hair”
discusses the implementation of the steps that make up the technique, such as spline projection, rasterization using edge functions, as well as interpolation information along the strands
WebGPU demo and implementation is available

wayback-archive

Jobs

Graphics Rendering Engineer
Relocate, Remote, Kuala Lumpur

This is a great opportunity to work with a passionate engineering team on cutting-edge industry technologies.

Would you like to advertise your job openings here too? More information

Layers All The Way Down: The Untold Story of Shader Compilation Background

the blog post describes the reasoning why SDL GPU doesn’t require a single portable high-level shader language
focuses on the complexity of the shader ecosystem, how different formats are converted and required to be across platforms

wayback-archive

[video] Animated 80s Sunset Pattern - Procedural Shapes and Patterns - Episode 10

the video explains how to implement a perspective-animated grid with a color gradient
presents how to implement perspective wrap in UV space
combines with other nodes to create the effect
implementation is shown in Unity and Unreal visual shading languages

The GPU API MkII

SDL GPU abstraction has been merged into the main branch
provides a D3D11, D3D12, Metal and Vulkan implementation layer

wayback-archive

The untimely demise of an image upscaler

the article presents the effects of applying ML upscaling algorithms repeatedly to the same image
compares against the effect of repeatedly scaling an image using a Lanczos filter

wayback-archive

Thanks to Yuwen Wu for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 354 - August 25th, 2024

Sun, 25 Aug 2024 04:00:00 +0000

Characterizing CUDA and OpenMP Synchronization Primitives

the paper presents an overview of the performance characteristics of synchronization primitives
discusses what factors affect performance and presents performance results for these factors
presents an open-source testing framework to measure these effects

VK_KHR_pipeline_binary

this proposal discusses an alternative approach to Pipeline caching in Vulkan
explains limitations of the existing Vulkan methods
presents how the proposed solutions suggest solving limitations and giving application developers more control

wayback-archive

Poor Foundations in Geometric Algebra

the author presents how Geometric Algebra concepts are often defined in the literature and what better definitions look like
discusses different concepts such as Inner Products, Contractions, and duals
additionally ensures comparing the best possible GA implementation against the best possible matrix implementations for a more fair comparison of the implementations

wayback-archive

Compute With DirectX 12 – Part 2: The Setup

the D3D12 tutorial presents how to get started with compute shader usage
explains the steps required to setup shaders, create the necessary API objects, and execute the shader
source code is available

wayback-archive

Jobs

Graphics Rendering Engineer
Relocate, Remote, Kuala Lumpur

This is a great opportunity to work with a passionate engineering team on cutting-edge industry technologies.

Would you like to advertise your job openings here too? More information

Workarounds for issues with mesh shaders + Vulkan + HLSL

the blog post explains how HLSL shaders compiled for mesh shader usage with Vulkan require special annotations
default shader behavior doesn’t handle it correctly, and it only fails on AMD without any validation errors

wayback-archive

Recreating Nanite: Raytracing

the article discusses a method to allow virtual geometry to be represented in ray-tracing scenes
explains issues related to BVH construction and LOD selection
shows how to integrate generation logic into loading and runtime frames

wayback-archive

Visualizing 4D Pt.1

the video develops a mental model for 4-dimensional space
explores where the space is located and what it represents
starts exploring the space via generalization of concepts from 2D to 3D and finally to 4D

Decoding instructions with the machine-readable AMD GPU ISA specifications

the short blog post presents how to use human-readable ISA documentation to decode one CDNA instruction

AMD GPU machine-readable ISA documentation

AMD released ISA documentation for RDNA2 and CDNA ISA
additionally, it presents a small example application that presents how to use the released data

wayback-archive

Gigi: Rapid Prototyping Platform for Real-Time Rendering

the blog post introduces a prototyping programming platform for shader development
exposes a way to use a visual node graph editor and HLSL shader nodes for the development of shader techniques
allows the export of the developed solution into D3D12 code (more targets will be supported later)
the video tutorial presents how to use the system and the debug tools available to implement a box blur technique

wayback-archive

Programmable Vertex Pulling // Intermediate OpenGL Series

the video tutorial explains how to load vertex information from within a Vertex Shader instead of relying on fixed function hardware
provides an overview of the concepts of Programmable Vertex Pulling and use cases that are enabled through it
implementation is shown using OpenGL

Thanks to Lesley Lai for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 353 - August 18th, 2024

Sun, 18 Aug 2024 04:00:00 +0000

Seamless Rendering on Mobile: The Magic of Adaptive LOD Pipeline

the presentation discusses how to use cluster-based mesh representations to allow transitions between model levels
shows how to calculate the cluster representations calculate cluster error metrics to allow LOD selection
additionally, it discusses how to integrate support for skinned meshes
provides performance numbers for the different stages of the pipeline

wayback-archive

Exact Polygonal Filtering

the blog post describes an approach to calculating accurate filtering of polygonal shapes with closed-form solutions
discusses the underlying theory of the method and implementation

wayback-archive

Rust GPU Transitions to Community Ownership

the blog post announces that Rust GPU (compiling Rust into SPIR-V) will transition from Embark to Community ownership
a brief overview of the goals and next steps

wayback-archive

Jobs

Graphics Rendering Engineer
Relocate, Remote, Kuala Lumpur

This is a great opportunity to work with a passionate engineering team on cutting-edge industry technologies.

Would you like to advertise your job openings here too? More information

Closed-Form 3x3 Matrix Decompositions

the article discusses a closed-form solution for polar and singular value decomposition of 3x3 matrixes
based on findings from “Isotropic ARAP energy using Cauchy-Green invariants”
contains the source code implementation
additionally, it discusses how to improve numerical stability

wayback-archive

[video] MaterialX Virtual Town Hall 2024

the presentation covers the current state of OpenPBR and the state of integration into MaterialX
updates on the state of support in tools
additionally provides a look at the upcoming developments

[video] Work Graphs: Hands-On with the Future of Graphics Programming

the talk provides an overview of the D3D12 work graph API
provides details into how the API is mapped onto AMD hardware

Why Do Reflections Stretch At The Horizon?

the post provides an explanation of Microfacet Models
shows how the reflections are affected by the surface and the view directions
presents how this explains the look of reflections on water surfaces as they approach the horizon

wayback-archive

Thanks to Lesley Lai for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 352 - August 11th, 2024

Sun, 11 Aug 2024 04:00:00 +0000

Variable Rate Shading with Visibility Buffer Rendering

the presentations provide a detailed overview of the challenges when implementing Visibility Buffer RenderinVisibility Buffer Rendering
discusses why classical rasterization techniques could be limiting on high triangle density and how
presents the different challenges that need to be solved when implementing the technique
for the challenges, present different possible solutions, discuss tradeoffs, and present performance numbers

wayback-archive

Ray Tracing Harmonic Functions

the paper presents a technique that allows Harmonic Functions to be sphere-traced directly
discusses use cases where the Harmonic Functions can be applied, such as grid shells, surface reconstructions
A real-time shader toy demo is provided

wayback-archive

Synthesizing Realistic Clouds for Video Games

the talk presents an overview of the Decima (Horizon Zero Dawn) cloud rendering system
covers the different phenomenons that need to be combined to create realistic clouds
discusses how to implement and combine the different aspects into a sading and modeling solution

wayback-archive

Vulkan SC 1.0.15 Released: SPIR-V Validation and New NVIDIA Drivers for Desktop Systems Available

the blog posts documents which extensions have been ratified and included as part of Vulkan Safety Critical
clarifies how to provide SPIR-V for use with the validation layer
additionally, it presents an update on the Driver support

wayback-archive

Jobs

Graphics Rendering Engineer
Relocate, Remote, Kuala Lumpur

This is a great opportunity to work with a passionate engineering team on cutting-edge industry technologies.

Would you like to advertise your job openings here too? More information

Improving GPU Performance by Reducing Instruction Cache Misses

the paper presents how to detect if a GPU workload is limited by instruction cache misses
discusses techniques that can be applied to reduce instruction cache misses
shows how to see the effect of the changes using the NVIDIA Nsight Compute tool

wayback-archive

Querying the PIX Timing Capture file format

the blog post reveals that pix timing captures are internally using SQLite as a storage format
provides SQLite code to allow access to the data in the container
the provided example code shows different use cases, including comments to describe the functionality of each demo sample in detail

wayback-archive

Highlights from HPG Conference 2024: Four exciting new research papers

the blog post introduces AMD papers released at HPG (High-Performance Graphics) 2024
covers Real-Time Procedural Generation with GPU Work Graphs, H-PLOC – Super-Fast BVH Construction, HIPRT – A Ray Tracing Framework in HIP as well as DGF – Geometry Compression for Micropolygon Meshes
each comes with a short video to summarize the main paper developments and takeaways

wayback-archive

[video] Game Engine Programming 071.1 - Introduction to Physically Based Rendering

the video presents a brief summary of Physically Based Rendering methods
discusses the model as presented by Google Filament
closes with a comparison against Phon shading results

[video] Pass me that render, please // Vulkan For Beginners #12

the video tutorial explains the Vulkan render pass concept
shows how to use a render pass to clear the framebuffer to a constant color

Thanks to Jon Greenberg for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 351 - August 4th, 2024

Sun, 04 Aug 2024 04:00:00 +0000

[video] Keynote by Peter Shirley: 60 fps rendering: past, present, and future

The keynote covers the history of computer graphics research (in algorithms, materials) with a focus on techniques used until today
discusses a look into the future by presenting techniques of the past that were not successful with current research
additionally presents how the user base might influence research directions in the future

A Visual Guide to Quantization

the blog post visuall explains floating point quantization techniques
presenting 32-bit, 16-bit as well as 8-bit floating point formats
explains the concepts in relationship to LLM models

wayback-archive

[video] EGSR2024: Ray Traced Stochastic Depth Map for Ambient Occlusion

the talk recording discusses a method for calculating ambient occlusion using stochastic depth maps to optimize ray-traced AO
presents a quality comparison with different resolutions and different test cases
additionally compares against screen space solutions

SIGGRAPH 2024 Links

a collection of links to SIGGRAPH 2024 resources
includes courses, talks, posters as well as open source data releases

wayback-archive

[pptx] Flexible and Extensible Shader Authoring in Frostbite with Serac

the Siggraph presentation presents Frostbites’ shader authoring solution
shows how it allows extensible component replacement, mixing of different implementations, and automatic interpolation logic
additionally discusses what worked well, what still needs to be improved

wayback-archive

Activision Releases Call of Duty®: Warzone™ Caldera Data Set for Academic Use

the blog post announces the release of the geometry for the Call of Duty Warzone map in USD format
The dataset contains five million meshes, 28 million primitives, and more than one billion point instances
license allows use for non-commercial, academic use

wayback-archive

Reconstructing Surfaces from SDFs via Tangent Points

the paper presents a method that converts an SDF into a point cloud
point cloud is then converted into a mesh surface
compares the quality of the new algorithm against existing solutions

wayback-archive

[video] Game Engine Programming 070.3 - Mikk TSpace

the video episode explains how to integrate Mikk TSpace tangent space calculation into the engine
discusses the importance of consistent tangent space authoring for good results

Thanks to Jon Greenberg for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 350 - July 28th, 2024

Sun, 28 Jul 2024 04:00:00 +0000

GPU-friendly Stroke Expansion

the paper presents a new method to apply strokes to lines in a GPU-friendly way
presents how to lower filled and stroked Bézier paths into an Euler spiral as an intermediate representation
tests and shows the performance of the implementation on CPU and GPUs
video and code have been released

wayback-archive

[video] Karen Ghavam Keynote at HPG 2024

the presentation recording discusses the development of the Vulkan ecosystem
how LunarG came to deliver the Vulkan SDK, the history of the developments, and ecosystem overview
presents a look into the development approach, improvements, and how it worked in practice

MaterialX and OpenPBR Town Hall

the presentation covers the current state of OpenPBR and the state of integration into MaterialX
updates on the state of support in tools
additionally provides a look at the upcoming developments

wayback-archive

Concurrent Binary Trees for Large-Scale Game Components

the paper presents a concurrent binary tree (CBT) for adaptive triangulations of arbitrary (half-edge) meshes
shows how to use a CBT as a memory management construct

wayback-archive

H-PLOC: Super-fast, high-quality BVH construction

the paper presents an approach to BVH construction based on the parallel locally- ordered clustering approach (PLOC) and PLOC++
shows how to implement the algorithm in a single kernel launch
explains a method to convert the binary BVH into wide BVHs where each parent can have an N number of child nodes

wayback-archive

DGF: A Dense, Hardware-Friendly Geometry Format for Lossily Compressing Meshlets with Arbitrary Topologies

the paper presents a block-compressed geometry format
explains the data packing applied, what can be encoded, and how to compress it
presents memory comparisons against existing solutions
additionally shows how hardware support with ray-tracing BVH builds might reduce memory consumption

wayback-archive

Procedural generation

the blog post provides an overview of generating a procedural world
discusses how biomes, terrain, grass, and flowers are placed
additionally shows how they turned the flat world into a sphere

wayback-archive

Cache Points for Production-Scale Occlusion-Aware Many-Lights Sampling and Volumetric Scatterin

This paper provides a deep dive into Disney’s Hyperion Renderer’s many-lights sampling system
presents how it caches and interpolates light sampling distributions at points throughout space
Presents how the approach allows the incorporation of learned visibility estimates into light sampling distributions

wayback-archive

GigaVoxels DP : Starvation-Less Render and Production for Large and Detailed Volumetric Worlds Walkthrough

the paper presents a voxel scene processing model that allows on-demand production of data during rendering
presents how to overlap the work to reduce synchronization and starvation issues
shows a way to visualize the execution of GPU cores on a dynamic timeline

wayback-archive

Introducing Frame Latency Meter (FLM) v1.0

AMD released a tool to help measure input to screen latency on Windows
users can specify a region to watch for changes; if a simulated mouse event triggers a change in this region, it calculates the latency and records for later analyses

wayback-archive

Screen Space Indirect Lighting with Visibility Bitmask: Improvement to GTAO/SSAO Real-Time Ambient Occlusion Algorithm (GLSL Shader Implementation)

the blog post provides an overview of the author’s implementation of Screen Space Indirect Lighting with Visibility Bitmask
presents an overview of the technique, discussing tradeoffs of the implementation
shows the results in-engine in a test scene and shows the shader implementation in GLSL

wayback-archive

[video] Normal Mapping Adventures // OpenGL Intermediate Series

the video tutorial provides an overview of the normal mapping technique
explains the limitations of vertex and interpolated vertex lighting
followed by an explanation of how normal maps allow additional information and how to generate this required data
finally, it provides a detailed discussion of the implementation steps using OpenGL/GLSL

Thanks to Jhon Adams for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 349 - July 21st, 2024

Sun, 21 Jul 2024 04:00:00 +0000

Foliage in AMD FidelityFX™ Brixelizer GI

the 2-part article series explains how Brixelizer GI (a sparse distance field backed GI solution) limitations affect Foliage geometry
part 1 explains the limitations, and Part 2 covers how to extend the system to support Foliage (alpha-tested) geometry
the implementation of an additional Alpha cache helps to resolve the problem
additionally, it discusses how the system deals with animations

wayback-archive

[video] Rectangle Signed Distance Field - Procedural Shapes and Patterns - Episode 4

the video presents how to create an SDF for a rectangle using Unity and Unreal
effect allows the modification of many parameters, including size, edge thickness, corner radius, and stroke thickness

Digital images

the article explains how images are represented
covers the build-up from single binary images to grayscale and, finally, color images
a brief discussion of the concept of resolution, human vision as well as DPI

wayback-archive

Real-Time Procedural Generation with GPU Work Graphs

the paper presents a detailed look at how to use D3D12 work graphs to generate a procedural world
shows how multiple generation phases are combined with GPU ray-tracing to create a world
discusses how the BVH structure is used to place markers, generate Ivy, marketplace arrangements, as well as ground clutter
presents results with performance information

wayback-archive

GPU Work Graphs mesh nodes in Microsoft DirectX® 12

the series of articles discusses how work graphs are now allowed to execute mesh rendering work
part 1 how presents the getting started guide through the code sample on basic setup
the second part focuses on best practices for performance
finally, the last part discusses how to use work graphs to procedurally generate and render a whole game world

wayback-archive

PIX 2407.17-preview: Mesh Nodes in Work Graphs

A brief blog post discusses what aspects of the new mesh nodes preview for d3d12 can be debugged using Pix

wayback-archive

SCALE by Spectral Compute

SCALE is a GPGPU toolchain allowing CUDA programs to be natively run on AMD GPUs
discusses what hardware is currently supported and how it’s achieved
documentation provides examples of how to get started

wayback-archive

Instanced Skeletal Meshes with GPU Driven Animations using Vulkan

the article discusses a solution to allow GPU instanced and animated models using Vulkan
presented solution pre-calculates all bone transformations for all frames of the animations and calculates the sample index during the vertex shader stage

wayback-archive

Real-Time Hair Rendering with Hair Meshes

the paper to be presented at SIGGRAPH 2024 presents a technique for rasterizing hair from hair strands
since it’s based on Hair meshes (which are protected by patents), I did not read it and can’t provide a summary
ensure to contact your legal team before proceeding to read

wayback-archive

Thanks to Vivitsu Maharaja for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 348 - July 14th, 2024

Sun, 14 Jul 2024 04:00:00 +0000

Behind the scenes: the Vulkan SC Ecosystem

the blog post provides insights into the Vulkan variant for safety-critical applications
shows the differences between stock Vulkan
presents a detailed look at the architecture and how the variant is maintained

wayback-archive

LucidRaster: GPU Software Rasterizer for Exact Order-Independent Transparency

the paper discusses the implementation of a compute-shader-based rasterizer specialized for order-independent transparency
explains the implementation and choices made
presents performance comparison against other solutions
additional explains the limitations of the current implementation

wayback-archive

Introducing the AMD FidelityFX™ Breadcrumbs library

the blog post introduces the new AMD library that aims to improve GPU hang debugging
allows developers to insert information into the command buffer
in case of crashes, it allows to figure out which part of the frame has finished execution and what is still outstanding
supports both Vulkan and D3D12

wayback-archive

Introducing AMD FidelityFX™ Brixelizer

the blog post presents an overview of using Brixelizer for Ambient Occlusion and soft shadows
shows performance number and discusses what aspects influence performance
concludes with a summary of best-practices to consider when eveluating Brixelizer

wayback-archive

Introducing Arm Accuracy Super Resolution

the blog post introduces Arm Accuracy Super Resolution
this upscaler is based upon AMD FSR 2.0 and optimized mobile GPUs
shows performance numbers as well as quality comparison against other solutions

wayback-archive

[video] Upscaling Face-Off: FSR 3.1 vs DLSS 3.7/ XeSS 1.3 - Has AMD Improved?

the video provides a comparison to present the improvements done with FSR 3.1
presents a comparison against other upscaling solutions

[video] Combining Signed Distance Fields - Procedural Shapes and Patterns - Episode 3

the video tutorial presents how to combine multiple SDFs in shaders
this information is used to implement a lava lamp effect
implementation is shown using Unreal and Unity visual shading languages

[video] Image Memory Barriers // Vulkan For Beginners #11

the video provides an overview of the concept of image barriers
explains what kind of hardware-defined memory layout changes might be associated with image layouts
presents how to implement the barriers in Vulkan required to solve the Vulkan validator messages for the swap chain presentation

[video] 3D Toon Rendering in 'Hi-Fi RUSH'

the GDC presentation explains how the toon rendering effect was achieved
the game uses a customized UE4 version, and the talk shows which stages need to be modified
covers the lighting, cross-hatching, and halftone patterns, as well as how the outlines are applied

Open Sourcing DXIL Validator Hash

the blog post announces the intent to open source DXIL shader validation as well as to support a mode to skip hash validation
explains what hash validation is, what the current state is, and what issues arise because of it

wayback-archive

State of Text Rendering 2024

The survey paper presents a very detailed look at the state of font rendering
discusses a high-level overview of font rendering systems, implementation, and limitations
lists a long list of available solutions with brief summaries, as well as what solutions well-known software projects use
showing performance tests of different solutions

wayback-archive

Graphics Programming Conference

a new graphics programming-focused conference in Breda, Netherlands
The call for speakers is still open till July 31st

Thanks to Leonardo Etcheverry for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 347 - July 7th, 2024

Sun, 07 Jul 2024 04:00:00 +0000

[video] Exploring a New Approach to Realistic Lighting: Radiance Cascades

the video explains visually step-by-step how the Radiance Cascades technique aims to solve Global Illumination
explains the underlying idea based on observations of linear and angular resolution
presents results and also shows what the limitations are

Spatial Indexing Algorithms

X thread with a collection of Spatial Indexing Algorithms
covers the pros/cons and what the techniques are typically used for

wayback-archive

[video] Lossless Scaling: Frame Generation For Every Game - But How Good Is it?

the video presents how the “Lossless Scaling” mod generates in-between frames for smoother game output
explains that the mode only uses color output without any additional meta-data or motion vectors
compares the technique against FSR 3.1 and DLSS 3.7

[video] Circle Signed Distance Field - Procedural Shapes and Patterns - Episode 2

the video tutorial presents how to create a signed distance field for a circle
the implementation is shown using Unity and Unreal
additionally presents a first overview of different shapes this series will be targeting to create

[video] KEYNOTE: Use.GPU - Declarative/Reactive 3D Graphics by Steven Wittens

the keynote presentation discusses the Use.GPU technology
presents issues of graphics technology and how the author aims to improve the authoring
discusses how the React style has been applied to GPU app authoring
provides a walkthrough of the implementation logic and examples
shows how to compose shaders

GPU-friendly Stroke Expansion

the paper presents a new method to apply strokes to lines in a GPU-friendly way
presents how to lower filled and stroked Bézier paths into an Euler spiral as an intermediate representation
tests and shows the performance of the implementation on CPU and GPUs

wayback-archive

VMF Diffuse: A unified rough diffuse BRDF

the paper introduces a unified BRDF that allows a consistent expression of smooth to highly rough porous behavior materials
compares the results against ground-truth
The presented solution might be approximated for real-time usage

wayback-archive

Compute shader wave intrinsics tricks

the blog post describes a couple of available shader intrinsics that allow the different threads of a shader wave to cooperate
starts with simple techniques and increasing complexity

wayback-archive

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 346 - June 30th, 2024

Sun, 30 Jun 2024 04:00:00 +0000

A Practical Real-Time Model for Diffraction on Rough Surfaces

the paper introduces a real-time BRDF model addressing diffraction on rough surfaces
shows the improved realism in Unity over the Cook–Torrance model
presents a performance comparison against a base Cook–Torrance implementation

wayback-archive

GPU profiling for WebGPU workloads on Windows with Chrome

the blog post presents how to profile WebGPU applications with Nsight, PIX, and Radeon GPU Profiler
The presented solution takes advantage of context sharing and dll interception

wayback-archive

Residual path integrals for re-rendering

the paper presents an approach for incremental re-rendering of scenes
it formulates image differences as a residual path integral, solved with importance sampling and path mapping
presents speed-ups over previous methods and independent frame rendering

wayback-archive

Jobs

C++ Gameplay and UI Programmers
Auckland, New Zealand

Grinding Gear Games are seeking experienced C++ Gameplay and UI Programmers to join our incredibly talented team. We’re after programmers to help design and implement gameplay and UI elements for Path of Exile using modern C++.

Would you like to advertise your job openings here too? More information

High Performance Graphics - Conference Program

the conference program for the High-Performance Graphics has been released
will take place between July 26 to 28 in Denver

wayback-archive

[video] SIGGRAPH 2024 Technical Papers Trailer

the video shows an overview of Technical Papers to be presented at SIGGRAPH 2024
shows a quick showcase of each trailer and a brief summary of the presented approaches

Patch Decomposition for Efficient Mesh Contours Extraction

the paper presents a method for the efficient extraction of mesh contours
it proposes a simple, flat data structure that is GPU-friendly and uses patches bounded by normal cones and sphere
discusses how to generate these patches and improve bounding sphere calculations
presents a performance comparison against CPU techniques

wayback-archive

[video] Submitting Command Buffers // Vulkan For Beginners #10

the next episode of the Vulkan tutorial series presents how to execute work to the GPU
presents how to clear the image to a fixed color and integrate it with the presentation process

[video] Intro To Procedural Shapes and Patterns - Episode 1

new video tutorial series that will cover how to generate procedural shapes and patterns from shaders
implementation is shown using Unity and Unreal Engine
this video focuses on the reasons why to use the approaches and how to create a pattern with antialiased edges

[video] I Tried Turning Games Into Text

the video presents an approach to develop an ASCII art shader approach (converts 3D rendering to text)
discusses methods, issues of the techniques, improvements and presents results on several different games
presents how to map the techniques onto a compute shader execution model
additionally presents other techniques that could be built upon

A quick introduction to workgraphs

the blog post presents a walkthrough on how to implement a raytracing classification shadow optimization using D3D12 work graphs
first discuss an overview of the technique
followed by a presentation on how to express this technique using HLSL and D3D12 work graphs

wayback-archive

Thanks to Bruno Opsenica for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 345 - June 23rd, 2024

Sun, 23 Jun 2024 04:00:00 +0000

[video] GDC 2024 - GPU Work Graphs: Welcome to the Future of GPU Programming

the GDC video presents a discussion of the new work graph features for D3D (also a Vulkan AMD-specific extension exists)
explains the issue with the current ExecuteIndirect model
shows an overview of the API model and how it aims to solve the challenges
presents an overview of a compute shader rasterizer and a runtime GPU scattering system based on the technology
additionally discusses the support level

CPU performance optimization guide – part 1

the first blog in a series about CPU optimizations
this part presents how different implementations of max between floats can generate very different code
presents the effect of branch misprediction on performance and how to use the AMD profiler to detect through hardware counters

wayback-archive

[video] I3D 2024 Papers Session 6 - Efficient Forward and Differentiable Rendering

the video recording of I3D 2024 sessions covers the following papers
Efficient Particle-Based Fluid Surface Reconstruction Using Mesh Shaders and Bidirectional Two-Level Grids, ShaderPerFormer: Platform-independent Context-aware Shader Performance Predictor
Transforming a Non-Differentiable Rasterizer into a Differentiable One with Stochastic Gradient Estimation
these papers cover a focus on performance from an academic focus

Jobs

C++ Gameplay and UI Programmers
Auckland, New Zealand

Would you like to advertise your job openings here too? More information

[video] Triangle Visibility Buffer 2.0

the talk provides an overview of the experimental Triangle Visibility Buffer 2.0 implementation
The presented approach uses only compute shaders to write the visibility buffer
discusses the pipeline design, different approaches based on triangle sizes, and how performance compares
additionally presents which features are still missing compared to hardware rasterization

From microfacets to participating media: A unified theory of light transport with stochastic geometry

the paper presents a method that aims to unify microfacets and volumes for light transport purposes
the paper shows that both can be expressed as stochastic implicit surfaces (SIS) and, more specifically, Gaussian process implicit surfaces (GPIS)
discusses the derivation, representation generation, and tracing aspects of GPIS
additionally discusses limitations regarding performance and quality

wayback-archive

5 Reasons Why Box Plots are the Better Default Choice for Visualizing Performance

the blog post presents why the author suggests using box plots over bar charts as the default way to represent performance
shows annotated examples of how box plots can express a lot of helpful information in a concise form

wayback-archive

Thanks to Jon Greenberg for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 344 - June 17th, 2024

Mon, 17 Jun 2024 04:00:00 +0000

[video] REAC 2024 DAY 1 Testing Rendering Code at Frostbite

the talk presents the system used by EA’s Frostbite team to test the rendering engine
shows an overview of the current state of the system and why they are the way they are
discusses all the complexities and difficulties
shows the tooling available and how different tools exist for different use cases
additionally discusses trade-offs and development approaches

[video] Coding Adventure: Optimizing a Ray Tracer (by building a BVH)

the video explains the concept of a BVH (bounding volume hierarchy) and presents how it increases the performance of a raytracing implementation
shows a detailed explanation and many visualizations of the behavior of the data structure and how to build an efficient implementation
presents different heuristics that can be used to order the data for efficient access
shows the results and presents performance improvements

Raymarching explained interactively

the article provides an interactive walkthrough into the implementation of the Raymarching algorithm
explains the logic of signed distance functions in 2D and expands these to 3D
presents the implementation of a simple 3D raymarching scenes
the provided code samples are interactive and can be used to get a better understanding of the presented techniques through experimentations

wayback-archive

[video] Quaternions to Homogeneous Points, Lines, and Planes

the second path of the math tutorial series from GDC 2024 extends the dual quaternion knowledge (see last week 338 for prerequisite)
starts by developing an intuition for plane representation (normal + distance), difference between positions and directions, and behavior under reflections
additionally explains the understanding of homogenous concepts

[video] REAC 2024 DAY 2 Modernizing geometry rendering in Alan Wake 2

the presentation presents updates done to the rendering pipeline of the internal engine used for Alan Wake 2
focuses on explaining the technique selection and why the choices were made
in-detail discusses the meshlet geometry pipeline and changes to the material system
additionally discusses updates on the used transparency models

[video] I3D 2024 Papers Session 5 - Noise and Reconstruction

the video recordings of Noise and Reconstrictions papers from I3D have been released
covers FAST: Filter-Adapted Spatio-Temporal Sampling for Real-Time Rendering, Filtering After Shading With Stochastic Texture Filtering, and Cone-Traced Supersampling for Signed Distance Field Rendering

The engine of the future.

following the REAC 2024 conference, this author composes his 10 predictions on how graphics engine architecture might evolve
looks back at the history, current developments and looks into the future
additional discusses how mobile requirements vary and how it might indicate a future on consoles and PCs as well

wayback-archive

Thanks to Graham Wihlidal for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 343 - June 9th, 2024

Sun, 09 Jun 2024 04:00:00 +0000

[video] Rendering Engine Architecture Conference

the video recordings for the Rendering Engine Architecture Conference have been released
covering a large number of topics from resource management, GPU-based mesh pipeline, testing approaches, and much more

Virtual Geometry in Bevy 0.14

the blog post provides a detailed discussion of implementing meshlet-based virtual geometry rendering into Bevvy
discusses how meshlet LODs are calculated, how meshlet culling has been implemented, and how they are rendered without mesh shader support
presents findings from different approaches and discusses the pros/cons of the various approaches
Additionally, it shows the integration work for supporting systems (depth pyramid generation, material shading, etc.).

wayback-archive

How I learned Vulkan and wrote a small game engine with it

the blog post discusses the author’s experience learning Vulkan through the development of a small 3d engine
presents the approach for keeping things focused and decisions leading to using Vulkan
explains the API concepts and how they are used in the engine (shaders, pipelines, queues, etc.)
additionally presents how higher-level techniques are implemented inside the engine

wayback-archive

Seiler’s Interpolation

the short paper presents how to reformat bezier interpolation using cheaper functions
shows the implementation of quadratic, cubic, and higher-order polynomials
additionally shows how a GPU implementation could take advantage of hardware linear interpolation

wayback-archive

On Hash Functions for the GPU

the article presents a geometric and statistical analysis of the PCG2D hash function
explains the terminology of random number generators and how they can be mapped onto GPUs
visualization of provided using shader toys

wayback-archive

Machine Learning on the GPU - Case Study: Open Image Denoise

the blog post provides a high-level view that explains machine learning concepts for practical usage by graphics programmers
presents the individual concepts and how DirectML maps them into compute shaders
additionally presents an overview of the different passes that make up the Open Image Denoise implementation

wayback-archive

Academy Software Foundation Releases OpenPBR 1.0

the blog post introduces the release of the first stable release of OpenPBR
discusses the importance of the standard and the history of its development
MaterialX now contains a reference implementation of the model

wayback-archive

Perspective-Correct Interpolation

the article presents how a rasterizer calculates intermediate values on a triangle
explains barycentric Interpolation and explains the cause for common artifacts on PS1-level hardware
then derives perspective-correct Interpolation that resolves the artifacts

wayback-archive

[video] I3D 2024 Papers Session 4 - Points and Splats

The videos for I3D paper presentations have been released
covering Reducing the Memory Footprint of 3D Gaussian Splatting, SimLOD: Simultaneous LOD Generation and Rendering for Point Clouds
additional Deblur-GS: 3D Gaussian Splatting from Camera Motion Blurred Images as well as Light Field Display Point Rendering

[video] The OpenGL Software Ecosystem

the video provides an overview of the OpenGL Ecosystem
explains the history of OpenGL and how OS integration compares to Direct3D
presents what software layers are involved and which software components enable easier cross-platform development

Thanks to Cort Stratton for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 342 - June 2nd, 2024

Sun, 02 Jun 2024 04:00:00 +0000

Efficient Visibility Reuse for Real-time ReSTIR

the paper presents a variance reduction technique for ReSTIR aimed at reducing shadow noise
presents a comparison against existing methods
discusses side-effects of the technique

wayback-archive

[video] I3D'24 Technical Paper: Filtering After Shading with Stochastic Texture Filtering

extended presentation of the I3D paper presentation discussed last week
the paper presents an investigation into applying texture filtering after shading instead of before shading
shows comparisons of the approaches and a background into the underlying theory
presents guidelines on the tradeoffs and when to use different approaches

Specular Polynomials

the paper presents a way to reformulate SDS (a path with at least a specular, diffuse, specular bounce) paths into a polynomial system
explains how to use root finding to solve the paths
shows the presented solutions for caustics in a unidirectional ray tracer

wayback-archive

Ray Tracing with Voxels in C++ Series – Part 6

the article series extends the voxel rendering implementation to use path tracing
discusses and explains the different components of the rendering equation
additionally presents the effect of importance sampling for reduced convergence time

wayback-archive

Microsoft® DirectSR and AMD FidelityFX™ Super Resolution technology

the blog post explains the new DirectSR (Super Resolution) API
provides a walkthrough of the API and how to integrate it into an existing engine
provides an overview and discussion of the different exposed parameters

wayback-archive

DXC 1.8.2405 Available Now, Including HLSL 202x

the blog post introduces the ongoing work of implementing future HLSL versions directly into Clang
discusses the expected difference between legacy and future HLSL versions
additionally shows the first version of DXC compiled with clang and performance improvement

wayback-archive

Renderdoc - Version v1.33

the latest version of Renderdoc includes a custom and improved DXIL disassembler
additionally lists the improvements for SM6.6 feature support

wayback-archive

Real-Time Physically Guided Hair Interpolation

the paper presents a new method that aims to improve hair interpolation from a smaller number of guided hairs
presents the theory and implementation of the technique
compares against existing solutions in quality and performance

wayback-archive

Implementing General Relativity: Rendering the Schwarzschild black hole, in C++

the blog post provides a high-level introduction to general relativity
takes the underlying theory and shows how to convert it into code
shows a C++ based implementation of the technique

wayback-archive

Texture Streaming

the blog post discusses the streaming system implementation in the Wicked Engine
discusses how the data is provided, loading streaming processed in the background, and finalized for rendering
additionally discussed techniques to improve streaming information, such as GPU streaming feedback buffers

wayback-archive

[video] I3D 2024 Papers Session 2 - Light Transport and Storage

video of the I3D 2023 Paper session on Light Transport
covers Bounded VNDF Sampling for the Smith–GGX BRDF, ZH3: Quadratic Zonal Harmonics and Interactive Rendering of Caustics using Dimension Reduction for Manifold Next-Event Estimation

Thanks to Matt Pharr for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 341 - May 26th, 2024

Sun, 26 May 2024 04:00:00 +0000

Construction of a Microfacet Specular BSDF: A Geometric Approach

the paper provides a walkthrough explanation of the different components that define a BSDF (bidirectional scattering distribution function) that defines the shading behavior of a materials
covers the underlying theory, explaining the derivation as well as the geometric interpretations

wayback-archive

Hemispherical Lighting Insights

the paper introduces models to solve the reconstruction of irradiance in the vertex-normal space
applies the developed framework to hemispherical and cone occlusion to volumetric lighting
as well as mitigating light leakage for normal-mapped surfaces’ appearance of runtime ambient occlusion
shadertoy implementation is provided

wayback-archive

Ray Tracing with Voxels in C++ Series – Part 5

the series on voxel ray tracer continues by presenting how to accumulate samples over time with a nonstatic camera
explains temporal pixel reprojection, how to deal with sub-pixel blending, and how to improve results with occurring object occlusions

wayback-archive

Getting Started In Computer Graphics

the blog post provides a detailed description for programmers interested in graphics programming
explains what the job entails, different specializations in games, and what topics graphics programmers often work on
additionally gives insights into the technologies the author recommends to start learning with

wayback-archive

Sun Beams / God Rays Shader Breakdown

the article explains an approach to implementing Sun Beams using Billboarding techniques
implementation is shown using the visual shading language of Unity

wayback-archive

Agility SDK 1.614.0: R9B9G9E5 support for Render Targets and UAVs

the blog post presents that the latest D3D12 SDK update introduces support for R9B9G9E5 for Render Target and UAVs
explains how the R9B9G9E5 format allows higher precisions compared to half-floats and less memory usage than float formats
additionally expressed the importance of verifying hardware support

wayback-archive

Unity Shader Graph Basics (Part 8 - Scene Intersections 1)

the video shows how to implement a shader effect that allows objects to change their appearance close to existing depth values in the depth buffer
the presented technique relies on a rendering order that ensures the depth values are written before the objects want to read them
technique is implemented using the visual shader language of Unity

Recording the clear command // Vulkan For Beginners #9

the video tutorial continues to discuss the implementation of a Vulkan renderer
this week’s videos explain how to clear the back buffer to a solid color in every frame
C++ implementation is shown

Thanks to Graham Wihlidal for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 340 - May 19th, 2024

Sun, 19 May 2024 04:00:00 +0000

Filtering After Shading with Stochastic Texture Filtering

the paper presents an investigation into applying texture filtering after shading instead of before shading
shows comparisons of the approaches and a background into the underlying theory
presents guidelines on the tradeoffs and when to use different approaches

wayback-archive

Death To Shading Languages

the author presents his view on shading languages and the (lack of) evolution
discusses the shortcomings and issues arising from them
shows an outlook on why the concept of shading language is outdated and should be retired

wayback-archive

Real-Time Path Guiding Using Bounding Voxel Sampling

the paper introduces a path-guiding method that utilizes an irradiance voxel data structure
the presented method is a spatial distribution
shows an evaluation of static and dynamic scenes, containing quality and performance

wayback-archive

Area ReSTIR: Resampling for Real-Time Defocus and Antialiasing

the paper introduces Area ReSTIR that extends ReSTIR to be able to be applied to sub-pixel details
presents how to allow the reservoir to integrate with the area for the lens and film
shows the technique applied to depth of field and antialiasing

wayback-archive

Ray Tracing with Voxels in C++ Series – Part 4

the article continues the series that covers the implementation of a voxel raytracer
this week explains the concept of noise patterns and presents the effects using soft shadows
explains white noise, blue noise, and stratification
additionally, it shows how to temporally apply noise to allow temporal accumulation

wayback-archive

A Fully-correlated Anisotropic Micrograin BSDF Model

the paper presents an improved version of a BSDF developed for micro grain materials
shows how it explicitly models height-normal dependencies to summarize shadowing and masking inside the porous layer

wayback-archive

[video] Beyond White Noise for Real-Time Rendering

the video presents how different types of noise for random number generation can affect the results
discusses Randomness/fairness when generating random numbers
present how different noises affect stochastic rendering techniques and suggest solutions to common problems
discusses FAST noise generator utility and available pre-generated noise patterns

Shapes and forms of DX12 root signatures

the article provides an excellent overview of the different ways to create root signatures in D3D12
starts with a brief overview of what a root signature is and how it’s used
then discusses different methods to author, create, decompile, and use the concept
presents a brief discussion on how root signatures are used and how other engines handle it

wayback-archive

Recreating Nanite: Mesh shader time

the article discusses how to implement cluster-based mesh rendering using mesh shaders
discusses how to set mesh shaders using Vulkan
extends the pipeline to use task shaders to execute LOD selection and frustum culling
presents performance numbers and how wave utilization is essential

wayback-archive

N-BVH: Neural ray queries with bounding volume hierarchies

the paper introduces a new neural method to compress BVH for raytracing workloads
shows how the technique is designed to be integrated into existing raytracing pipelines
presents a comparison against existing solutions on memory and performance

wayback-archive

Thanks to Angel Ortiz for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 339 - May 12th, 2024

Sun, 12 May 2024 04:00:00 +0000

AMD GPU architecture programming documentation

AMD released documentation for the Micro engine and the RDNA 3 ISA

wayback-archive

Pre-condition block compressed textures with Brotli-G

the blog post presents that the Brotli-G (GPU compression library) now allows a pre-condition step that allows further file reduction
shows how to use the feature and what image formats are currently supported

wayback-archive

Ray Tracing with Voxels in C++ Series – Part 3

the article continues the development of a voxel raytracer by explaining anti-aliasing and soft shadows
presents the difference between numerical integration and stochastic integration solvers
shows the technique with anti-aliasing first and derives soft shadows as a follow-up

wayback-archive

Buffer Those Commands! // Vulkan For Beginners #8

the video tutorial explains the Vulkan command buffer concepts
presents limitations that OpenGL had and how Vulkan can solve these
shows the command buffer lifecycle, explains memory management
presents how to use the API to operate on command buffers

The shader graph contract

the article discusses the design trade-offs for a shader graph system
presents the complexity when integrating with modern complex shading systems
shows how Unreal and Unity implement the ideas

wayback-archive

ZH3: Quadratic Zonal Harmonics

the paper introduces the ZH3 format for spherical harmonics that fills the gap between linear and quadratic SHs
The proposed solution improves the quality at the cost of a single extra coefficient per channel
the source code is provided

wayback-archive

Apple’s Mysterious Fisheye Projection

the blog post discusses projection methods for spherical videos
presents issues with existing methods
reverse engineers what apples Methods appears to be doing and how it’s able to achieve higher quality

wayback-archive

Thanks to Keith O’Conor for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 338 - May 5th, 2024

Sun, 05 May 2024 04:00:00 +0000

[video] Math in Game Development Summit: A Visual Guide to Quaternions and Dual Quaternions

the GDC talk presents a great explanation of Quaternions and expands the concepts to cover dual quaternions
presents interactive and visual examples of the different components and operations involved
shows issues and limitations with matrix interpolations and how quaternions and dual quaternions can solve these limitations

Ray Tracing with Voxels in C++ Series – Part 2

this blog post covers how to extend a raytracer in a voxel world with support for reflections
expands perfect reflection to allow for refraction
contains challenges for the reader to develop their understanding further

wayback-archive

Meshed Radiance Manifolds for Efficient Volumetric Rendering of Dynamic Faces

the paper introduces a method for view synthesis of facial expression captures in 3D views not captured
the presented solution is running at real-time rates without relying on machine learning techniques
achieved using a layered mesh for view-dependent information and mixing this with view-independent RGBA texture video
the included paper presents a summary of the technique, compares it against existing solutions, and discusses the limitations of the approach

wayback-archive

[video] I3D 2024 Papers Preview

the video presents a summary of all the papers that will be presented at the I3D Conference 2024
shows a brief summary of a couple of seconds for each paper
papers cover an extensive range of topics, from ML techniques, VR research, upcoming display technologies, new filtering approaches, and much more

One Noise to Rule Them All: Learning a Unified Model of Spatially-Varying Noise Patterns

the paper discusses a generative model that is trained to generate multiple types of noise and blend between them
presents the network architecture, how it has been implemented and improved
shows many examples of the generated results

wayback-archive

Filter-Adapted Spatio-Temporal Sampling for Real-Time Rendering

the paper presents a framework to shape rendering noise to optimize samples for perceptual quality and denoising performance
shows how sampling patterns can be optimized to take advantage of knowledge about post-processing spatial and temporal filtering characteristics
demonstrates how to use the framework on example applications

wayback-archive

[video] Nanite for Artists | GDC 2024

the video shows the limitations of Nanite from an artist’s perspective
presents the debug views to explain why vegetation scenes are more difficult for the system to process
discusses possible solutions through the use of procedural generations and fallback LODs

Introducing Reverse Z (AKA I'm sorry for breaking your shader)

the Godot engine is switching the definition of near/far plane, with the near plane now mapping to a depth of 1 and the far plane to 0
this post explains common patterns that are affected by this change
additionally provides links to explain why this new mapping allowed significantly improved depth buffer precision

wayback-archive

Thanks to John Burton for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 337 - April 28th, 2024

Sun, 28 Apr 2024 04:00:00 +0000

Take a deep dive into Nanite GPU-driven materials

the presentation is packed with detailed information about the process of implementing shader graph support into the Nanite shading model
starts with an overview of the system and discusses the steps taken to reach the current support level
provides many details on the lower-level aspects and how GPU hardware influences decisions
additionally explains how the system has been optimized on PS5 and Series X with console-level access
also shows that work graphs for PC enable a new set of optimizations

wayback-archive

Real-time denoising of importance sampled direct lighting

The Master Thesis is a collaboration with Remedy Entertainment and discusses the implementation of a denoising solution for direct lighting
the focus is to find a solution that balances performance and quality to allow real-time utilization of consoles
reviews existing solutions and provides evaluation methods to provide analysis capabilities
discusses the implementation and tradeoffs done
presents performance, memory, and image comparisons of the developed solution against existing solutions

wayback-archive

Ray Tracing with Voxels in C++ Series – Part 1

the start of a series of articles covering the implementation of ray tracing for a voxel system
presents the initials of light and shadow calculations
concludes with challenges to the reader to improve their understanding of the material

wayback-archive

How to Compact Acceleration Structures in D3D12

the blog post shows how to implement Acceleration Structure compaction using D3D12
this compaction step is run on the GPU timeline and often reduces the memory size required by 40%
discusses the necessary API steps, GPU synchronization, and memory management strategies

wayback-archive

Demystifying multiple importance sampling

the article provides a full explanation of the derivation of multiple-importance sampling
explains the different components and how to combine them correctly

wayback-archive

GPU Compute in the Browser at the Speed of Native: WebGPU Marching Cubes

the article explains how to implement a marching cube compute shader
the implementation is shown both in Vulkan and WebGPU
compares the performance of both implementations and finds that WebGPU performance is close to native Vulkan

wayback-archive

The Performance Impact of C++'s final Keyword

a blog post covering the effect of using C++ final on a ray-tracing demo
the author presents the findings with several platforms, compilers, and scenes and presents the performance results

wayback-archive

Raytracing - Articles

this page serves as a starting point for the articles of the author
covering topics such as BVH building series, Probability Theory, CPU Optimization series
also contains various articles on Ray Tracing, graphics techniques, and fixed point math

wayback-archive

Radeon™ GPU Profiler 2.1 adds interoperability with Radeon™ GPU Analyzer (and more)!

the article introduces how shaders from GPU Profiler captures can now be opened in the GPU Analyzer for more detailed investigation
additionally shows UI updates and presents how instruction latency provides more information about where the latency occurs

wayback-archive

Alan Wake 2: A Deep Dive into Path Tracing Technology

the video presentation (free login required) discusses the implementation details of Path Tracing within the Alan Wake 2 technology stack
starts with an overview of the implementation used (vertex accessing, BVH creation, dealing with dynamic geometry, etc.)
shows how Opacity Micromaps are used for alpha-tested geometry
from there, explain how Path tracing has been implemented, covering the whole pipeline from shading, shadows, reflections, and reconstruction techniques

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 336 - April 21st, 2024

Sun, 21 Apr 2024 04:00:00 +0000

Transforming a Non-Differentiable Rasterizer into a Differentiable One with Stochastic Gradient Estimation

the paper presents a method that allows existing non-differentiable rasterizers to be made differentiable
explains the underlying technique and how to derive per-pixel stochastic gradient estimation
shows how to use the concepts to implement a 3D assets optimization system

VNDF importance sampling for an isotropic Smith-GGX distribution

the article introduces a specialization for the isotropic distribution of visible normals for GGX-Smith
discusses the limitations and implementation
source-code for HLSL and GLSL is provided

wayback-archive

Colour Science Precis for the CGI Artist

a collection of summaries about color science aimed at computer graphics artists
provides a summary of the physics of color, the human vision, as well as the representation in computer graphics
additionally discusses color transformation onto displays

wayback-archive

Real-time Seamless Object Space Shading

the paper introduces an object space shading method based on per-half-edge texturing (Htex)
presents a comparison against existing and shows how a Htex based method helps to reduce texturing seams
implementation of ReSTIR GI in object space using Unity is provided

wayback-archive

[video] Terrain Tessellation Shaders // Terrain Rendering Episode 13

the video explains how to use OpenGL tessellation shaders to implement a dynamic level of detail for mesh based terrain system
explains how to setup the data for usage with the shaders
presents the shader and C++ code implementation required

[video] An Optimisation 6 Years In The Making

the video presents techniques to represent light shafts
explains an overview of two existing approaches
present an approximation technique that uses 2D planes combined with shadow map sampling and temporal filtering

Thanks to Joakim Dahl for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 335 - April 14th, 2024

Sun, 14 Apr 2024 04:00:00 +0000

GM Shaders Guest: Radiance Cascades

the blog post explains the Radiance Cascades technique for global illumination
shows the different stages of the algorithms and how to implement them for 2D cases
source code is provided

wayback-archive

Flattening Bézier Curves and Arcs

the post presents three methods to convert (Quadratic, Cubic) Bézier curves and elliptical arcs into line segments
provides interactive examples to visualize the methods
An example javascript code is provided

wayback-archive

3D Toon Rendering in 'Hi-Fi RUSH'

the GDC presentation provides an in-depth view into how the visual stylized shading was implemented
covers a large number of topics from Deferred Toon Rendering, Comic Shader, over Global Illumination to Toon Face Shadows and more
the game is based on Unreal Engine 4

wayback-archive

DirectX State of the Union Ft. Work Graphs and Introducing DirectSR (Presented by Microsoft)

the GDC 2024 presentation covers the problems with Draw Indirect and how Work Graphs are designed to solve them
presents a walkthrough of the API and how AMD/NVidia have started to use the feature
additionally introduces DirectSR, the new API that abstracts upscaling techniques behind a command D3D API

wayback-archive

[video] Coding Adventure: Rendering Text

the video deep dives into font rendering
starts by exploring the True Type Font format
showing how to extract the glyphs and the bezier curves that represent them
discusses several techniques to render the curves to form the fonts
presents issues and solutions for a large number of issues encountered

Graphics Programming Conference

a new graphics programming conference to happen in Breda (Netherlands) in November
currently looking for speaker and master class proposals

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 334 - April 7th, 2024

Sun, 07 Apr 2024 04:00:00 +0000

Recreating Nanite: Runtime LOD selection

the blog post discusses how to implement a continuous LOD system for meshlet-based rendering
shows how to calculate the error metric and structure the data for GPU access
presents how to select the correct LOD level at runtime
A video of the results is included

wayback-archive

Optimizing UE5: Rethinking Performance Paradigms for High-Quality Visuals - Part 1: Nanite and Lumen | Unreal Fest 2023

the presentation provides an overview of the Nanite and Lumen systems
shows a high-level look at which parts affect performance and how performance intuition doesn’t match the classical rasterization model
the whole presentation slide deck is done in the UE5 editor

wayback-archive

[video] Dithered Transparency in Unity Shader Graph

the video explains the difference between alpha blending and dithered transparency
shows sorting issues related to blending order and how dithered transparency solves them
presents how to implement the technique using Unity Shader Graph
additionally shows the limitations of the technique

RenderDoc - Version v1.32

the latest version adds support for Slang with Vulkan, additional extensions support, D3D12 Pixel history support, and many bug fixes

wayback-archive

Copy Queue woes.

the article presents how usage patterns of copy queues to upload and download data from the GPU can significantly affect the amount of stalls
discusses the different patterns and presents timelines to show the waits
additionally shows how multiple copy queues interact and the importance of copy queue priorities

wayback-archive

Real-Time Lighting with Gaussian Splats

the blog post describes a method to apply lighting to Gaussian Splats
shows methods to reconstruct geometry with normals and how to filter the results
additionally discusses limitations and ideas for improvement or leveraging of existing mesh-based solutions

wayback-archive

[video] DJ! Swap that chain!!! // Vulkan For Beginners #7

the latest video in the series explains how to create a Vulkan Swapchain
explains the different presentation modes
additionally shows how to create a view of the different images of the swap chain

Thanks to Unai Landa for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 333 - March 31st, 2024

Sun, 31 Mar 2024 04:00:00 +0000

Game optimization with the AMD radeon developer tool suite

the GDC presentation provides an overview of the profiler tools available from AMD
presents the updated shader analysis tool, including a preview of the single shader stage mode
additionally presents an overview of the raytracing and memory debugging tool improvements

wayback-archive

Moebius-style post-processing and other stylized shaders

the article presents a walkthrough of how to implement a post-processing effect that emulates Jean Giraud’s art style
shows how the author approached object outlines, shadows, and lighting patterns
provides interactive WebGL implementations that showcase the individual stages of the implementation

wayback-archive

Open sourcing the WinPixEventRuntime under MIT

the blog post announces that the Windows PIX runtime has been released as OpenSource
this includes logic to decode PIX events as well as the runtime logic that writes ETW entries
additionally, the team is looking for feedback for a proposed task API for PIX

wayback-archive

Sampling the disk from a square: The adoption method

the article introduces an alternative low discrepancy sampling strategy for circles
provides a quick introduction to rejection sampling
shows how adaption could be used to sample only within a quad within the disk and still fill the whole circle with samples
compares the characteristics of the technique and presents the applications to different shapes

wayback-archive

Efficient CUDA Debugging: Using NVIDIA Compute Sanitizer with NVIDIA Tools Extension and Creating Custom Tools

the blog post describes how to use the CUDA Compute Sanitizer to implement a resize-aware memory pool
additionally discusses the APIs available to allow memory debugging more insightful

wayback-archive

[video] GDC 2024 - Shader Instrumentation with GPU Reshape

the GDC presentation discusses how the GPU Reshape tool enables GPU timeline validation
explains how the validation logic can be written in an API-agnostic manner
provides a look at future developments where the same infrastructure could be used for profiling or data debugging

Ray Marching: Menger Sponge Breakdown

the article provides an introduction to ray marching
explains the underlying concept and how it compares to ray-tracing
extends the concepts to introduce the various operations (scaling, translations, boolean operations) required to express geometry
combines the knowledge to build a fractal object called the Menger Sponge

wayback-archive

Thanks to Jhon Adams for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 332 - March 24th, 2024

Sun, 24 Mar 2024 04:00:00 +0000

Mesh shaders in AMD RDNA 3 architecture

the presentation discusses mesh shaders and the techniques they enable
discusses how to compress index data and how to allow quad source data
presents the importance of vertex reuse and meshlet generation for performance

wayback-archive

[pdf] Post-mortem GPU crash analysis with AMD radeon GPU detective (RGD)

the presentation presents why debugging GPU issues is difficult
explains how the AMD Radeon GPU detective presents information to help developers track issues down
presents how to use the tool, read the information, and understand the cause of the issue with the information provided

wayback-archive

Upgrade Your Graphics: Explore New Ray Tracing Features for NVIDIA Nsight Tools

the article discusses updates in the Nvidia developer tools
covers new debugging capabilities, improved performance collection, and profiling tools

wayback-archive

Procedural grass rendering

the blog post describes how to implement a procedural grass system using mesh shaders
explains how the grass mesh is described using bezier curves and combined into a grass patch
presents how to write the index/vertex buffers for efficient rasterization

wayback-archive

GI-1.1 adds support for glossy reflection rendering

the blog post provides a brief overview of how glossy reflection got added to the GI 1.1 release
looks at how the denoiser is required to reduce the inherent noise images

wayback-archive

GDC 2024: We reveal incredible Work Graphs performance, AMD FSR 3.1, GI with Brixelizer, and so much more

the article provides an overview of the announcements AMD made during GDC
additionally provides links to the slides and videos of the presentations

wayback-archive

Adventures with Differentiable Mesh Rendering

the article explains how to approach differentiable rendering for mesh-based rasterization
presents the limitations of a simple method and how to achieve it with PyTorch
expands the idea to expand the idea with soft probability to solve some of the limitations

wayback-archive

Graphics Programming – Where To Start?

the article provides a suggested collection of resources for beginners in graphics programming
covers mathematics, working with APIs, and writing shaders

wayback-archive

[video] It is illogical (device) // Vulkan For Beginners #6

the video provides a brief overview of the difference between physical and logical Vulkan device
presents the C++ code necessary to implement the device creation

Thanks to Stephen Hill for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 331 - March 17th, 2024

Sun, 17 Mar 2024 04:00:00 +0000

[video] Too Many Developers Ignore These Optimisations

the video provides a walkthrough of the steps when optimizing a voxel renderer
each step is explained and visualized to make it very easy to understand
covers a large number of optimizations and, for each, discusses the effect on performance and memory usage

Unlock Seamless Material Interchange for Virtual Worlds with OpenUSD, MaterialX, and OpenPBR

the article provides an overview of the different models available to describe the appearance of a mesh using OpenUSD
Explain the advantages and the disadvantages of the available methods

Agility SDK 1.613.0 Available Now, Including Support for GDC 2024 Showcase Features

the article provides an overview of all new features available in the D3D12 Agility SDK update
covers work graphs, new shader model, accessible memory for CPU/GPU, as well as unifications on shader creation

wayback-archive

D3D12 Work Graphs

an overview from Microsft into what work graphs are
what possibility it enables, a brief summary of the spec
additionally points out the changes since the preview version last year

wayback-archive

Work Graphs in Direct3D 12: A Case Study of Deferred Shading

the article provides an overview of how a G-Buffer classification system for BRDF selection can be authored using work graphs
provides performance numbers for the work graph and an Uber shader approach
discusses lessons learned, pitfalls, and performance considerations
It additionally discusses the open challenges and future developments

wayback-archive

GDC 2024: Work graphs, mesh shaders, FidelityFX™, dev tools, CPU optimization, and more.

AMD provides a list of talks they will be presenting at GDC (starting today)
each talk is given a small summary and where it’s taking place

wayback-archive

Font- and vector-art rendering with mesh shaders

the article provides a detailed walkthrough of how to implement Loop’s and Blinn’s font rendering approach from Siggraph 2005
provides an overview of the approach with many visualizations
shows how to implement the algorithm using D3D12 mesh shaders
source code is provided

wayback-archive

Random walk method for quaternions

the blog post discusses a method for generating uniformly distributed quaternions
explains the theory of quaternion and the proposed method to generate random rotations
provides an implementation without using trigonometric in C++ SIMD as well as GLSL

wayback-archive

Cross-Stage Shader Optimization

the whitepaper presents which tools and optimizations passes in spirv-cross and glslang are available to optimize shaders, taking advantage of knowledge from multiple shader stages
shows an example of how vertex outputs can be eliminated if the connected pixel shader doesn’t read the attribute

wayback-archive

Recreating Nanite: LOD generation - faster, better, simpler

second part in an article series about creating a LODing system that allows per-cluster LOD selection
focuses on performance and quality fixes for the proposed solution from part 1

wayback-archive

[video] 3D Gaussian Splatting! - Computerphile

the video provides an explanation of Gaussian Splatting and how it connects to point clouds and nerfs
presents the base idea and optimizations that have been applied to speed up the technique

PIX 2403.08 – New D3D12 features + misc PIX improvements

the blog post provides an overview of new features and improvements in PIX
additionally presents at which state of support the new D3D12 features, such as shader graph, shader model 6.8, etc.

wayback-archive

Thanks to Erika for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 330 - March 10th, 2024

Sun, 10 Mar 2024 04:00:00 +0000

About fast 2D CDF construction

the article presents a method for efficiently calculating the Cumulative Distribution Function or CDF, for image-based lighting
explains the underlying prefix sum algorithms
shows how to improve the initial implementation for improved GPU performance
the implementation is provided using CUDA

wayback-archive

Solar Storm Rendering

the article provides a brief overview of the rendering engine architecture of the indie game Solar Storm
presents how the systems are designed around immediate mode principles
shows how the world is built up, shaders are created, and objects submitted for rendering
additionally presents a quick look at post-processing and performance

wayback-archive

Vulkan Foliage rendering using GPU Instancing

the blog post provides a walkthrough of the author’s implementation of grass rendering using compute shaders + indirect draw
shows how the instances are generated, animated, and culled, as well as how LODs have been added
code samples are presented using Vulkan

wayback-archive

Screen Space Reflection

the article presents how to implement screen space reflections using a single shader pass
starts from a basic technique description and presents how to resolve common issues
each step and improvements are visually represented
the source code for a Unity shader is provided

wayback-archive

The Smooth-Minimum operator or Smooth-Union

the article provides an in-depth look at the Smooth-Minimum operator and its characteristics
shows that many varieties exist, and they all have different strengths and weaknesses
presents examples of all and discusses when to use the different variations

wayback-archive

Inside Snapdragon 8+ Gen 1’s iGPU: Adreno Gets Big

the article provides an in-depth look at the hardware details of the Snapdragon 8+ Gen 1 GPUs
shows the hardware design, compute throughput, performance, cache performance, and much more

wayback-archive

[video] Let's Get Physical (Device) // Vulkan For Beginners #5

the video tutorial explains the concepts related to GPU hardware detection
shows how to enumerate connected GPUs, what capabilities they support, and how to pick the hardware that matches the application requirements

Thanks to Cort Stratton for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 329 - March 3rd, 2024

Sun, 03 Mar 2024 04:00:00 +0000

Ray-Tracing Validation at the Driver Level

the article presents a new driver-level validation for Ray-Tracing implemented by Nvidia
discusses what kind of issues can be detected by the system and how they are reported to the developer
presents how to enable the system and expected performance overhead

wayback-archive

[video] How Persona Combines 2D and 3D Art

presents a complete walkthrough of the forward rendering model employed by Persona 3 Reload
discusses how different effects are combined to create the stylized rendering effects
provides an overview of shading, shadowing, and ray-tracing integrations
presents how art-driven effects are integrated to improve the visual appearance
additionally, it presents how the UI system is integrated

How video games use LUTs and how you can too

the article explains the concept of Look Up Textures (LUT)
shows different use cases with interactive examples
discusses 1D and 3D Lookup textures
covering examples from Left 4 Dead of how LUTs are used and the possibilities they enable

wayback-archive

Look, Ma, No Matrices!

the article discusses the feasibility of replacing 4X4 Matrix multiplications with Geometric Algebra concepts in a forward renderer
presents the implementation of the required concepts and how to replace classical methods
discusses conversion limitations when using normal maps
additionally, it discusses the amount of instruction required for different operations

wayback-archive

DirectX Innovation on Display at GDC 2024

Microsoft presents what will be discussed at GDC 2024
Introducing DirectSR (Super Resolution), a new API for the uniform integration of different super-resolution solutions with the same API
will be presenting an update on Work graphs and how they will affect GPU programming in the future

wayback-archive

How (Not) To Optimize Shaders

the article presents the importance of profiling when optimizing
shows a comparison between precomputed sample positions (with a buffer load) and on-the-fly computations

wayback-archive

Creating a Surface Handle // Vulkan For Beginners #4

the short video tutorial explains how to create and destroy a surface handle from a GLTF window

Thanks to atyuwen for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 328 - February 25th, 2024

Sun, 25 Feb 2024 04:00:00 +0000

On Light, Colors, Mixing Paints, and Numerical Optimization.

the article provides an in-depth discussion of how light behaves, how it interacts with the human visual system, and finally, how paints are made up
given the theoretical underlying presents a model to derive a model to represent the mixing of colors
discusses how to implement the solver
The Python source code is released as open-source

wayback-archive

Vulkanised 2024 Playlist released

the video recordings of the talks from the Vulkanised 2024 conference have been released
covering efficient rendering for mobile, Vulkan synchronization, shader language innovation, practical porting lessons, and much more

Shadeup Crash Course

the article introduces the Shadeup language that aims to minimize boilerplate code required when authoring WebGPU workloads
provides a quick introduction to the various features of the system and how to interact between CPU and GPU code
covers basic rasterization as well as compute shader usage
code examples are interactively editable for experimentation

wayback-archive

[video] Creating a Debug Callback Function // Vulkan For Beginners #3

the video tutorial explains the necessary steps to ensure that all Vulkan validation messages will be intercepted
shows the C++ code implementation required and how to use the debugger to collect additional information when an error occurs

[video] Underwater Caustics Part 2 - Advanced Materials - Episode 42

the second part of a video tutorial about the implementation of Caustics using Unreal and Unity
The first part explained how to implement an underwater caustic effect
this part shows visual issues (noise, edges) from the previous part and shows how to solve them

Graphite internships: announcing participation in GSoC 2024

the Rust-based 2D editor Graphite is looking for Students to join the Google Summer of Code project
one of the suggested project ideas is to rewrite the Shader-driven graph UI for improved performance

Thanks to Keith O’Conor for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 327 - February 18th, 2024

Sun, 18 Feb 2024 04:00:00 +0000

Collaborative Control for Geometry-Conditioned PBR Image Generation

The paper introduces a machine learning model that generates a set of PBR Textures (albedo, Roughness, Metallic)
trained on a locked RGB model to take advantage of existing models
discusses how the model was designed, tradeoffs, and common failure cases

wayback-archive

GPU synchronization in Godot 4.3 is getting a major upgrade

the article discusses the new RenderGraph implementation in Godot 4.3
discusses the limitations of the old system and the advantages of the new system
shows the implementation of dependency tracking, dealing with sub-resources
additionally discusses CPU and GPU performance impact

wayback-archive

GM Shaders: Blur Philosophy

the blog post article discusses the implementation of a box blur shader
presents explanation of Gaussian, Kernels, Separable blurs
closes with a discussion of things to do and avoid when implementing a blur shader for good results

wayback-archive

REAC 2024 Conference - Call for Submissions!

the Rendering Engine Architecture Conference is looking for speakers for the 2024 edition
post describes what kind of talks are being looked for and the formats of the talks

wayback-archive

GPU Programming Primitives for Computer Graphics (course)

the course presents an introduction to GPU compute shader algorithms
discusses the primitives available
how to implement parallel reduction, prefix scan, and radix sort
additionally presents a look at optimization techniques

wayback-archive

[video] Tech Focus: TAA - Blessing Or Curse? Temporal Anti-Aliasing Deep Dive

the video provides a history of ant-aliasing techniques used in games
discusses capabilities and limitations of the different AA techniques
presents in-depth the advantages and disadvantages of temporal antialiasing techniques
all examples are presented with videos from games that use the presented techniques

Gradient Descent With Adam in Plain C++

the article explains the extension method to gradient descents called Adam
provided implementation is shown in C++

wayback-archive

Thanks to Angel Ortiz for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 326 - February 11th, 2024

Sun, 11 Feb 2024 04:00:00 +0000

Vulkanised 2024

The slides for the talks of the 2024 Edition of the Vulkanised conference have been released
3-day conference covering Vulkan SDK changes, synchronization, common learning mistakes, presentations of integration into larger systems, shading language developments, as well as future looking developments

wayback-archive

[video] Creating an Instance // Vulkan for Beginners #2

the video in a series of Vulkan tutorials explains how to create a Vulkan Instance
explains the API concepts required to understand
code samples are provided

[video] Water Foam - Advanced Materials - Episode 40

the video tutorial explains how to add surface foam around the edges of objects that intersect the water surface
shows how to implement the foam effect and how to limit the effect to the area around the intersection
implementation is shown using both Unreal and Unity using a visual shading system

Jobs

Unreal Developer (m/w/d)
Darmstadt

We are Threedy, a dynamic startup that emerged as a spin-off from the Fraunhofer Institute for Computer Graphics Research IGD in Darmstadt in 2020.

Threedy develops and distributes instant3Dhub - the first Visual Computing as a Service technology. It enables the productive use of Mixed Reality and digital work scenarios in any industrial applications in a simple and straightforward manner.

As an Unreal Developer, you will be involved in the development of our distributed rendering system and work on integrating our technology with the Unreal Engine.

Would you like to advertise your job openings here too? More information

Building the DirectX shader compiler better than Microsoft?

the article presents the authors’ work on allowing the DXC compiler to be built into a static library for Linux, MacOS, and Windows
additionally presents how to remove it’s possible to replace the dependency on DXIL.dll for shader signing

wayback-archive

Toward a next-gen vulkan shading language: our journey with slang

the presentation shows an overview of the Slang shading language
presents how it fits into the ecosystem, what features are supported, and what additional capabilities it brings to shader authors
shows how the integrated automatic differentiation can be used for different use cases

wayback-archive

[video] Explaining my game engine in 2023 - Part3: Tile-based light culling, compute shaders, RenderDoc

the video explains Forward+ shading techniques
shows how to express frustum culling, how compute shader allows the workload to be expressed
additionally presents how to use RenderDoc to visualize the involved data

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 325 - February 4th, 2024

Sun, 04 Feb 2024 04:00:00 +0000

TRIPS: Trilinear Point Splatting for Real-Time Radiance Field Rendering

the paper presents a novel approach to the Point Splatting rendering technique
the presented approach uses multi-layered feature maps that are processed with a neural network to generate the final output

wayback-archive

Breakdown: Syndicate (2012)

the blog post presents a frame investigating into a frame of the game syndicate from 2012
shows the different rendering passes and provides an overview of the techniques used in each pass

wayback-archive

[video] I made a Compression Algorithm for Heightmap Terrain

the video explains a compression technique developed for height field compression
covering quantization, quadtree, delta encoding, as well as linear regression
source code as a Godot implementation is provided

The Apparent Simplicity of RGB Rendering

the blog post describes the observer correlation and coupling that is introduced into computer graphics through the use of RGB rendering
explains physical definitions of terms and how the rendering definitions introduce these inherent limitations compared to spectral definitions

wayback-archive

Jobs

Unreal Developer (m/w/d)
Darmstadt

We are Threedy, a dynamic startup that emerged as a spin-off from the Fraunhofer Institute for Computer Graphics Research IGD in Darmstadt in 2020.

As an Unreal Developer, you will be involved in the development of our distributed rendering system and work on integrating our technology with the Unreal Engine.

Would you like to advertise your job openings here too? More information

Examining AMD’s RDNA 4 Changes in LLVM

the blogpost discusses the changes AMD made to LLVM
these changes might indicate hardware changes coming for the upcoming RDNA4 generation

wayback-archive

[video] Vulkan For Beginners Tutorial #1

the video introduces a new Vulkan tutorial
the video focuses on the introduction of the audience, software/hardware requirements
shows how to set up Vulkan and create a window

Introducing HIP RT v2.2

the article presents updates in HIP (Heterogeneous-compute Interface for Portability) Raytracing implementation
presents how multi-level instancing allows reduction of memory usage
additionally discusses BVH construction speed improvements

wayback-archive

[video] When Optimisations Work, But for the Wrong Reasons

the video provides an in-depth explanation of why LOD (Level of Detail) for 3D models helps to improve rendering performance
shows how the hardware pipeline is organized, what data GPUs are optimized, and how different workloads cause different bottlenecks
explains all stages of the pipeline involved and provides additional reading sources

An Introduction To BCn Texture Compression, Part 1: BC4

the article presents the start into a series of explaining BC (DDS, Block Compression) formats
this part shows how to build a working BC4 compressor
explains each step and discusses the limitations of the presented techniques

wayback-archive

Thanks to Marius Horga for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 324 - January 28th, 2024

Sun, 28 Jan 2024 04:00:00 +0000

Streamlining Subpasses

the new Vulkan extension allows developers to express local dependencies between sub-passes so that drivers can stay on-chip memory for tiled hardware
blog post explains the extensions, how to post existing applications to use the new extension

wayback-archive

Khronos Releases Maximal Reconvergence and Quad Control Extensions for Vulkan and SPIR-V

Khronos released two new SPIR-V extensions
the first extension guarantees reconvergence behavior to require the behavior many programmers’ intuition assumed to work
additionally, a new extension allows correct divergence handling within a quad
the blog post explains the previous issues and how the extension solves them

wayback-archive

Portals are misunderstood

the blog post describes the history of Portals and BSP trees
expands the ideas to more modern concepts and suggests the applicability of GPU based solutions

wayback-archive

Don't Use Moving Averages

the article presents issues with moving averages and suggests using binomial averages instead
shows data examples to highlight the issues and explain in frequency domain why they happen

wayback-archive

Profiling WebGPU with PIX

the article shows how PIX can be used to debug WebGPU applications
shows what is required to attach PIX, get debug-marker output, as well as frequent issues

wayback-archive

Efficient GPU Rendering for Dynamic Instances in Game Development

the author discusses a method to use indirect drawing to draw a dynamic number of instances of each type on the GPU
The article provides an overview of the implementation (with code examples)
additionally provides a couple of optimizations and future development steps

wayback-archive

Shining a light on Caustics with Shaders and React Three Fiber

the blog post provides a detailed walkthrough of the implementation of a caustics effect using WebGL
shows the different elements the effect is made up of and how to simulate the different phenomena
intermediate samples are presented as interactive WebGL examples

wayback-archive

Thanks to Giuseppe Modarelli for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 323 - January 21st, 2024

Sun, 21 Jan 2024 04:00:00 +0000

Mesh shaders: optimization and best practices

the article presents an overview of mesh shaders and amplification shaders
shows the considerations and constraints on RDNA2/3 hardware
showcases the tools available to profile the different stages and identify bottlenecks

wayback-archive

Modernizing Granite’s mesh rendering

the article presents a detailed look at implementing a mesh shader based rendering pipeline
each step is accompanied by performance numbers on Nvidia and AMD
shader code samples are provided

wayback-archive

Reprojection in a Ray Tracer

the author presents an alternative method to calculate the previous frame screen space position given a world space position
this technique doesn’t rely on projection matrices

wayback-archive

Introducing GPU Reshape - shader instrumentation for everyone

the blog post introduces a new GPU-based debugging tool to make finding shader issues easier
allows the detection of out-of-bounds access, resource-bound validation, NAN detection, concurrency validation, and more
works with Vulkan and D3D12 on both AMD and Nvidia GPUs

wayback-archive

[video] Machine Learning for Game Developers

the video provides an overview and introduction to machine learning from a game development perspective
explaining the standard terms, intuition, building an example network, and finally running the example network using D3D12
the example code is provided

Creating Rhoxel Meshes From Integer Coordinates

the article presents a method to construct rhombic dodecahedral honeycomb elements from an integer grid
shows an example of an SDF represented using the method
presents how to generate the mesh surfaces
additionally presents some ideas on what the method might be used for

wayback-archive

HLSL Constant Buffer Packing Rules

the article explains the packing rules for Constant buffers when used with D3D11/D3D12
provides examples of different structures
shows visually how the different members are packed into memory

wayback-archive

GPU Sorting - Overview

the article provides an overview of GPU sorting algorithms
provides high-level comparisons between the techniques
links to papers and implementations of the techniques are provided

wayback-archive

Thanks to atyuwen for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 322 - January 14th, 2024

Sun, 14 Jan 2024 04:00:00 +0000

Shader Printf in HLSL and DX12

the article discusses how to implement a printf statement that can be used from a shader
presents a workaround that allows HLSL 2021 to convert strings into a char array for writing into a buffer
code examples are presented with HLSL and D3D12

wayback-archive

GM Shaders: Noise 3

the article presents a walkthrough on the steps required to generate simplex noise
shows a comparison between texture and function-based noise generation
additionally presents steps required to ensure that noise is tileable

wayback-archive

Hash Noise stability in GPU Shaders

the article discusses the portability of different methods to calculate noises/hashes across GPUs
comparing methods to calculate, float, int, and functions as well as sampling differences

wayback-archive

Jobs

Unreal Developer (m/w/d)
Darmstadt

We are Threedy, a dynamic startup that emerged as a spin-off from the Fraunhofer Institute for Computer Graphics Research IGD in Darmstadt in 2020.

As an Unreal Developer, you will be involved in the development of our distributed rendering system and work on integrating our technology with the Unreal Engine.

Would you like to advertise your job openings here too? More information

[video] How does Quad Tessellation work in OpenGL?

the video provides an overview of different tessellation modes
visually explains where the tessellation is applied and how different modes subdivide differently
code examples are provided with OpenGL

[video] Vertex Animated Water - Advanced Materials - Episode 36

the video tutorial shows how to create a water surface through the use of vertex displacement
the effect is implemented using a visual shader editor using Unity and Unreal

Around The World, Part 11: Everything is harder on a sphere

the article discusses the complexities of using operations on the surface of a sphere
presents issues of different encodings and extra difficulties with operations such as rotations, precision, distortions, etc.

wayback-archive

Thanks to Dominik Lazarek for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 321 - January 7th, 2024

Sun, 07 Jan 2024 04:00:00 +0000

Quaternion Weighted Average

the article presents how to accurately calculate the average of a set of quaternions
shows issues with a common method, why these errors happen, and how to improve it
visually shows the improved method

wayback-archive

Siggraph 2023 Courses - Videos released

ACM has released the video recording for the SIGGRAPH 2023 courses
a large number of topics such as USD, WebGPU, Vulkan raytracing, and many more

wayback-archive

A Gentle Introduction to ReSTIR Path Reuse in Real-Time

ACM released the video recording of the Siggraph course on the introduction to ReSTIR
the full ~3h30 video is available for streaming & download
covering from the basics to practical integration into Cyberpunk

wayback-archive

Jobs

Senior WebGL Graphics Engineer
Remote

Phaser Studio is looking for a focused, collaborative, professional graphics engineer to help craft the 2D rendering engine for the current and next generation of the Phaser game framework.

You’ll be a bright, energetic, and talented individual who shares our love of video games and our passion for empowering game developers to make the most of the web as a gaming platform.

Would you like to advertise your job openings here too? More information

[video] Inside Alan Wake 2: How Remedy Delivered A Visual Masterpiece

the Digitial Foundry interview with a Technical Director and Lead Graphics Programmer from the Alan Wake 2 team
discusses engine changes, mesh shader usage, ray tracing design, memory optimizations, etc.
the full interview is ~50 minutes long

[video] Vertex Displacement - Advanced Materials - Episode 35

the video tutorial presents several use cases that vertex offset enables
shows how to implement the techniques in Unity and Unreal Engine

[video] This Is Ray Tracing Supercharged!

the article presents an overview of recent advances in light transport and compute graphics algorithms
shows noise reduction techniques, screen space-based GI techniques as well as displacement mapping with continuous LODs

Jobs

Unreal Developer (m/w/d)
Darmstadt

Wir sind Threedy, ein dynamisches Startup, das als Ausgründung vom Fraunhofer-Institut für Graphische Datenverarbeitung IGD in Darmstadt im Jahr 2020 entstanden.

Threedy entwickelt und vertreibt instant3Dhub - die erste Visual-Computing-as-a-Service-Technologie. Sie ermöglicht den produktiven Einsatz von Mixed Reality und digitalen Arbeitsszenarien in beliebigen Industrieanwendungen auf einfache und unkomplizierte Weise.

Als Unreal Developer wirst du an der Entwicklung unseres verteilten Rendering-Systems teilhaben und an der Integration unserer Technologie mit der Unreal Engine arbeiten.

Would you like to advertise your job openings here too? More information

DiffusionLight: Light Probes for Free by Painting a Chrome Ball

the paper presents a method to estimate HDR EnvironmentMap (Chrome Ball) from a single input image
shows how the LDR diffusion model was trained, what insights enable better estimation as well as how to generate HDR sphere
source code and example implementation are available

wayback-archive

Thanks to Adalberto Bruno for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 320 - December 31st, 2023

Sun, 31 Dec 2023 04:00:00 +0000

Low-level thinking in high-level shading languages 2023

the article presents how different shader constructs are converted into instruction on RDNA2
shows the impact on code generation that small changes can have
what can be optimized by today’s compilers and what cannot be optimized

wayback-archive

3D shape matching with quaternions

the article discusses a technique that calculates the transformation required between a known base and target position
applies this technique to a 3D cloth simulation to calculate the shading tangent and normals

wayback-archive

Creating a Directed Acyclic Graph from a Mesh

the article discusses how to generate LODs using a meshlet-based Directed Acyclic Graph approach
talks about the data structure, the approach, and implementation details of the model
mentions considerations for choosing meshlet sizes as well as LOD selection using the graph

wayback-archive

[video] How do Video Game Graphics Work?

the video provides a great visual breakdown of the rendering pipeline
covers how scenes are represented, how the source triangles are transformed, rasterized, and shaded to finally appear on screen
additionally provides a small overview of more recent techniques such as ray-tracing and DLSS

Beyond SAH — Building Optimal BVHs

the article provides an overview of different heuristics to choose from when building a BVH for raytracing
compares the ray tracing performance of the heuristics in a test scene
additionally provides ideas for future research in the area

wayback-archive

Dynamic diffuse global illumination

the article provides a walkthrough of the practical tweaks and tricks used to implement a ReStir-based global illumination system into a research framework
discusses the caching strategies, light leaking improvements, and performance optimizations

wayback-archive

Denoising raytraced images using OIDN

the article provides insights into how to convert OpenImageDenoise into HLSL compute shaders
shows a high-level overview of the technique
presents a couple of steps to reduce the performance cost

wayback-archive

Thanks to Giuseppe Modarelli for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 319 - December 24th, 2023

Sun, 24 Dec 2023 04:00:00 +0000

Mesh Shaders on RDNA™ Graphics Cards

the blog post is the beginning of a series covering mesh shaders and how they map to the RDNA hardware
explains the classical pipeline and how the mesh shading pipeline differs
presents which AMD hardware stages are used to implement the stages
additional presents how amplification shaders can be used to represent dynamic workloads

wayback-archive

Occupancy explained

the article provides an in-depth look at understanding shader occupancy on RDNA hardware
shows what occupancy is, what factors could limit it, and how to observe the actual occupancy
presents how to improve occupancy
additionally, it presents pointers to detect cases when more occupancy might not be beneficial

wayback-archive

Optimizing Shaders in Unreal Engine

the article presents techniques to help identify the performance cost of shaders created from unreal shader graphs
shows how to see the generated instructions
additionally, it presents a couple of examples to optimize the generated shaders

wayback-archive

Interpolation Using Wave Intrinsics

the article presents a shader function that uses wave intrinsic to calculate interpolation of the result of lane-dependent calculations across lanes
shows step-by-step how the shader is structured
additionally presents how to take advantage of SPIR-V inline to further improve the generated code

wayback-archive

An update to our Render Graph

the article provides an overview of the implementation of a render graph implementation
presents how the implementation uses versioned resources to structure the order of render passes
shows how the execution order of the render graph is established
additionally, it discusses how unused render passes are removed

wayback-archive

Vulkan Video Decode: First Frames

the blog discusses the implementation of Vulkan video decoding to get the first frame of a video
shows the steps necessary, from loading a file to unpacking the mp4 to actually decoding a first frame
discusses pitfalls encountered along the way
additionally, it presents a collection of other resources used to get to the stage

wayback-archive

Surface Gradient Bump Mapping Framework Overview

the paper presents a retelling of the Surface Gradient Bump Mapping Framework paper from the author’s perspective
shows what normal maps are, how they encode information, and what the difference between object and tangent space is
discusses issues with blending normals from different sources and how the alternative representation can achieve better-blending results

wayback-archive

Ray tracing animated crowds

the blog post discusses how GPU-based animation for large crowds is implemented
presents how the animations are structured, driven on the GPU, and acceleration structures for ray-tracing are generated
additionally presents how skeleton instancing can be used to reduce animation costs while still allowing object variations

wayback-archive

[video] Digital Foundry's Best Game Graphics of 2023 - PC, PS5, Xbox, Switch - Another Amazing Year

year-end video that discusses the standout graphical games of the year
presents demonstrations of the effects of the game-nominated
shows the top 3 picks for best-looking games of the year and presents the reasoning for the choices

Thanks to Lesley Lai for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 318 - December 17th, 2023

Sun, 17 Dec 2023 04:00:00 +0000

A gentler introduction to ReSTIR

the blog post aims to introduce and explain the ReSTIR technique with a focus on implementation and intuition instead of the underlying theory
shows how to start with a first implementation and expand it to implement shadows
additionally shows how to take advantage of temporal and spatial data to reduce noise

wayback-archive

Knockout City Frame Breakdown

the article presents a breakdown of the primary render passes of the Knockout City frame
provides a high-level overview of the rendering techniques used, what existing techniques they are based on, and how they modified the techniques to fit the requirements of the game

wayback-archive

Advanced API Performance: Swap Chains

the blog post collects advice on how to achieve the most stable presentation results when using DXGI
presents what flags to set, how to size the queues, and how to make sure the results stay consistent after window/resolution resizes

wayback-archive

AMD FSR3

the blog post presents an overview of the FSR3 SDK improvements
shows the debug display modes to help during implementation
additionally shows how it’s possible to run workloads on one queue to make initial implementation easier

wayback-archive

How to programmatically check graphics driver version

the article discusses several ways to query the driver version and how to interpret the results
presents how to query the information with AMD, and Nvidia-specific API
and the API standard way exposed by D3D12 and Vulkan

wayback-archive

Avatar: Frontiers of Pandora - the big developer tech interview

the interview between DigitialFoundry and some of the developers of the developers from Massive provides insights into the implementation of the game
discussing raytracing, GI, GPU rendering pipeline, and many more topics
also provides into the CPU side structure as well as PSO management

wayback-archive

Introduction to micro-meshes for mesh compression

the article presents how to use Simplygon to generate micro-meshes (base structure + displacement information)
shows examples of what kind of results can be expected from different settings and how it affects memory usage and quality
presents how the way a model has been created can affect the base resolution vs. tesselation amount to achieve high-quality results

wayback-archive

Simulating Fluids, Fire, and Smoke in Real-Time

the blog provides an introduction to fluid dynamics and rendering
the implementation is explained with the growing sophistication of the simulation
an interactive WebGL demo of each stage is provided
closes with how to apply temperature to color space conversion to enable a first completed fire simulation

wayback-archive

[video] Using Textures In The Vertex Shader - Advanced Materials - Episode 34

the video tutorial explains how to sample textures from a vertex shader
explaining the quality difference and how the mesh vertex distribution and the texture content can significantly affect the quality of the result
additionally presents the different strategies that are available for the selection of varying texture MIP levels

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 317 - December 10th, 2023

Sun, 10 Dec 2023 04:00:00 +0000

Exploring the design space of remote scene approximation

the blog presents a walkthrough of the author’s R&D process when approaching the issue of generation of a scene approximation
shows how to analyze the constraints, develop a high-level intuition for the problem, and use this to explore the problem space
discusses the different solutions’ pros & cons and shows how to start prototyping and iterating through the process

wayback-archive

Use the GPU, Luke!

the blog post provides an overview of GPU programming concepts for non-graphics programmers
discusses GPU architecture, how to author shaders, how to read/write data, and basics of synchronization
For example, d3d11 code for an image converter is provided

wayback-archive

Performance Comparison of Meshlet Generation Strategies

the research paper presents the performance impact of different vertex clustering (meshlets) on the efficiency of mesh shaders
discusses hardware design/limitations that affect considerations when deciding on cluster sizes
discusses different algorithms, providing an overview of the technique, implementation considerations, as well as performance differences
source code for the meshlet generation is provided

wayback-archive

[video] GPU Crash Debugging in Unreal Engine: Tools, Techniques, and Best Practices | Unreal Fest 2023

the presentation shows the complexity of debugging issues that cause crashes that originate from GPU issues
provides an overview of available techniques and tools and how to combine them to track down issues
explains the steps required to track down example crashes from The Witcher

Shader on The Sphere

a small website that allows the authoring of GLSL shaders and running them on a virtual “The Sphere” located in Las Vegas
contains a couple of examples as starting points

wayback-archive

WebGPU/WebGL performance comparison best practices

the article provides best practices to follow when comparing WebGL and WebGPU workloads
It presents how to verify the underlying API, output configuration, blend modes, and other aspects that can affect performance
additionally presents how to report issues after confirming the aspects are identical

wayback-archive

[video] How Games Have Worked for 30 Years to Do Less Work

the video provides an explanation of techniques used by rendering systems to reduce the number of objects that need to be drawn to the screen
shows how frustum culling is only the first step, expand upon the idea by introducing occlusion culling
explains how to use the depth buffer to improve culling further and take advantage of temporal information to further enhance culling results

DirectX? On my Linux??

brief example blog post that presents how it’s possible to use DXVK to build a native Linux elf that uses the D3D11 API
shows how to integrate the necessary steps into Cmake with a SDL based application

wayback-archive

[video] Vertex Shader Optimization - Advanced Materials - Episode 33

the video tutorial shows how to move computations from a pixel shader into a vertex shader
presents two examples and uses them to show the change in visual results when moving from pixel to vertex shading frequency
code examples are shown in unity and unreal visual scripting

Introducing Radeon™ GPU Profiler 2.0!

the blog post shows the release of the new version of the AMD GPU profiler
presents the updated UI and how divergence raytracing pipelines can be visualized better

wayback-archive

Our brand-new DirectStorage sample is available now

AMD released a sample for DirectStorage that was presented during GDC 2023
the code shows how to use the API and how to compress assets to be able to take advantage of the API patterns

wayback-archive

Thanks to Eric Haines for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 316 - December 3rd, 2023

Sun, 03 Dec 2023 04:00:00 +0000

Announcing AMD RenderStudio - supporting collaborative 3D creation and rendering in the OpenUSD and MaterialX ecosystem

the blog post announces USD integration into the AMD RenderStudio
presents how the system allows real-time collaboration between different authoring tools (Maya, Blender, Houdini, RenderStudio)
additionally also supports MaterialX into the renderers

wayback-archive

Coverage Bitmasks for Efficient Rendering Algorithms

the presentation provides an overview of bitmasks and their uses in rendering
It covers many applications for the technique (rasterization, font rendering, culling, global illumination, raytracing, etc.)
explores the properties and how they are a fantastic fit for GPU programmability and machine learning

wayback-archive

[video] Lengths, angles, projection, correlation | Linear algebra episode 2

the video provides an excellent and detailed overview of the dot product
shows how the product is defined in algebraic notation as well as geometric interpretation
explains relationships and properties with visual explanations
additionally provides practical examples of how to use the different properties and operations introduced in the video

GM Shaders Mini: OkLab

the article presents the issues when creating a color gradient from sRGB and linear color spaces
introduces how the OkLab color space is designed to be perceptually linear and allows smoother gradients
provides code for the color space conversion

wayback-archive

Jobs

Principal Graphics Programmer
Remote, United Kingdom

Studio Elevation are re-establishing the boundaries of VR. We’re looking for a talented Principal Graphics Programmer to help us explore, create, and deliver world-leading innovation in software and VR hardware. Become a key member of Elevation, pioneering AAA, remote first process and crafting a new generation of VR development to bring core VR games to fruition.

Would you like to advertise your job openings here too? More information

[video] How to Render a Wireframe On a Solid Mesh

the video explains how to use a geometry shader to render a wireframe overlay on a mesh using a single pass
provides the overview of the presented algorithm before showing the OpenGL implementation

[video] What Is A Graphics Programmer?

the video provides the story of the author becoming a professional graphics programmer
discusses the author’s view on the path into the industry for graphics programmers, technical artists, as well as general shader artists
shows the importance of self-learning, portfolio creation, and the lack of intermediate resources

[video] Introduction To Vertex Shaders - Advanced Materials - Episode 32

start of a new shader tutorial series covering vertex shaders
starts off with an overview of vertex shaders and how to use them from Unity and Unreal

[video] When Your Game Is Bad But Your Optimisation Is Genius

the video presents techniques used to optimize terrain rendering
shows how to compress vertex information to reduce the memory and bandwidth requirements
additionally shows the importance of LODs for rendering performance

Thanks to Max R.R. Collada for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 315 - November 26th, 2023

Sun, 26 Nov 2023 04:00:00 +0000

How We Render Extremely Large Point Clouds

the article discusses a system to compute shader rasterize large point cloud datasets at interactive rates
the detailed blog presents how they solved problems along the whole pipeline
covering point reordering, point rejection and hole filling, level of detail selection and calculation, as well as memory usage optimizations
additionally presents how the data is expressed and used from the Unity implementation

wayback-archive

How do I become a graphics programmer? - A small guide from the AMD Game Engineering team

the article gives some advice on how to get started with graphics programming
discusses the complexity of different graphics APIs
additionally provides a list of tutorials/blogs and courses that provide a good starting point

wayback-archive

(Graphics) Programming Resource List

a start of a collection of books and resources for (graphics) engine programmers that I recommend
covering mathematics, engine architecture, graphics programming, collision detection, software design, as well as knowledge organization

wayback-archive

GM Shaders Mini: Phi

the article presents Phi and the Golden Angle
shows how to use these numbers for a point distribution in a rectangle as well as a disk
provides a shader toy example to present the effect when using blur kernels

wayback-archive

Jobs

Principal Graphics Programmer
Remote, United Kingdom

Would you like to advertise your job openings here too? More information

Interpolating Color Image Histograms Using Sliced Optimal Transport

the article provides a visual explanation of what an optimal transport problem is
presents how the problem can be solved a lot simpler in 1D
extends on this insight to present how a multi-dimensional problem can be sliced and approximated in multiple 1D steps

wayback-archive

WebGPU Render Bundle best practices

the article describes the concept of render-bundles and how they can be used to reduce CPU overhead
presents what changes are backed into the bundle and how updating referenced resources enables flexibility beyond static scenes
code examples and internals are discussed in WebGPU terms but apply to other APIs as well

wayback-archive

A library for creating and manipulating spherical and zonal harmonics.

The author updated his library for spherical harmonics and zonal harmonics
added GLSL shader variation and shader toy
additionally, the update fixed several bugs and made improvements

wayback-archive

Improved Multithreading in wgpu - Arcanization Lands on Trunk

the article presents a look into the internals of the gfx-rs wgpu implementation
demonstrates the limitations of the implementation in terms of multithreaded uses
shows what changes were made to reduce lock-contention and how the implementation might change in the future further

wayback-archive

Performance tricks

short blog post lists a couple of tricks to use when writing shaders for higher performance
additionally provides a small trick on how to reuse data between iterations when using shaderToy

wayback-archive

Unlocking GPU Intrinsics in HLSL

the blog post shows how to use Nvidia-specific intrinsics with D3D11 and D3D12
how to use them from shaders and how to verify that the hardware supports it

wayback-archive

Thanks to Denis Gladkiy for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 314 - November 19th, 2023

Sun, 19 Nov 2023 04:00:00 +0000

Dynamic vertex formats

the article presents a couple of methods that can be used to read vertex information from shaders
shows the more flexible approaches enabled by Vulkan/D3D12
presents how more modern approaches allow data quantization
shows the effect of different quantization formats on precision and how to choose which one to use

wayback-archive

Tiled per-triangle soft shadow volumes

the article discusses an approach for the calculation of sun-soft shadows
the solution uses a 16x16 software rasterize per fragment to establish occlusion
presents performance numbers, limitations as well as possible improvements

wayback-archive

[video] Optimize Your Meshes!

the video tutorial presents how to use Mesh Optimizer to optimize meshes for faster rasterization
shows five different types of optimizations (duplicated vertices, vertex cache, overdraw, vertex buffer optimization, as well as draw simplification)

Interactive 3D Graphics and Games - Call for Participation

The I3D conference for 2024 is looking for papers
the page lists important dates and the submission process

wayback-archive

GM Shaders Mini: The Matrix

the tutorial provides a brief overview of matrix operations
covers matrix types, how to fill it with data, and how to express different operations

wayback-archive

Changing the game for Black hair

the guide provides a collection of reference materials for different black hairstyles and advice for improving the look
GitHub provides reference images, textures, and 3D meshes for the presented hairstyles

wayback-archive

[video] code.talks 2023 - Making pretty things with code: Getting started as Technical Artist

the talk presents an insight into the job of a technical artist
covers what TAs tend to work on, what they need to know, and how to learn
additionally covers how to get started on the journey of becoming a technical artist

AMD - UE - Performance guide

AMD released a performance guide that helps developers with profiling work when using UE
covers command line options for predictable results, how to create test cases, and enable profiling tool support
provides some pointers for getting started with profiling for systems such as Nanite, Lumen, and upscaling
additionally provides practical examples to showcase the effect of the optimizations

wayback-archive

Thanks to Lesley Lai for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 313 - November 12th, 2023

Sun, 12 Nov 2023 04:00:00 +0000

Physically Based Rendering: Fourth Edition

the 4th edition of the Physically Based Rendering has been released to read on the web for free
the book teaches both the mathematical theory and the practical implementation of a photorealistic rendering

wayback-archive

Advanced API Performance: Intrinsics

a brief blog post that describes what advantages Wave intrinsics can have
advises on group sizes and how they can affect code generation

wayback-archive

Secrets of Direct3D 12: Do RTV and DSV descriptors make any sense?

the article provides an overview of the way D3D12 deals with resource descriptors
presents how shaders use the RDNA2 instructions use the descriptor when sampling
from there, shows how Render/Depth targets are different and only used from the CPU side

wayback-archive

Intuiting Latency and Throughput

video of the Performance-Aware Programming series that presents in real-world terms latency, throughput, and dependency chains
aims to develop the intuition of these concepts by explaining the process of doing laundry and showing that the same fundamental ideas apply to accelerate chores

wayback-archive

Explore GPU advancements in M3 and A17 Pro

the video presents an overview of the hardware changes in new Apple hardware generations
discusses how new hardware features enable better hardware utilization through dynamic shader register usage
additionally covers the updates to the hardware raytracing capabilities

wayback-archive

Discover new Metal profiling tools for M3 and A17 Pro

the video discusses updates to the profiling capabilities of hardware/software updates
presents new views that visualize screen space costs and allow better visualization of hardware counters
explains how the new capabilities allow performance issues to be identified with examples

wayback-archive

Why Cities: Skylines 2 performs poorly

the article provides a breakdown of the GPU scene rendering of Cities: Skylines 2
presents how the scene is drawn and points out performance optimization issues

wayback-archive

Extending Materials in Bevy 0.12 with MaterialExtension

the video tutorial presents how to extend the generic bevy rendering material to support custom effects
shows the process in two examples
covers the shader changes, how to bind custom data, and how to use the newly defined material

wayback-archive

[video] How do Major Video Games Render Grass?

the video provides an overview of how Ghost of Tsushima rendered grass
presents the process of implementing the rendering step by step inspired by the technique

[pptx] The Rendering of The Callisto Protocol

the slides for the advances of rendering presentation have been released
proposes a novel approach for BRDF authoring against photograph references
covering how to develop the main character shading model and validate the results
additionally covers raytracing reflections, transmissions, and related optimizations

wayback-archive

Thanks to Giuseppe Modarelli for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 312 - November 5th, 2023

Sun, 05 Nov 2023 04:00:00 +0000

NVIDIA Micro-Mesh Vulkan Sample

Nvidia released a sample that explains how to render Micro-Mesh using both the Vulkan extension and classical compute shaders
presents how to read the necessary data all the way to render it
shows how to rasterize and ray trace the data

wayback-archive

OpenPBR v0.2 Now Publicly Available

the blog post describes the first public release of the Open Physically-Based Rendering model
the model is built upon MaterialX by Adobe and Autodesk
the early release that is looking for feedback from the community before the final release in 2024

wayback-archive

Real-time dreamy Cloudscapes with Volumetric Raymarching

the article presents the story of the development of a cloud shader that uses raymarching to render a cloud space
starts with raytracing, and the reformation of tracing density as the starting point
from there, expand the example step by step to implement more advanced capabilities
all intermediate stages are presented as interactive examples

wayback-archive

Finding Real Polynomial Roots on GPUs

the article discusses the implementation details of an efficient method to compute roots of Polynomial functions with high degrees
presents an overview of the underlying method (Bracketed Newton bisection) and the implementation issues related to performance and precisions
shows how to use Nvidia’s Nsight to identify the performance issues and how to resolve the register spilling problem to improve performance significantly

wayback-archive

PIX 2310.30: a faster PIX with many raytracing + other improvements

the blog post discusses the changes in the latest significant PIX release
improved application performance, vastly improved raytracing debugging capabilities, and much more
also lists breaking changes introduced in the accompanying WinPixEventRuntime

wayback-archive

[video] Alan Wake 2 PC Path Tracing: The Next Level In Visual Fidelity?

the video shows the visual fidelity of the PC version of Alan Wake 2
presents how the different levels of raytracing affect the visual results
contains many insights into what limitations can be resolved with raytracing and what can still be improved
additionally presents a brief look at the DSSL upsampling logic being used

[video] How Are Games Rendering Fur?

the video discusses the nature of hair and the aspects that make it a complex topic to reproduce
presents how hair can be represented as shells and builds up the technique step by step
additionally presents what issues the technique has and workarounds to reduce the visual impact of the limitations

[video] OpenGL [Episode 30] [Theory] The View Matrix

the video provides a beginner-level view of how a camera orientation can be represented and transform vertices from the 3D world onto the screen
explains the concept in OpenGL terms and shows the necessary library calls to create the matrix

Thanks to atyuwen for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 311 - October 29nd, 2023

Sun, 29 Oct 2023 04:00:00 +0000

[video] Animated Flag Part 2 - Advanced Materials - Episode 27

part 2 of the animated flag series extends the effect from the previous video
adds support for allowing the flag to be rotated
additionally shows how to recalculate the normals for improved lighting

[video] Why can't you multiply vectors?

the talk presents an overview of linear algebra
covering topics from the basics of vectors, complex numbers, operations between vectors, and more
shows how intuition developed connects to geometric algebra

Machine Learning for Game Devs: Part 1

the blog post introduces a new series about machine learning that aims to connect different disciplines
provides an introduction to machine learning and shows how it can be expressed in shader code

wayback-archive

Study Notes On The Marschner Hair Shading Model

the blog post describes the The Marschner Hair Shading Model
focuses on high-level information and develops an intuition for the model
additionally provides corrections and extensions for ideas from the original paper

wayback-archive

GM Shaders Mini: Tonemaps

the article presents the importance of tone mapping to reduce color clamping
shows visual examples of different tone mapping implementations

wayback-archive

Efficient CUDA Debugging: Memory Initialization and Thread Synchronization with NVIDIA Compute Sanitizer

the article presents the types of checks available by the NVIDIA Compute Sanitizer
shows how to use sanitizers to detect memory access errors, uninitialized device global memory access, thread synchronization hazard detection, and more
each example is provided with source code to the issue and how the sanitizer helps to detect it

wayback-archive

Advanced API Performance: Descriptors

the article presents a collection of recommendations for descriptor usage on Nividia using D3D12 and Vulkan
discusses what are best practices, what should be avoided, as well as pitfalls to avoid

wayback-archive

[video] RE:2023 Shader Translator: Implementation and Use

the video presents how shaders are translated between HLSL and the target shading languages
explains the limitations of existing solutions and why a custom solution was developed
shows how DXC is used as a frontend and the steps necessary to convert to GLSL

[video] RE:2023 Is Rendering Still Evolving?

the video presents an overview of the RE ENGINE graphics stack
shows how shaders/material are authored, how raytracing has been deeply integrated and optimized
additionally presents how bindless allowed reduced CPU overhead and shows limitations, risks, and GPU performance impact of the approach
briefly covers mesh shaders and visibility buffers

Thanks to Warren Moore for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 310 - October 22nd, 2023

Sun, 22 Oct 2023 04:00:00 +0000

The Best Darn Grid Shader (Yet)

the in-depth article presents how to render a high-quality grid from a shader
presents what issues occur when rendering lines commonly
shows how to render anti-aliased lines that are free of these common artifacts
code is provided for unreal and unity

wayback-archive

Setting up PSO Precaching & Bundled PSOs for Unreal Engine

the article provides an overview of the methods available in UE5 to deal with Pipeline loading
presents timings to show the effect of lacking PSO pre-loading
discusses the new methods available and how to use them
additionally presents what is still missing for a 100% fluent player experience

wayback-archive

[video] Animated Flag - Advanced Materials - Episode 26

the video tutorial shows how to animate a flag using vertex shaders
step-by-step presents how to develop the effect using Unity and Unreal Engine

[pdf] Bounded VNDF Sampling for Smith–GGX Reflections

the paper introduces a method to reduce the amount of rejected rays for tracing rays following a visible normal distribution function (VNDF)
the unbiased method improves variance for highly rough and low-anisotropy surfaces

wayback-archive

The white furnace test

the article presents the white furnace test
discusses what the purpose of the test is and provides a real-life example of the behavior
additionally provides a ShaderToy example of the test and also demonstrates how incorrect sampling can be caught using the test

wayback-archive

Book (w/ Turnable Pages) Breakdown

the blog post presents how to set up a book with turnable pages
shows how to create the art assets and shaders to enable the effect
implementation is shown using unity visual shader graph

wayback-archive

Doing dynamic resolution scaling? Watch out for texture memory size!

the article discusses dynamic resolution scaling and its effect on memory usage
presents findings of texture sizes/formats on Nvidia, AMD, and Intel GPUs

wayback-archive

New Implementation of LTC Line Lights

the article presents three issues with linearly transformed cosine (LTC) Line Lights
presents an improved routine that reduces the required usage of arc tangent calculations

wayback-archive

Designing Slang’s automatic differentiation

the blog post introduces the new automatic differentiation feature for the slang shading language
provides an overview of how it’s integrated into the language
presents a comparison between tensor and shading languages

wayback-archive

The new sokol-gfx WebGPU backend

the blog post discusses the implementation of WebGPU into the sokol-gfx library
shows what issues had to be solved and how the author resolved them

wayback-archive

[video] Introduction To Tessellation in OpenGL

the article provides an overview of the tesselation pipeline
explains how it fits into the rendering pipeline and what possibilities it enabled
presents how to render cubic bezier splies using tesselation
implementation is shown using OpenGL

Thanks to Warren Moore for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 309 - October 15th, 2023

Sun, 15 Oct 2023 04:00:00 +0000

Locally-Adaptive LOD for Hardware-Accelerated Ray Tracing

the paper introduces a level of detail technique for triangular meshes for use with ray tracing workloads
proposes a data structure for hierarchically representing triangle meshes, allowing localized decisions for the desired mesh resolution per ray

wayback-archive

Work graphs API – compute rasterizer learning sample

the blog post shows how to implement a scan-line rasterizer using D3D12 work graphs
presents how to implement the rasterization using D3D12 work graphs, showing the C++ and HLSL implementation
shows how to split work between GPU threads and how it affects performance

wayback-archive

Voxy tool development so far...

the article discusses the author’s development of a real-time voxel rendering and authoring system in Unreal Engine
covers the data structure usage, compute shader implementation as well as issues transition between UE4 and UE5

wayback-archive

Advanced API Performance: Debugging

the blog post discusses advice to help debug issues with GPU workloads
covers how to track GPU progress, get debugging information from shaders, available tools, etc
additionally provides a list of steps to follow when tracking down issues

wayback-archive

Unity 4D #4: Creating 4D Objects

the article covers how to generate a 4D hypersphere
discusses multiple generation techniques
presents how to sample 4D noise uniformly

wayback-archive

Dynamic Resolution Scaling (DRS) Implementation Best Practice

the article discusses ten implementation details to consider when working on a Dynamic Resolution Scaling (DRS) solution
covering memory handling, resolution choices, effects on frame timing, debugging advice, as well as UI rendering

wayback-archive

Vulkan Documentation Just Got Easier!

the blog post introduces the updated Vulkan documentation website
it combines the spec, proposals, samples, shader language information, etc., into one place
the blog post provides the reasoning and an overview of where to find the information

wayback-archive

[video] Worn-Out LCD Screen Shader - Advanced Materials - Episode 25

the video tutorial presents how to implement a material effect that simulates an old LCD screen effect
the effect combines scan lines, vignette fading, flickering, half-tone shading, and flipbook animations
implementation is shown in Unreal and Unity Visual Scripting

Master Thesis - Volumetric data structures for real-time ray tracing

The master thesis provides an overview of the different trade-offs of volume data structures
introduces a method for storing density data in block-compressed textures combined with deduplicating homogeneous nodes
shows how this enables efficient flipbook animations

wayback-archive

Thanks to Matt Pharr for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 308 - October 8th, 2023

Sun, 08 Oct 2023 04:00:00 +0000

[video] AMD FSR3 Hands-On: Promising Image Quality, But There Are Problems - DF First Look

the video provides an overview of the FSR3 frame generation
presents the state of FSR related to frame pacing with Vsync and variable refresh rates
additionally presents the effect on latency and compares against DLSS

SimLOD: Simultaneous LOD Generation and Rendering

the paper presents a method to incrementally construct a LOD structure for point clouds directly on the GPU and render points as they are still being loaded
shows how the tree is built, the interaction between CPU and GPU, as well as a look at the performance

wayback-archive

Ray Tracing Spherical Harmonics Glyphs

the paper introduces a new method to render Spherical harmonics glyphs efficiently
SH glyphs are used to visualize High angular resolution diffusion imaging (HARDI)
presents how to intersect the rays, calculate bounding boxes, as well as how to apply shadows

wayback-archive

Jobs

C++ Engine Programmer
Auckland, New Zealand

Grinding Gear Games is seeking a C++ Engine Programmer to work on our in-house engine and tools. Our engine is specific to Path of Exile and attempts to solve the problems uniquely generated by the dynamic gameplay that we support while taking advantage of the opportunities granted by our fixed camera perspective.

Would you like to advertise your job openings here too? More information

USD and glTF Resources Page

the website presents a collection of USDs and glTF information
collection of introduction articles, specification links, as well as supporting tools

wayback-archive

A Micrograin BSDF Model for the Rendering of Porous Layers

the paper introduces the concept of micro grains to approximate layered materials
allows the separation of structural properties from their reflectance properties
present results, underlying theory, and approximations

wayback-archive

Stable Fiddusion - Frequency-domain blue noise generator

the in-depth article discusses noise generation
presents a generation approach based on generating in the frequency domain
source code and example app is provided

wayback-archive

GPU driven rendering in AnKi: A high level overview

the blog post discusses issues encountered when moving AnKi object visibility onto the GPU
covers data layout, the command buffer building, as the occlusion techniques used

wayback-archive

Unity 4D #3: Rendering 4D Objects

This article explains in detail how to render 4D objects in 3D space
shows orthographic projection, perspective projection and cross-section techniques to visualize 4D objects
many visualizations and code examples are provided

wayback-archive

From the archive: Notes on environment lighting occlusion.

the article discusses Parallax-corrected cube maps and their related approximations
discusses issues and limitations of the technique

wayback-archive

Introducing Desmos Studio's 3D Calculator (Beta)

the article introduces that the Desmos calculator now supports 3D visualizations
contains interactive examples to demonstrate the capabilities

wayback-archive

GM Shaders Mini: Vector Spaces

the blog post provides a summary of common spaces found in graphics operations
covers texture, screen, object, world view as well as Projection Space

wayback-archive

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 307 - October 1st, 2023

Sun, 01 Oct 2023 04:00:00 +0000

[video] Sampling of Environment Maps for Image-based Lighting [Shaders Monthly #13]

the video shows how to sample texture lighting information stored in environment maps using importance sampling
shows the underlying math for the different contributing elements
also presents how to implement the technique using GSN Composer

Toon Shading Fundamentals - From Cel-Shading to bidirectional toon ramps

the article presents the basic steps for a toon shading implementation
provides an overview of the different toon shading techniques
covers toon ramps, cel-shading, lighting, and extensions such as shading ramps

wayback-archive

Combining Resampled Importance and Projected Solid Angle Samplings for Many Area Light Rendering

The paper presents a combination of Resampled Importance Sampling (RIS) and Projected Solid Angle Sampling (ProjLTC) for many area lights.
provides a method of improving the efficiency run-time as RIS with a lower error
shows the comparison between previous methods

wayback-archive

Nonlinear Ray Tracing for Displacement and Shell Mapping

the paper introduces a new approach to perform acceleration structure traversal and intersection tests against micro triangles texture space
implementation is using nonlinear rays as degree-2 rational functions
present performance and memory usage
additionally discusses the effect of floating point precision

wayback-archive

Making Gaussian Splats more smaller

the blog describes how to compress the Gaussian splat SH data by using clusters and color palettes
shows the effect on memory usage as well as quality

wayback-archive

Chrome Graphics as Seen By Attackers

the article provides an in-depth discussion about how WebGPU is implemented within Chrome
shows how the different implementation layers communicate
presents a look at bugs found during the research process and possible attack surfaces

wayback-archive

You’re calculating framerate percentiles wrong!

the blog post describes the importance of considering the total runtime when calculating performance characteristics
discusses how failing to do so can skew the results towards a more positive conclusion

wayback-archive

AMD FSR 3 game integrations out now + more details for developers

the article provides a brief overview of the FSR algorithm implementation
discusses how the frame generation interacts with the underlying native APIs as well as the state of the UE5 plugin integration

wayback-archive

Thanks to Panagiotis Tsiapkolis for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 306 - September 24th, 2023

Sun, 24 Sep 2023 04:00:00 +0000

[video] Game Engine Programming 060.3 - Explaining block compression formats and sRGB color space | C++

the video explains BC texture compression
covers how the compression format works and the differences that exist
explains guidelines on which format to use for different use cases
additionally also covers SRGB color space and explains when/how to use it

Reach For the Spheres: Tangency-Aware Surface Reconstruction of SDFs

the paper introduces a new method for the triangle mesh reconstruction from an SDF representation
The presented method is based on the insight that each SDF sample represents a spherical region
generates an initial mesh and then shrinks the shell using a gradient flow approach

wayback-archive

Interlocked min/max on HLSL single precision floats (Part II)

the article presents improvements to using floating point atomic operations if all inputs have the same sign
additionally discusses how half and double floating point numbers might be operated on with uint atomics

wayback-archive

Worley and His Noise (Worley Noise/Voronoi Noise)

the article presents how to implement Worley/Voronoi noise
starts with Voronoi shapes and expands to noise
additionally presents how to animate the noise

wayback-archive

From WebGL to WebGPU

the article presents a set of differences between WebGL and WebGPU
covers clip space, synchronization, mip-generation, canvas handling, and more

wayback-archive

Radeon™ Raytracing Analyzer 1.3 is now available

the latest version of the raytracing analyzer adds support for visualizing the rays in the scene
allows each ray to be visualized, heatmap information, and ray types
presents how to analyze performance given the provided information

wayback-archive

Radeon™ Memory Visualizer 1.7 is out now

the latest edition of the Memory Visualizer adds improved support for resource aliasing
additionally adds support for post-crash analysis

wayback-archive

Radeon™ GPU Profiler 1.16 is here!

the article presents changes in the latest AMD GPU profiler update
improved work graph, instruction search, output merger state visualization as well as shader hashes

wayback-archive

Introduction to 3D Gaussian Splatting

the blog post provides an introduction to the Gaussian Splatting rasterization technique
discusses the technique, data collection, training as well as downsides of the technique

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 305 - September 17th, 2023

Sun, 17 Sep 2023 04:00:00 +0000

Painting with Math: A Gentle Study of Raymarching

the blog post provides a visual introduction to Raymarching
builds up from simple spheres to animated shapes and concludes with more complex terrains
all examples are provided as javascript and GLSL code examples that are fully live and editable

wayback-archive

GM Shaders Mini: Math

the article provides a brief overview of alpha blending and weighted averages
additionally shows a simple technique to create a perspective effect

wayback-archive

Making Gaussian Splats smaller

the article discusses how to compress the data for the Gaussian Splats technique for reduced memory usage
presents how to re-order data for spatial coherence, compressing data relative to a local reference point
discusses how to compress splat data as textures and the effect of different BC compressions on the visual quality and memory reduction

wayback-archive

Onboarding floating-point

the series of blog posts covers floating points and fixed point representations for numbers
discusses different representations for numbers, how to estimate precisions and ranges
shows how floating point numbers are expressed in hardware and how to implement common mathematical operations

wayback-archive

[video] How I implemented MegaTextures on real Nintendo 64 hardware

the video presents an overview of virtual texturing
discusses texturing concepts and how to represent textures using tiles
shows visual presentations of the variations of texture resolution required and how it affects which tiles of textures are required
implemented for N64

Vulkanised 2024 - Call for Submissions

the 2024 Vulkan conference Vulkanised is looking for speakers
the blog post discusses topics being searched for, what is required for a talk proposal, as well as applicable submission deadlines

wayback-archive

Call for Authors GPU Zen 3

the latest edition of the GPU Zen books is looking for authors
the blog post lists some recommended topic, answers to frequently asked question as well as deadlines

wayback-archive

Thanks to Eric Haines for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 304 - September 10th, 2023

Sun, 10 Sep 2023 04:00:00 +0000

[pdf] Authoring Materials That Matters - Substrate in Unreal Engine 5

The presentation covers the development of a new material model based on Slaps, Operators, and Trees
explains what these three concepts represent and the issues they aim to resolve
shows the implementation details, data storage, and integration into the rendering pipeline
additionally presents how to integrate visualization for tool purposes

wayback-archive

What we talk about when we talk about Ray Tracing?

The article provides an overview of ray tracing rendering concepts
shows a summary of different methods such as Ray Marching, Cone tracing, and photon mapping
discusses how it fits into the rendering pipeline as well as what phenomenons it enables to be simulated

wayback-archive

Gaussian Splatting is pretty cool!

The blog post describes a brief overview of the Gaussian Splatting technique
how it compares to previous techniques
additionally discusses memory and performance of the demo application

wayback-archive

Interlocked min/max on HLSL single precision floats

The article discusses a technique to implement atomic min/max operations on HLSL (that doesn’t support it natively)
presents how to map floats into uints and reverse the mappings

wayback-archive

GM Shaders Mini: Imagination

The blog post shows the importance of thinking in gradients
Consider acceptable input domains and output ranges to prevent errors and unexpected results
Utilize periodic functions, trigonometry, dot products, and exponentiation for various shader effects and measurements

wayback-archive

Constant Time Stateless Shuffling and Grouping

The article introduces how to encrypt/decrypt are methods to allow reversible changes to data
shows how to generate cheaper models than cryptographical methods to solve specific problems
expands the concepts to present a method that allows grouping and shuffling in a stateless manner
provides source code for a couple of examples of the presented techniques

wayback-archive

[video] Wow, NVIDIA’s Rendering, But 10X Faster!

The video presents a comparison of 3D Gaussian Splatting for Real-Time Radiance Field Rendering against Instant NeRF techniques
discusses a summary of the technique and how it can achieve the results without using any neural networks

[video] I Tried Simulating The Entire Ocean

The video provides a discussion of ocean simulation and shading
presents an overview of the theory, mathematics, and practical considerations for implementation
additionally presents a look at the shading models for water surfaces

At A Glance: The Aliasing Problem in Computer-Generated Shaded Images

The article presents a brief discussion of Aliasing in computer graphic
presents how the sampling patterns cause the artifact
additionally presents techniques to resolve the artifacts

wayback-archive

[pdf] HypeHype Mobile Rendering Architecture

The presentation provides a detailed look at how the rendering API for HypeHype was rewritten for a modern mobile architecture
discusses a large spectrum of topics from API design approach, memory API, data update frequency
shows in detail how the draw operations are represented for the most efficient rendering performance
presents performance numbers on PC and various mobile hardware

wayback-archive

[pdf] Large-Scale Terrain Rendering in Call of Duty

The presentation covers the terrain rendering methods used in previous Call of Duty and shows the shortcomings
discusses how the new method virtual texturing method improves upon the issues
shows the implementation details as well as new capabilities that have been enabled

wayback-archive

GFXReconstruct on Android - How-To Guide

The article presents the steps necessary to use the GFXReconstruct on Android
how to capture the information and replay it at a later date

wayback-archive

Thanks to Bruno Opsenica for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 303 - September 3rd, 2023

Sun, 03 Sep 2023 04:00:00 +0000

[video] CUDA Tutorials I Profiling and Debugging Applications

The video tutorial contains a high-level overview of the profiling tools available for Cuda workloads
shows an example of how to use the tools to identify a cude performance issue

New Work Graphs sample and Radeon GPU Profiler support for GPU Work Graphs

The article presents a new D3D12 work graph sample to demonstrate how to classify screen space materials
presents a high-level overview of the demo application
additionally presents how the Radeon GPU Profiler can visualize the performance of work graph applications

wayback-archive

BroadLeaf: Developing a Real-Time Solution for Rendering Trees

The article explains the Tencent tree rendering system
explains how tree information is compressed, automatic LODs are generated, as well as how GPU-driven rendering techniques are used for efficient rendering
provides videos to show the LOD transitions as well as comparison against (older versions of) Nanite

wayback-archive

Solving Self-Intersection Artifacts in DirectX Raytracing

the article presents a robust solution to resolve self-intersection issues with secondary rays
the proposed solution works by calculating error bounds and offset the starting point to lie outside of these bounds
presents methods to reduce floating point numerical issues through using the suitable coordinate space and operation ordering
HLSL and GLSL implementations are provided

wayback-archive

Jobs

Graphic Programmer - C++ / Vulkan API/ DirectX/ Realtime-Rendering
Del Mar, CA (On-site)

Do you want the chance to work with clients like Google, Microsoft, Activision, Qualcomm and other AAA studios?

This is an opportunity to join a world-leader in advanced real-time graphics who are working at the cutting-edge of the game industry.

Bachelor’s degree in Computer Science or equivalent
Experience with DirectX 12, Vulkan, Metal, or other current rendering API
2+ years professional graphics programming experience

Please apply with your resume attached by replying to jiayi.zhuo@theforge.dev

Would you like to advertise your job openings here too? More information

Advanced API Performance: Shaders

the blog post provides best practices for shader performance
covers generic shader advice, as well as vertex/pixel/tesselation/compute specific advice

wayback-archive

[video] Starfield: The Digital Foundry Tech Review

the video presents a deep dive into the technical aspects of Starfield
covering ship geometry details, materials, lighting, cities, landscapes, character details as well as reflections
additionally, look at the loading structure, loading times, and brief frame-rate discussion

[video] Billboarding With The Geometry Shader // Intermediate OpenGL Series

the article presents how to use geometry shaders from OpenGL
provides an overview of what geometry shaders are and how they can be used to overcome some vertex shader limitations
implements a simple shader that calculates normals for a displaced plane first
expands the implementation for billboarding, explaining the math and the implementation

Thanks to Cort Stratton for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 302 - August 27th, 2023

Sun, 27 Aug 2023 04:00:00 +0000

Bezier curves

The article provides an interactive explanation and exploration of Bezier curves
presents how the curves are represented and controlled
allows the user to change settings and interpolation settings to explore the effects on the curve

wayback-archive

[video] MaterialX 2023 Virtual Town Hall

Video recording of MaterialX-related developments in the virtual town hall meeting
covering OpenPBR, MaterialX shader editor, MaterialX in USD, and many more topics

Dispatch IDs and you

Blog post explains the different compute shader semantics
shows the difference between SV_DispatchThreadID, SV_GroupThreadID, SV_GroupID and SV_GroupIndex

wayback-archive

vsync simulator

The simulator provides the ability to experiment with different factors that affect the vsync effect
presents the effect of vblank intervals, CPU and GPU time differences, and how it affects frame stability and latency

wayback-archive

Jobs

Graphic Programmer - C++ / Vulkan API/ DirectX/ Realtime-Rendering
Del Mar, CA (On-site)

Do you want the chance to work with clients like Google, Microsoft, Activision, Qualcomm and other AAA studios??

This is an opportunity to join a world-leader in advanced real-time graphics who are working at the cutting-edge of the game industry.

Bachelor’s degree in Computer Science or equivalent
Experience with DirectX 12, Vulkan, Metal, or other current rendering API
2+ years professional graphics programming experience

Please apply with your resume attached by replying to jiayi.zhuo@theforge.dev

Would you like to advertise your job openings here too? More information

Inside bend: screen space shadows

The presentation and source code for the screen space shadows used in Days Gone have been released
shows the effect, covering the implementation, and also discusses optimizations
The code is released under the Apache License

wayback-archive

Ray-aligned Occupancy Map Array for Fast Approximate Ray Tracing

The paper introduces a Ray-aligned Occupancy Map Array as an alternative to BVH-based ray tracing
shows how to generate the data structure from a single rasterization pass and compute-based processing
comparing against Distance Field and Hardware Ray Tracing

wayback-archive

Radiance Cascades: A Novel Approach to Calculating Global Illumination[WIP]

The paper presents a global illumination technique based on radiance cascades
Radiance Casdaces allow the storing and calculating of radiance fields by decomposing them into multiple ranges (from near-field to far-field) with asymptotic scaling
The paper discusses the data structure, implementation, and how the presented technique is used in Path of Exile 2

wayback-archive

Thanks to Cort Stratton for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 301 - August 20th, 2023

Sun, 20 Aug 2023 04:00:00 +0000

Rendering Technologies behind Gran Turismo 7: VR, Ray Tracing and Sky Simulation

the slides cover the difficulties of VR and what is required for a good user experience
presents what hardware features the PS5 GPU supports to improve the results
shows how raytracing was integrated into the rendering pipeline and an overview of the overall rendering pipeline
covers how the sky rendering was implemented, introducing the mie approximations used
additionally presents how multiple weather skys are implemented using multiple sets of lookup textures that are blended

wayback-archive

Camera and lens definitions for VFX

the article discusses the concept of focal length, presenting how different definitions of focal length are used for other aspects
explains the underlying optics concepts to clarify the meaning
discusses Nominal focal length, Pinhole focal length as well as Effective focal length

wayback-archive

[video] Mathematical Magic Mirrorball #SoME3

the video explains how mirror balls enable the representation of 360-degree views
focuses on the derivation of the mathematics of the approach and how to deal with projection bling spots
additionally presents several demos and use cases of mirror sphere projections

Optimizing Metal: Stitch several Metal functions into a single shader using MTLFunctionStitchingGraph

the article presents how to use MTLFunctionStitchingGraph to allow the creation of a final shader from multiple pre-compiled pieces at runtime
shows how to express that functions will be stitched at shader compile time, how to load and stitch the shaders from the API
combines everything to show how to use the stitched graph to apply image processing operations

wayback-archive

Jobs

Graphic Programmer - C++ / Vulkan API/ DirectX/ Realtime-Rendering
Del Mar, CA (On-site)

Do you want the chance to work with clients like Google, Microsoft, Activision, Qualcomm and other AAA studios??

This is an opportunity to join a world-leader in advanced real-time graphics who are working at the cutting-edge of the game industry.

Bachelor’s degree in Computer Science or equivalent
Experience with DirectX 12, Vulkan, Metal, or other current rendering API
2+ years professional graphics programming experience

Please apply with your resume attached by replying to jiayi.zhuo@theforge.dev

Would you like to advertise your job openings here too? More information

Hardcore Vulkan debugging – Digging deep on Linux + AMDGPU

the blog post gives insights into debugging crashes originating on the GPU
presents what API level tools are available to track down the range of possible draw calls
further expands from there to show how barriers can help to reduce the search space
additionally shows how on AMD + Linux native hardware information is available to improve the debugging experience

wayback-archive

Getting Started with Radeon™ GPU Detective 1.0

AMD released a new tool to help with debugging GPU crashes
the article provides a brief overview of the tool, what information is available, and how it’s to be interpreted
additionally discusses the limitations and usage tips

wayback-archive

rendering-bib

extensive bibliography of more than 3000 rendering papers
collected by Wojciech Jarosz from papers, conferences, and own research findings

wayback-archive

[SCC] Next Gen Development for Games | Sony Official

a combination of three conference presentations recordings from the sony creator event
the videos cover VR, Ray tracing, and sky simulation in Gran Turismo 7
Screen space shadows by Bend Studio, as well as ML Research by Haven Studios

HLSL 2021 Migration Guide

the latest version of DXC switches the default HLSL version to 2021
this article presents what number of cases where default behavior changed
shows what changed and how the code needs to be adjusted. Presenting quick solutions and more ideal solutions to deal with the changed behaviors

wayback-archive

ShaderCrashingAssert

release of a small header helper to implement a basic assert for GPU shader code
will trigger a GPU memory exception on purpose to halt the execution
helper is meant to be used together with Radeon GPU Detective

wayback-archive

Thanks to Giuseppe Modarelli for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 300 - August 13th, 2023

Sun, 13 Aug 2023 04:00:00 +0000

A Gentle Introduction to ReSTIR: Path Reuse in Real-time

the course notes and slides for the ReStir course from Siggraph are available
covering from introduction level content to more advanced use cases to the practical implementation in Cyberpunk 2077
video recordings are available for those who registered for Siggraph 2023

wayback-archive

SIGGRAPH 2023 Links

a growing collection of content from Siggraph 2023
presentations, talks, slides, posters, and more

wayback-archive

Reverse Z (and why it's so awesome)

the article presents how projection matrixes are expressed in different APIs
shows how to adjust the classic projection to reverse the direction of the z projection
followed by an explanation of how this matter helps when combined with floating point numbers to improve depth precision significantly

wayback-archive

Interviewing Graphics Programmers

the article presents a way to categorize graphics programmers into four broad groups
for each group, discuss what tasks they typically work on and what questions might be asked in an interview
additionally provides general advice for graphics programmer interviews

wayback-archive

Jobs

Graphic Programmer - C++ / Vulkan API/ DirectX/ Realtime-Rendering
Del Mar, CA (On-site)

Do you want the chance to work with clients like Google, Microsoft, Activision, Qualcomm and other AAA studios??

This is an opportunity to join a world-leader in advanced real-time graphics who are working at the cutting-edge of the game industry.

Bachelor’s degree in Computer Science or equivalent
Experience with DirectX 12, Vulkan, Metal, or other current rendering API
2+ years professional graphics programming experience

Please apply with your resume attached by replying to jiayi.zhuo@theforge.dev

Would you like to advertise your job openings here too? More information

Speed Up GPU Crash Debugging with NVIDIA Nsight Aftermath

Nsight Aftermath now supports application-specific markers to be inserted and accessed from the crash dumps
the blog post provides an example of how the tool shows the information
explains how to enable application marker support

wayback-archive

GM Shaders Mini: CRT

the article presents how to create a post-processing effect that simulates the look of CRT TVs
the individual steps are explained
shadertoy implementation is provided

wayback-archive

Bringing shaders to contest programming

the article presents how the author organized an online shader programming contest
presents how the problems were designed, challenges faced
additionally presents how the judgment system was implemented

wayback-archive

[video] SIGGRAPH 2023 | Latest in Graphics Development and GPU Profiling with NVIDIA Nsight Tools

the video presents a short overview of the new developer features in Nvidia tools
the graphics performance profiler now supports sampling profiling
additionally covers aftermath debugging and improved Cuda memory profiling

[video] Skydome // Terrain Rendering episode #12

the video presents the theory behind Skydomes and how they compare to sky boxes
explains spherical coordinates and how to use them to generate a sphere mesh
combines the information to implement skydome rendering using OpenGL

Optimize 3D Assets with Khronos’ New glTF-Compressor Tool

Khronos released a new tool to improve the experience when working with KTX compression
the tool allows the changing of settings, exporting of files, and side-by-side live comparisons

wayback-archive

Thanks to Keith O’Conor for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 299 - August 6th, 2023

Sun, 06 Aug 2023 04:00:00 +0000

[video] The rendering techniques of Path of Exile (Alexander Sannikov)

the presentation covers an overview of many rendering techniques used in Path of Exile
these techniques cover a large number of topics, such as flow fields, decals, subsurface raymarching, bent-normal shadows, waves, and much more
additionally presents details about a hierarchical probe system for GI that uses multiple hierarchical levels to approximate GI information with bounded cost

[pdf] Shadow Techniques from Final Fantasy XVI

the paper discusses the Shadow Techniques used by Final Fantasy XVI
presents the Tiled Deferred Shadow implementation, performance, and quality results
the paper discusses how the Oriented Depth Bias technique can be used to replace the traditional Hardware Depth Bias
additionally, it presents debug visualization techniques

wayback-archive

Jobs

Lead Rendering Programmer
Hybrid, from central London Studio

Rocksteady is an award-winning developer based in London, focused on combining character-driven cinematic narrative with genre-defining gameplay to create unforgettable experiences based on legendary IP. Growing our studio in London, our multicultural team takes inspiration from the culture and history of our home in one of the most diverse cities in the world.

We’re currently looking for an technical leader in rendering, to join our experienced team of game developers as we launch the highly anticipated project Suicide Squad: Kill the Justice League, and build exciting future plans.

Would you like to advertise your job openings here too? More information

Occluding Contour Breakthroughs, Part 1: A Surprisingly Hard Problem

the first part of a 3 part series that discusses occluding contour rendering
first part discusses the issues
the second part presents methods to efficiently generate smooth, sensible occluding contours from a triangle mesh
and the final part presents suggestions on what techniques to use for which problems and an overview of open research problems

wayback-archive

Why your GPU can (and probably should) do real function calls

the article presents a discussion of functions calls in shaders
covering issues with having and not having function calls
discusses how CUDA and ISPC support functions pointers, but GLSL doesn’t
presenting the costs associated and possible solutions

wayback-archive

Learnings As a Graphics Lead

the blog post provides an overview of leadership topics aimed at new graphics leads
lists lessons learned and advice separated by categories
covering Hiring, Day to Day actions, Performance Reviews, Advocacy as well as Self-Care

wayback-archive

Denoising-Aware Adaptive Sampling for Monte Carlo Ray Tracing

The paper proposes an adaptive sampling technique for efficient Monte Carlo rendering with deep-learning-based denoising
The suggested method estimates the variance of neural network outputs with random inputs to drive adaptive sampling methods
When combined with denoising post-correction, it significantly accelerates error convergence during rendering

wayback-archive

Radiant Flux, Intensity, Irradiance, Radiance, and the Rendering Equation

the blog post presents the rendering equation and derives the meaning by following the physical units used
explains differences and relationships between the different units

wayback-archive

Using decals to drive object shaders and post-processing.

the blog post presents the idea of using decals to drive where post-processing and object-level effects
discusses considerations when applying the decals and how to combine them with other effects
presents how to use the technique for post-processing shaders and object-level vertex-displacement and alpha effects

wayback-archive

Pixar, Adobe, Apple, Autodesk, and NVIDIA Form Alliance for OpenUSD to Drive Open Standards for 3D Content

the blog post presents the announcement of the formation of an organization for fostering the standardization, development, and evolution of USD to OpenUSD

wayback-archive

Approximate projected bounds [Updated]

the article has been updated with improvements
covers efficient, conservative projected bounds for spheres as well as AABB
presents the implementation and discusses the performance of the presented techniques

wayback-archive

Advanced API Performance: Synchronization

Nvidia presents the best practices for asynchronous compute queue work scheduling
mentions how expensive workloads need to be to see an advantage
additionally mentions patterns that should be avoided

wayback-archive

Thanks to Leonardo Etcheverry for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 298 - July 30th, 2023

Sun, 30 Jul 2023 04:00:00 +0000

Raytraced order independent transparency part 2

the article presents a method that uses any hit shaders to implement order-independent transparency
compares the performance and quality against the closest-hit shader method of the last post

wayback-archive

Announcing GPU Work Graphs in Vulkan

AMD announced the release of a Vulkan extension to support the experimental D3D12 Work Graph concept
The extension is called VK_AMDX_shader_enqueue and presents the API, reasons as well as open issues
sample application is provided

wayback-archive

Jobs

Lead Rendering Programmer
Hybrid, from central London Studio

Would you like to advertise your job openings here too? More information

Korean edition of RTR4 available

the blog post announces that the book Real-Time Rendering is now also available in Korean

wayback-archive

Float to int casts for data compression

the article discusses different methods that are available to convert from f32 to u32 data formats losslessly
presents use cases and what to consider when choosing between the methods

wayback-archive

GM Shaders Mini: Dither

the article presents an overview of dithering techniques
shows how the type of noise influences the effect
includes a shadertoy implementation of the presented techniques

wayback-archive

Jobs

Graphics Programmer
Remote Working (UK Based or Relocation)

Join nDreams Studio Orbital as a Graphics Programmer and be at the forefront of developing groundbreaking VR experiences that will captivate players for years to come.

As part of our remote team, you will collaborate with a diverse and innovative group, taking ownership of visual fidelity and rendering performance in Unreal Engine 5.

If you are passionate about pushing the boundaries of VR gaming technology and want to make your mark on the industry, apply now and be part of our exciting journey to redefine the future of VR!

Would you like to advertise your job openings here too? More information

Unity 4D #1: Understanding the Fourth Dimension

the article presents an introduction to the fourth dimension and explains how to imagine mathematically and geometrically accurate 3D objects
shows the mathematical foundation
the series aims at giving the reader the knowledge to simulate how 4D objects would behave in a 3D world

wayback-archive

A Whirlwind Tour of Games Color Management

the article provides a comprehensive overview of game color management and encoding complexities
introduces the separation between color and radiometric units
additionally also touches on the subjectivity of converting rendered data to displayable via “tone-mapping” operations

wayback-archive

PROGRAMMING: SDMV (Single Draw Multiple Viewport) Instanced Cubemap Rendering

the article presents how to render geometry to the six faces of a cubemap from a single draw call
explains how to use the VK_EXT_shader_viewport_index_layer extension
shows how to use the extension, what kind of hardware support can support the feature
additionally shows a high-level performance comparison between the classical approach and the usage of the extension

wayback-archive

Jobs

Principal Graphics Programmer
Hybrid Working – Farnborough (45 Minutes outside London)

Join nDreams, a world-leading VR game developer and publisher, as a Principal Graphics Programmer and be at the forefront of VR gaming innovation.

As part of our team, you will research, implement, and support new rendering features and shaders, collaborate with technical and creative staff, and optimize code and systems for optimal performance. We offer a state-of-the-art collaborative workflow, flexible hours, and a range of exciting benefits.

Apply now to join our team and shape the future of VR gaming!

Would you like to advertise your job openings here too? More information

Roblox to Present 3D Motion and Rendering Research at SIGGRAPH 2023

the blog post shows the talks Roblox will be presenting at SIGGRAPH
covers Surface Simplification, Differentiable Heightfield Path Tracing, hair simulation, and much more

wayback-archive

[video] Art Optimization: How FatShark constructed their central asset pipeline with Simplygon

the GDC presentation covers geometrical limitations and techniques that can be used to solve the bottlenecks
shows how Simplygon can be used to simplify models for improved rendering performance
discusses a large number of issues that will be encountered when simplifying common workflows and how to solve the issues

Thanks to Hasen Judy for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 297 - July 23rd 2023

Sun, 23 Jul 2023 04:00:00 +0000

Rendering ‘God of War Ragnarök’

the talk presents is a combination of leadership methods and rendering techniques of God of War Ragnarök
covering lightings units, optimization techniques, PS5 Enhacements such as raytraced cubemaps reflections
presents optimization appraoches used for shadows, geometry, and how it was tracked

wayback-archive

Advanced API Performance: Pipeline State Objects

the article provides a list of best practice recommendations for usage of PSOs with D3D12
additionally also presents what patterns are not recommendation
explaining why these recommendations are made

wayback-archive

Calculate how many helper pixels a pixel quad has

small twitter thread that presents how to use Quad intrinsics and IsHelperLane to visulize how efficent quad shading is

wayback-archive

Jobs

Principal Graphics Programmer
Hybrid Working – Farnborough (45 Minutes outside London)

Join nDreams, a world-leading VR game developer and publisher, as a Principal Graphics Programmer and be at the forefront of VR gaming innovation.

Apply now to join our team and shape the future of VR gaming!

Would you like to advertise your job openings here too? More information

[video] Nuclear's graphics tricks #1: simple outline rendering

the quick video presents a method to render an outline of an object by taking advantage of wireframe rendering mode
relies on rendering backfaces only and drawing lines that are thicker than 1 pixel
presents how to implement the technique using OpenGL

Computational complexity of texture encoding

the article explains how most tecture encoding formats operate in blocks, presenting how this reduces time complexity
Additional computational complexity of encoding textures depends on the search space of possible endpoint/mode combinations, which can be reduced using heuristics and pruning techniques

wayback-archive

Santa Monica Studio - Our GDC 2023 presentations

Santa Monica Studio release the slides for all GDC 2023 presentations
covers not only rendering topics but also AI, Animation, Testing, Art, accessbility and visual scripting

wayback-archive

Sub-pixel Distance Transform - High quality font rendering for WebGPU

the article presents an in-depth look at SDF font rendering techniques
shows issues with common implementations and show how to correctly render on a sub-pixel level
discusses how to blend more complex shapes such as Emoji
additionally presents how the glyps are cached into runtime dynamic texture atlas

wayback-archive

Jobs

Graphics Programmer
Remote Working (UK Based or Relocation)

Join nDreams Studio Orbital as a Graphics Programmer and be at the forefront of developing groundbreaking VR experiences that will captivate players for years to come.

As part of our remote team, you will collaborate with a diverse and innovative group, taking ownership of visual fidelity and rendering performance in Unreal Engine 5.

If you are passionate about pushing the boundaries of VR gaming technology and want to make your mark on the industry, apply now and be part of our exciting journey to redefine the future of VR!

Would you like to advertise your job openings here too? More information

Micro-Mesh Overview (Part 1)

the blog post provides a first high level overview of the micro-mesh technique
contains links to nvidia sources that discuss the technique in more detail

wayback-archive

Effective use of the new D3D12_HEAP_TYPE_GPU_UPLOAD flag

the article presents what ReBAR is and how it allows GPU resource to be directly CPU adressable
shows recommendations when and how to use the technique
addiotinally discusses hardware constraints, and how to validate the availbility

wayback-archive

Real-Time Neural Texture Upsampling in ‘God of War Ragnarök’

the presentation present a neural network approach used to upscale textures
shows an overview of BC7 block compression, explaining different modes available and tradeoffs
discusses the implementation of the network, preseting performance and quality

wayback-archive

[video] User Clip Planes // OpenGL Intermediate Series

the video tutorial presents how one can use clip planes to cut geomeetry along plane equations
presents the underlything math as well as how to implement the feature using OpenGL

Thanks to Hasen Judy for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 296 - July 16th, 2023

Sun, 16 Jul 2023 04:00:00 +0000

Raytraced order independent transparency

the articles continues the exploration into order independent transparency techniques
presents the performance and quality of a solution that uses ray tracing
discusses advantages, disadvantages and how it compares to other solutions

wayback-archive

[video] The Art of Linear Programming

the video tutorial provides a visual introduction into linear programming
explains how to represent problems in a geometric fashion and then presents how to use the simplex method to solve it
additionally presents how to solve linear problems using the pulp python package

Jobs

Principal Graphics Programmer
Hybrid Working – Farnborough (45 Minutes outside London)

Join nDreams, a world-leading VR game developer and publisher, as a Principal Graphics Programmer and be at the forefront of VR gaming innovation.

Apply now to join our team and shape the future of VR gaming!

Would you like to advertise your job openings here too? More information

Marching Cubes, Explained Using Marching Squares

the articles aims to provide an intuitive understanding of the marching cubes algorithmn
starts by explaining how to render a circle on a pixel grid
generalizing this method to marching square (the 2D equivalent) and expands it into 3D

wayback-archive

[video] It Takes Two, lava lamps, Raymarching in Godot 4.1

the video describes how to use raymarching to draw a lava lamp effect
shows how to represent spheres using SDFs and combine multiple shapes
implementation is done using Godot

High Performance Graphics 2023 papers on the web

collections of papers from the High Performance Graphics 2023 conference
contains the PDFs and where available also the video recordings
covers topics such as Acceleration Structures, Primitives, Surfaces & Appearance Modeling, Deep Learning for Graphics, Distributed & Cloud-Based Rendering as well as GPU Mesh Computing

wayback-archive

The AMD FidelityFX™ SDK 1.0 is now available on GPUOpen

AMD has released FidelityFX SDK that was announced during GDC 2023
the SDK provides a unified interface that aims to reduce the overhead of integrating AMD provides techniques into applications
added new Blur, depth of field and lens effects
additionally updated existing techniques for the new SDK and introduced improvements

wayback-archive

Jobs

Graphics Programmer
Remote Working (UK Based or Relocation)

Join nDreams Studio Orbital as a Graphics Programmer and be at the forefront of developing groundbreaking VR experiences that will captivate players for years to come.

As part of our remote team, you will collaborate with a diverse and innovative group, taking ownership of visual fidelity and rendering performance in Unreal Engine 5.

If you are passionate about pushing the boundaries of VR gaming technology and want to make your mark on the industry, apply now and be part of our exciting journey to redefine the future of VR!

Would you like to advertise your job openings here too? More information

Eurographics Symposium on Rendering 2023 papers on the web

collections of papers from the Eurographics Symposium on Rendering 2023 conference
covers topics in Ray Tracing, Neural Rendering, Spectral, NeRF, Materials, Scatter as well as Patterns & Shadows

wayback-archive

In-Game GPU Profiling for DirectX 12 Using SetBackgroundProcessingMode

the blog post presents how to use available D3D12 APIs to create stable applications for profiling purposes
shows that SetStablePowerState is only one part of the solution
the second part SetBackgroundProcessingMode and shows how it allows drivers to communicate back to the application to allow stable performance results

wayback-archive

Tile-based Lightweight Integer Compression in GPU

the paper introduces a tile-based decompression scheme aimed to allow data queries to operate in a single pass
provides an overview of compression schemes
shows how to combine delta decoding step and bit unpacking step into a single pass

wayback-archive

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 295 - July 9th, 2023

Sun, 09 Jul 2023 04:00:00 +0000

Intermediate Graphics Library (IGL)

Meta open-sourced their cross-platform library that provides a common graphics API abstraction
a couple of examples are provided that show how to use the API

wayback-archive

GPU 2D Drawing Part 2: Rectangle SDF. Masking. Rotations.

the blog post discusses signed distance fields (SDF) for rectangles as well as how to render borders and rounded corners
shows how to apply masking, transformations, and clipping of shapes and effects such as conversion into borders only and inversion
additionally shows how to combine multiple SDFs to create more diverse results with a limited number of base shapes

wayback-archive

Rain Effects Breakdown

the article provides a breakdown of how to implement a rain effect using Unity visual shaders
shows different types of implementation with varying levels of sophistication and implementation difficulty
simulates raindrops and rain streaks

wayback-archive

Skeletal animation in glTF

the article provides an overview of skeleton animation in-general and then presents how to parse the information from gLTF files
shows how to combine transforms, interpret hierarchical information and apply the data in vertex shaders

wayback-archive

[video] Windows Gaming On Mac: Game Porting Toolkit Tested! Cyberpunk, Hogwarts, Dead Space + More!

the Digital Foundry video provides an overview of the Apple Game Porting Toolkit
shows how the toolkit works with several recent AAA game releases
additionally presents how to setup the toolkit for use

[video] Skybox // Terrain Rendering episode #11

the video tutorial presents how to render a skybox using OpenGL
explains the theory of the technique and the implementation
covers considerations such as culling, rendering order, and positioning

[video] Building Roads Procedurally Using Unity's Spline Package

the video tutorial presents how to build a road network using a spline system
discusses how to extrude a road mesh from a spline and create junction meshes
presents how to calculate tiling UVs that follow the density of the bezier changes

Thanks to Neil Bickford for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 294 - July 2nd 2023

Sun, 02 Jul 2023 04:00:00 +0000

Debugging CUDA More Efficiently with NVIDIA Compute Sanitizer

This article discusses a code sanitizer in CUDA that is similar to one used in C++
The tool can detect race conditions, memory violations, uninitialized memory access, and thread synchronization issues.

wayback-archive

Behind the Pretty Frames: Diablo IV

the article provides an in-depth study of a Diablo IV frame rendering on PC
presents the different stages and passes of the frame
additionally contains a section of some technical ticks & tricks that were employed from art and programming

wayback-archive

An Approximate Mie Scattering Function for Fog and Cloud Rendering

The paper introduces a new method for representing scattering with varying particle sizes using uniform parameters
The method combines Henyey-Greenstein and Draine’s phase derivation
The paper provides an analytic evaluation of the method
The quality of the method is compared to other methods

wayback-archive

[video] Make Your Renders Unnecessarily Complicated

the video shows an humerous overview of what is required to model a camera, with functioning lenes, filters etc
shows the difficulties and complexities that camera’s following a real-world model face
finally shows a number of images that got generated using this method

Signed Distance Function (Field)

the article dicusses how to use signed distance functions to render a circle
show render a circle with antialiasing, drop-shadows, and edge borders.

wayback-archive

Neural Intersection Function

the paper introduces a replacement for bottom-level BVH traversal based on neural network techniques
presents performance and quality comparison
additionally also shows how the presented technique is view and scene dependent

wayback-archive

[pdf] Path tracing in Production - The Path of Water

the Siggraph 2023 course notes discuss the challenges faced related to water rendering on Avatar: The Path of water
gives an overview of the challenges faced, a solid foundational background for the underlying models
presents practical implementation strategies used
additionally presents several unsolved problems

wayback-archive

[video] Convolutions and adding random variables, visually explained

the video explains the concept of convolution functions/filters
starts with distinct distributions and generalizes from there into continuous functions
develops two separate ways to visualize the computations and show how they allow different questions to be answered more neatly

Thanks to atyuwen for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 293 - June 25th 2023

Sun, 25 Jun 2023 04:00:00 +0000

Real-Time Ray Tracing of Micro-Poly Geometry with Hierarchical Level of Detail

the paper introduces a method that enables micro-poly geometry for raytracing workloads
geometry is preprocessed, clusters formed and simplified into a compressed hierarchical level of detail representation
presents how using clusters enables fast BVH building
in the appendix discusses in detail how to select clusters to be guaranteed crack-free between different clusters

wayback-archive

D3D12 Work Graphs Preview

the blog post announces the first public release of a new D3D12 feature called Work Graphs
shows how this feature enables GPU shaders to spawn further GPU work from the GPU timeline
presents an overview of the spec
additionally, it discusses which samples are available at this time

wayback-archive

GPU Work Graphs in Microsoft DirectX® 12

the AMD guide provides a more in-depth look at the practical use of D3D12 Work Graphs
presents how to get started and the building blocks of the programming model
additionally, it presents a section on tips & tricks to help during the development (guides for tracking down issues, best practices, etc.)

wayback-archive

PIX 2306.21-preview: Work Graphs support

the blog post announces support for the new d3d12 work graphs feature in the preview version
shows the first level of debug support and discusses what is coming in the future

wayback-archive

From 0 to glTF with WebGPU: Rendering the Full glTF Scene

another part of the glTF rendering series
part focuses on how to interpret the scene hierarchy and flatten it for rendering

wayback-archive

[video] Let's Code a Realtime Fluid Simulation in Unity

the video tutorial presents a walkthrough on the integration of a real-time fluid simulation
shows how the physical model is translated into shader code
implementation is shown using Unity C# and shader code

Thanks to Erika for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 292 - June 18th, 2023

Sun, 18 Jun 2023 04:00:00 +0000

Task Graph Renderer at Activision

the talk discusses the design of the Task Graph architecture used by Activision
covers how to author tasks, design iterations, interactions with the memory allocation systems
additionally presents how it interacts with multi-threaded command recording

wayback-archive

Overview of Nitrous’ Decoupled Rendering Architecture

the presentation slides explain the improvements done to decoupled shading
discusses how decoupled shading enables improved visual stability
presents how the technique has been implemented by using Shadels that reduces the limitations of overshading of previous iterations of the technique
show how to generate a PrimiteID texture from rasterization as a replacement for position texture maps
additionally shows how the material system has been designed to enable utilization of the new shading method

wayback-archive

Real-Time Rendering of Glinty Appearances using Distributed Binomial Laws on Anisotropic Grids

the paper presents a new method to render glittery materials
introduces a new statistical method to calculate the number of glints for each pixel
source code and a Unity implementation demo are available

wayback-archive

Line Rendering Deep Overview - Part 1 - Extraction

the article presents an overview of line extraction techniques
discusses line theory and types
presents Screen-Space Extraction as well as Geometry-Based (Mesh Contours)
discusses limitations and considerations of each technique
additionally gives recommendations on when each technique should be used

wayback-archive

A note on Metal shader converter

the article presents a discussion of the limitations of metal hardware related to barriers across thread groups
also discusses the complexity of the current compute ecosystem across platforms

wayback-archive

Sampling Visible GGX Normals with Spherical Caps

the paper introduces a novel importance sampling algorithm for the GGX microfacet BRDF
presents an explanation of the method and how it compares to the Heitz method
code implementation is provided

wayback-archive

Thanks to Trevor Black for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 291 - June 11th 2023

Sun, 11 Jun 2023 04:00:00 +0000

Far Cry Dunia Engine Shader Pipeline - Long-term Vision & Lessons Learned

the presentation covers the development story of the Far Cry shader system
shows how over multiple games, the architecture was iteratively improved to solve the D3D12 transitions
focuses on how the PSO design was approached by making all PSO information known during build time
presents techniques to reduce PSO hitching by skipping draw calls, introducing optional variations, and allowing fallbacks

wayback-archive

Modern Mobile Rendering @ HypeHype

the talk covers how the author designed a new rendering architecture aimed at mobile hardware
presents how an iterative API Design was utilized
covering the resulting solution and reasons for the design decisions
much in-depth advice to consider for the best performance in different mobile GPUs

wayback-archive

Day Night Cycle using LUT in Fragment Shader of Materials

the article presents how a LUT (Look Up Table) can be used to apply a color transformation to convert a daytime scene into a nighttime
presents how to express a color transformation into a texture and how to apply it from a shader
discusses implementation considerations and how to reduce color banding

wayback-archive

CG Spotlight Slides - Screen Space Indirect Lighting with Visibility Bitmask

slides covering Screen Space Indirect Lighting with Visibility Bitmask
presents how bitmasks are used to track visibility along the visibility horizon
show how this allows you to handle objects with thickness better
additionally shows performance and image results

wayback-archive

Peeling back the varnish: The graphics of Diablo IV

the blog post covers a high-level overview of topics covering Diablo IV graphics techniques
discusses the guiding principles, the interaction with tech art
shows how HDR enables an improvement in visual quality
additionally provides an overview of resolution/refresh rates on consoles as well as graphics options

wayback-archive

Bring your game to Mac, Part 2: Compile your shaders

the presentation presents how to convert the D3D12 shader for use with metal
presents a shader converter tool that converts DXIL into metal shader IR
this tool also supports the conversion of tesselation shaders into mesh shaders
additionally presents performance pitfalls and advice to bind resources to the pipeline efficiently

wayback-archive

[video] OpenGL vs. Direct3D - Servan Keondjian & Casey Muratori

the 2-hour interview discusses the history of the development of Graphics APIs
discusses the origins of APIs, how OpenGl and Direct3D came to be
tradeoffs, design decisions, and many insights into the history of computer graphics

[video] I3D 2023 Keynote A Glimpse of Neural Rendering's Future by Marco Salvi

the keynote presents an overview of the state of the art in neural rendering
covering image reconstruction, texture compression, mesh simplification, and others
presents a look at what might be coming next in research and open areas for further development

Thanks to Marius Horga for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 290 - June 4th 2023

Sun, 04 Jun 2023 04:00:00 +0000

[video] An introduction to Shader Art Coding

the video tutorial explains shader programming aimed at newcomers
explains how to create digital art using shaders
showing the fundamental concepts, tools, and mathematics required along the way
the example is provided using shadertoy and portrayed from an empty shader to the final result

A Quickstart Guide to CUDA

the article provides a tutorial on how to use CUDA for beginners
presents how to set up a project and an overview of the basic programming model
additionally presents how to interop with OpenGL

wayback-archive

Stochastic Subsets for Bounding Volume Hierarchy (BVH) Construction

The paper presents a new approach for constructing Bounding Volume Hierarchies (BVH) by leveraging sampling techniques
the aim is to create higher quality BVHs to be maintained under real-time dynamic conditions and minimize the need for refitting
The presented approach involves ordering input primitives using a space-filling curve and building a Cumulative Distribution Function (CDF) for sampling

wayback-archive

GM Shaders Mini: Scaling

the tutorial provides common scaling, stretching, and centering patterns when using pixel and UV coordinates in shaders
explaining the process for newcomers and discussing common pitfalls

wayback-archive

Iterative 𝛼-(de)Blending: a Minimalist Deterministic Diffusion Model

the paper presents a rederivation of diffusion models with more straightforward concepts of mixing and de-mixing of images
previous models relied on advanced knowledge and practice of statistics such as Langevin diffusion or score matching

wayback-archive

[video] Where did my intersections go?

the short video presents how ray-sphere intersection points behave when expressed with imaginary numbers

[video] I3D 2023 Papers Session 4 - Ray Tracing

the video recording ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games 2023 for Ray Tracing has been released
the talks covered are the following:
- Subspace Culling for Ray-Box Intersection
- Performance Comparison of Bounding Volume Hierarchies for GPU Ray Tracing
- Accelerated Photon Mapping for Hardware-based Ray Tracing
- Importance-Based Ray Strategies for Dynamic Diffuse Global Illumination

Rendering Engine Architecture Conference - 2023

open, digital, and freely accessible conference covering many rendering engine architectures is happening on June 5th and 6th
talks from HypeHype, Activision, Ubisoft, Wētā Digital, and more
the talks cover modern mobile rendering, task graph architecture, decoupled rendering, shader pipeline, and much more

wayback-archive

Thanks to Vivitsu Maharaja for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 289 - May 28th 2023

Sun, 28 May 2023 04:00:00 +0000

[video] Frustum Culling // Terrain Rendering episode #9

the video tutorial explains two different techniques of frustum culling
presents how to implement culling in object and clip space
code implementation is provided for OpenGL

Khronos Osaka Dev Day Video and LunarG Presentation Slides Available

slides and videos from the Khronos Osaka Dev Day have been released
covers how to read and write SPIR-V, use the Vulkan Validation Effectively as well as what tools are available

wayback-archive

Deus Ex – Alpha Terrain

the article presents how the terrain in Deus Ex is quite different compared to other solutions
shows how the terrain uses translucent materials to blend between opaque objects and the terrain

wayback-archive

[video] [OpenGL Episode 25] Rotation Matrices (using glm)

the video shows how rotation matrices are defined in mathematics and glm + OpenGL
presents how to read a 4x4 matrix as columns matrices to understand the effect

[video] Halton Low-Discrepancy Sequence [Shaders Monthly #12]

the video explains the effect of the Halton Sequence compared to random and grid sampling
shows how to implement the Halton Sequence using GLSL
presents the practical effects when applied to image space lighting

Waterfall Shader Breakdown

the article explains how to create a stylized waterfall effect
shows how to integrate SDF objects to interact with the water flow

wayback-archive

Micro-Mesh Construction

the paper presents how to construct micro meshes from high-resolution triangle meshes
provides an overview of the micro-mesh data structure
discusses advantages and disadvantages of the mesh structure

wayback-archive

Thanks to Jon Greenberg for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 288 - May 21st 2023

Sun, 21 May 2023 04:00:00 +0000

Unit Gradient Fields: SDFs, UGFs, and their friends

the article provides a formal definition of a Unit Gradient Field
compares an SDF to a UGF and possible applications
presents a visual component to provide further insights

wayback-archive

Advanced API Performance: CPUs

the article presents CPU performance consideration for efficient usage of APIs
shows the importance of running the right workloads on separate threads

wayback-archive

Introducing Vulkan Ray Tracing Position Fetch Extension

the blog post describes a new Vulkan raytracing extension that allows the retrieval of positions from a hit shader
discusses how applications used to fetch position information manually and how this extension will simplify the logic

wayback-archive

[video] I3D 2023 Papers Session 1 - Neural Rendering and Image Warping

video recording for the first I3D conference paper session has been released
the three talks are Interactive Editing of Neural Radiance Fields, A Primitive for Animatable Neural Rendering with Interactive Speed as well as Metameric Inpainting for Image Warping
the Q&A for each talk is included as well

From 0 to glTF with WebGPU: Rendering the First glTF Mesh

the second part of the glTF mesh series covers how to interpret mesh data and render from WebGPU
covers the ASCII and binary format

wayback-archive

Shader Execution Reordering: Nvidia Tackles Divergence

the article presents the effect of Shader Execution Reordering (SER) on GPU performance
shows the effect on Cyberpunk 2077 and shows how improved coherence improves performance
presents how the extension is represented in the DXIL and changes the shaders

wayback-archive

Thanks to Sondre Kongsgård for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 287 - May 14th 2023

Sun, 14 May 2023 04:00:00 +0000

Introducing AMD Capsaicin Framework - our ARR Research Framework which includes our GI-1.0 sample

AMD released a new research framework aimed at the rapid development of multiple rendering implementations in parallel
The first release contains a GI implementation and a reference Path tracer

wayback-archive

A Rough Idea of How Photon Mapping Works

the article provides an overview of the Photon Mapping technique
discusses the issues with ray counts from ray and path tracing methods and how photon mapping aims to reduce the number of rays
developed to solve rendering caustics efficiently

wayback-archive

Stochastic Texture Filtering

the paper investigates and presents the quality and performance influence of stochastic texture filtering
stochastic texture filtering makes it possible to perform filtering outside of the lighting integral
this could allow for the adoption of higher-order texture magnification filters as the introduced noise can be removed with temporal filtering algorithms

wayback-archive

GPU Hang Exploration: Splitgate

the article provides a walkthrough of how to investigate a GPU hang found in Splitgate on Steam Deck
shows how to narrow down the issue using Vulkan validation, the AMD open-source drivers, and UE source code access
presents the complex interconnections of GPU systems

wayback-archive

[video] GDC 2023 - Two-Level Radiance Caching for Fast and Scalable Real-Time Global Illumination in Games

the GDC presentation present a GI solution that aims to cache radiance into a cache hierarchy
shows how the technique combines screen space probes with world space-level cells
presents the implementation, quality, performance as well as limitations of the technique

[video] The LOD Manager // Terrain Rendering episode #8

the video tutorial expands on the terrain rendering series by adding support for calculating LOD levels for each patch
shows how to implement the technique using OpenGL

Thanks to Jan-Harald Fredriksen for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 286 - May 7th 2023

Sun, 07 May 2023 04:00:00 +0000

RPS SDK Tutorial

AMD released an extensive tutorial on how to use the Render Pipeline Shaders SDK
broken down into multiple parts, it explains the basics to more advanced concepts
shows how to render a triangle, express more complex resource dependencies, as well as how to interact between the graph and host application
additionally shows how to take advantage of multithreading when recording commands

wayback-archive

Microfacet theory for non-uniform heightfields

the paper proposes a new method for the combination of rough surface NDFs
The presented techniques aim to accurately simulate multiple scattering from heightfields with height-dependent roughness and material properties
the solution is based on a layered-Smith microfacet model

wayback-archive

Real-Time Neural Appearance Models

The paper presents a new method to represent materials utilizing learned hierarchical textures combined with neural decoders
presents how to integrate the technique into real-time applications such as path tracers

wayback-archive

I want to talk about WebGPU

the article presents a history of graphics API and how WebGPU fits into the history
shows an overview of how WebGPU works
presents possible implementations for different programming languages and how to get started

wayback-archive

Advanced API Performance: Sampler Feedback

the guide contains best practices for using Sample Feedback on Nvidia hardware
shows what is expected to perform well, what is not supported, and possible edge cases to consider

wayback-archive

Vulkan Video Decoding

the article presents the video functionality that Vulkan exposes
discusses how to use the API and what pitfalls were encountered
as the Wicked Engine is open source, code and links to the necessary implementation are provided

wayback-archive

Unit Gradient Fields: What do we mean by offset?

the article presents an overview of Unit Gradient Fields (UGFs)
UGFs offer a generalization over SDFs, enabling a more expressive language for implicit modeling
this is only part one of a planned series on the topic

wayback-archive

Cyberpunk 2077’s Path Tracing Update

the article presents an in-depth look at the performance of the latest Cyberpunk 2077 update
shows how the hardware is utilized and what the bottlenecks are
additionally shows how RDNA2 and RDN3 workloads compare

wayback-archive

[video] Level Of Detail // Terrain Rendering episode #7

the video tutorial about rendering terrain using OpenGL continues by explaining how LODs can be implemented for the terrain system
covers how to create LODs and make sure the terrain doesn’t have any cracks

Thanks to Angel Ortiz for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 285 - April 30th 2023

Sun, 30 Apr 2023 04:00:00 +0000

Fine-grained backface culling

Article discusses implementing backface culling in mesh shaders
Compares the efficiency of three different methods: Cluster cone culling, precomputed visibility masks, and multi-cone culling
Presents performance numbers for each technique on different scenes

wayback-archive

Building a new graphics engine in Rust - Part 4

the article presents progress on a Rust-based home graphics engine project
focuses on the discussion of how to integrate resource management into the Rust memory model and GPU-driven rendering considerations
presents how to setup bindless rendering pipelines, implement frustum culling in compute shaders, and how to integrate with an ECS-based engine

wayback-archive

Radeon™ GPU Profiler 1.15 provides an enhanced ISA view experience and more

the article presents improvements done to the AMD GPU profiler
It primarily focuses on the shader/pipeline disassembly view improvement and has been updated to make it easier to navigate
but also mesh shader and Conservative Rasterization mode have been added to support

wayback-archive

[video] A neat realtime water caustics technique using partial derivatives in UE!

the video explains how to use partial derivatives in HLSL shaders to calculate the amount of light distortion to calculate refractions
presents the results and implementation using UE4

[video] A visual explanation for 3D transformation matrix multiplications

the video tutorial explains how matrices are combined
visually explains the operations by explaining how a robotic arm transformation is implemented
followed up by explaining how the multiplications are implemented mathematically but always visually explaining the relationships

the video explains how PVS (Potential Visibility Set) used by Quake is implemented
visually shows how the graph is constructed and what optimizations were applied to optimize the set further

Battlefront II: Layered Explosion

the article explains how star wars battlefront explosion VFX has been implemented
shows how flipbook textures are combined with LUT textures for recoloring as needed

wayback-archive

Cubic Interpolation of Quaternions

the article explains a series of Interpolation and shows how they build up to cubic Quaternion interpolation
covers Hermite Curve, Catmull-Rom Cubic, and finally, Quaternion Catmull-Rom Cubic Interpolation

wayback-archive

Thanks to Nathan Reed for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 284 - April 23rd, 2023

Sun, 23 Apr 2023 04:00:00 +0000

Symposium on Interactive 3D Graphics and Games 2023 papers on the web

a collection of papers from the I3D 2023 presentation
contains links to the papers and related material where available

wayback-archive

[video] Math in Game Development Summit: A Visual Guide to Quaternions and Dual Quaternions

the GDC talk explains how Quaternions and Dual Quaternions work and how they affect objects under transformation
starts by building an understanding of Quaternions, shows the advantages and limitations
followed by an extension to cover Dual Quaternions, explaining what problems they solve and how they compare to 4x4 transformation matrices

Advanced Graphics Summit: Realistic Real-Time Sky Dome Rendering in 'Gran Turismo 7'

the GDC presentation discusses the new sky rendering model developed for GT7
presents the physical foundations and how to simulate them in an offline rendering system
followed by how the sky method has been adjusted to be used in real-time through heavy use of LUT
discusses how to control the method through simplified parameters
additionally covers how they approached cloud rendering

wayback-archive

GM Shaders Mini: FXAA

the short tutorial presents how the FXAA algorithm is implemented
presents how the algorithm works in simple terms

wayback-archive

Simplifying Bézier paths

the article discusses techniques to calculate Bézier that use fewer segments than the existing original path
presents the importance of an error metric and discusses different available options

wayback-archive

MaterialX - Version 1.38.7

the latest version released from the Open MaterialX standards adds support for MaterialX Graph Editor and support for Metal shader generation
also adds support for coated emissive surfaces and bitangent input vectors

wayback-archive

The many ways of converting FP32 to FP16

the article presents several different methods to convert between 32 and 16-bit floating point formats
discusses the implementation, issues, and considerations with each technique

wayback-archive

Mipmap Generation

the tutorial explains how to use WebGPU to use compute shaders to calculate the MIP maps for textures
presents the implementation of a one MIP level at a time technique

wayback-archive

Contributing to Godot - Visual Shaders Nodes

the article presents how to introduce custom shader nodes into the Godot Visual shader graph
shows an example of how to color an object following the UVs

wayback-archive

New playground: integer.exposed

the article introduces two new interactive playgrounds for integer and floating point numbers
allows experimenting with how different numbers are encoded into the underlying bit patterns

wayback-archive

Thanks to Lesley Lai for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 283 - April 16th, 2023

Sun, 16 Apr 2023 04:00:00 +0000

[video] Advanced Graphics Summit: 'Marvel's Spider-Man' Remastered: A PC Postmortem

the talk discusses how the PC port approaches PSO management to reduce stutter and manage memory when the game was designed for unified memory
how they approached ray-tracing for parity with the PS5 implementation and what extension got added to improve the quality
detailed section on how to further debug GPU issues on PC and how to deal with super wide resolution rendering

wayback-archive

[video] Everyone can understand transformation matrices - and how it works

the video explains visually to read and understand 4x4 transformation matrixes
explains the basic of matrix/vector operations
presents how to combine the operations to allow rotations, scaling, and translations of objects using a visual approach

Half baked and a half: a small update

the blog post describes the approach of incrementally accumulating voxel data to augment the reprojection of the previous depth buffer
shows images of how the depth buffer develops over time and how small sub-voxels can help to improve the results

wayback-archive

Direct3D 12: Adventures in Shaderland

the article describes how Godot converts SPIR-V shaders to DXIL for D3D12
covers the old approaches (SPIRV-Cross) and why it was replaced with using Mesa’s NIR approach
discusses what SPIR-V Specialization constants are and how a patchable DXIL is created to allow the approach with D3D12

wayback-archive

[video] I3D 2023 Papers Preview

the video presents an overview of the papers that will be presented during the I3D 2023 in Bellevue
covering interactive Neural Radiance Fields, importance sampling for Dynamic Diffuse Global Illumination, real-time dune simulation, and many more

[video] Cyberpunk 2077 Ray Tracing: Overdrive Technology Preview on RTX 4090

the video presents the visual difference the overdrive (ReStir-based) raytracing implementation for Cyberpunk 2077 can achieve
compares against the prior ray tracing implementation and the maximum rasterization quality
shows cases where the mode makes a huge difference
additionally presents the performance influence of the mode

NVIDIA Displacement Micro-Map Toolkit

Nvidia released the Displacement Micro-Map Toolkit SDK
provided samples and documentation explaining the capability and how to use them from Vulkan
the technique allows the triangle to be sub-divided and displaced with a highly compressible format
this can be raytraced to add additional detail at lower costs

wayback-archive

From 0 to glTF with WebGPU: The First Triangle - Updated for Chrome 113 Release

the tutorial shows how to render a first triangle with WebGPU
this is using the final WebGPU spec as it is now publically available in Chrome

wayback-archive

Web3D Survey

the website collects information about the API and extension availability for Web-based usage
supports WebGL, WebGL2 and WebGPU

wayback-archive

Thanks to Robert Wallis for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 282 - April 9th, 2023

Sun, 09 Apr 2023 04:00:00 +0000

Matrix Compendium

the article provides a central place for matrix understanding for computer graphics
explains storage and multiplication order, how they are expressed in HLSL and GLSL
explains coordinate system handedness, what the left-hand/right-hand rules are
additionally presents some questions that help to detect conventions used if applications did not document their choices

wayback-archive

Random Sampling Experiments: Avoid The Sides!

the blog post shows different sampling strategies
presents the patterns along 1D lines, 2D squares as well as 2D circles

wayback-archive

Shader Tutorial: Color Correction

the tutorial explains how to apply color modifications in shaders
shows how to modify luminance, saturation, brightness, or contrast
implementation is provided using Unity shaders

[video] Stylized Grass and the many techniques available in UE to reach the desired style & performance

the long Video explains detailed how to render a Stylized grass
covers the art creation, shader logic, performance considerations
additionally covers how to apply movement, occlude parts if intersecting with the camera, LOD setup, and much more

Subspace Culling for Ray–Box Intersection

the paper proposes a new solution to accelerate AABB when used as BVH for objects that are thin and diagonal
the solution presented embeds a binary voxel data structure for each node and showed how to use these to reduce false positives
additionally presents how to use a LUT to compress the voxel data

wayback-archive

Efficient Spatial Resampling Using the PDF Similarity

the paper introduces a new rejection method based on the PDF shape similarity between pixels for single-bounce ReSTIR
this helps to reduce spatial resampling across shadow edges and material boundaries

World Space Path Resampling

the article presents an overview of ReSTIR/ReGIR, explaining similarities and differences between the techniques
shows how to set up reservoirs to allow spatial path reuse

wayback-archive

let's talk about normals

the article presents the difference between Object Normals, Tangent Normals as well as World Normals

Thanks to Max R.R. Collada for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 281 - April 2nd, 2023

Sun, 02 Apr 2023 04:00:00 +0000

Mesh Shaders and Meshlet Culling in Metal 3

the article presents an overview of use cases for mesh shaders
shows how to implement a mesh shader implementation that breaks down a mesh into parts and culls these
presents frustum culling and cone culling for a meshlet-based model

wayback-archive

You Can Use Vulkan Without Pipelines Today

the blog post introduces the VK_EXT_shader_object extension that allows Vulkan to be used without pipeline objects
instead, applications create shader objects for each stage (and optionally link these). All state setting is dynamic
the article describes performance expectations that drivers need to follow if they report the feature as supported
additionally describes how to test the feature on hardware today

wayback-archive

A Generalized Ray Formulation For Wave-Optics Rendering

the paper introduces a generalized ray concept into wave-optical light transport
presents how to use the generalized concept to apply path tracing sampling techniques to wave behavior modeling
shows how the technique compares in quality and performance to existing techniques

wayback-archive

Agility SDK 1.710.0-preview: GPU Upload Heaps and Non-normalized Sampling

the new D3D12 SDK adds support for CPU and GPU shared heaps on iGPUs and GPUs with re-bar support
additionally adds support for texel coordinate sampling

wayback-archive

GM Shaders Mini: Derivatives

the article explains what function derivatives are and how they are helpful in shaders
presents a couple of examples to show derivatives in action

wayback-archive

Practical Projective Geometric Algebra

slides of the GDC talking covering Geometric Algebra have been released
the presentation covers the building blocks of the algebra and how it connects to concepts from other algebras
shows how common operations and primitives can be represented using Geometric Algebra concepts

wayback-archive

[video] Coding Adventure: Ray Tracing

the detailed video tutorial shows how to implement raytracing applications
explains and implements concepts such as reflection, simple sky models, depth of field, lighting, and much more

PIX and ID3D12ManualWriteTrackingResource

the new API allows applications to disable the use of kernel WRITE_WATCH for CPU-visible GPU memory
applications promise to track access and inform pix explicitly instead of relying on the OF
this is required because of limitations in win10 and non-insider builds of windows 11 today that affect performance negatively

wayback-archive

Thanks to Adalberto Bruno for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 280 - March 26th, 2023

Sun, 26 Mar 2023 04:00:00 +0000

GDC 2023: Introducing the FidelityFX SDK with new technologies, an early look at FSR 3 + more!

AMD released the videos and slides from the sponsored session at GDC23
covers the new FidelityFX SDK, Real-time sparse distance fields for games, temporal upscaling as well as direct storage

wayback-archive

Real-time sparse distance fields for games

the presentation introduces the implementation of Brixelizer, an AMD real-time generator for sparse distance fields
discusses what sparse distance fields are, how they can be generated
followed by a discussion of how Brixelizer can be used to generate the necessary data

wayback-archive

Introduction to Spherical Gaussians

the article introduces Spherical Gaussians based on the Spherical Harmonics covered in the last part
presents how these two representations differ, strengths and weaknesses
additionally introduces Ambient Cube encoding for diffuse lighting

wayback-archive

DNND 2: Tensors and Convolution

the second article of the series continues uncovering how Deep Neural Networks are implemented
looking at aim to reconstruct the Intel Open Image Denoise open-source library
explains the concept of Tensors, Convolution, and how these concepts are combined to form Convolutional Neural Networks

wayback-archive

[video] Geomipmapping // Terrain Rendering episode #6

the terrain video tutorial series introduces a continuous level of detail for geometric details
explains the implementation of Geomipmapping, discussing the vertex number requirements and how to deal with edges between LODs
implementation with OpenGL is provided

Raytracing on AMD’s RDNA 2/3, and Nvidia’s Turing and Pascal

the article uses the AMD and Nvidia dev tools to take a look at how they approach the BVH building process
compares different hardware and presents performance comparisons
Hogwarts Legacy and Cyberpunk 2077 are used as examples

wayback-archive

Thanks to Angel Ortiz for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 279 - March 19th, 2023

Sun, 19 Mar 2023 04:00:00 +0000

Half baked: Dynamic Occlusion Culling

the blog post discusses designs and considerations for occlusion Culling techniques
lists limitations of existing techniques for fully dynamic worlds
discusses two prototypes covering screen-space depth reprojection as well as world space voxelization
presents weaknesses of the techniques, open issues, and next steps

wayback-archive

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

the article discusses the implementation of the GPUI library
shows how to derive SDFs for rectangles and how to apply drop shadows using separable blurs
additionally covers how font rendering is implemented by using the OS and GPU caching

wayback-archive

CPU->GPU data transfer - What is the best way to provide GPU the data inputs for each draw call on every API

the Twitter thread discusses different methods to upload per-draw call GPU data
presents how to use Metal, Vulkan, and WebGL 2.0
additionally presents pointers on how to apply it for D3D12

wayback-archive

Notes on FFTs: for users

the article presents different use cases of Fourier Transforms from a user perspective
explains what to use them for and how
presents strengths/weaknesses of the library design and how it affects the workloads

wayback-archive

[Video] Iridescent Bubble Shader - Advanced Materials - Episode 18

the video tutorial explains the effect of iridescence, why it happens, and how to replicate it
then uses the principles to implement a soap bubble shader using both Unity and Unreal
shader implementation is shown using the Visual Shader language

[Unreal] GameCube-Style Stencil Lights

the article discusses how to implement a lighting model as found in the Legend of Zelda: The Wind Waker
presents how to set up the blueprint as well as the shader logic required for the effect

wayback-archive

DNND 1: a Deep Neural Network Dive

the article discusses the basics of Convolutional Neural Networks
the series aim is to explore the denoising implementation of the Intel Open Image Denoise library

wayback-archive

Depth-only Screen Space Ambient Occlusion (SSAO) for Forward Renderers

the article shows how to implement SSAO using WebGL 2
provides a high-level overview of the steps required and how to implement these
discusses limitations of the technique as well as parts where forward and deferred shading paths would diverge

wayback-archive

Thanks to Joakim Dahl for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 278 - March 12th, 2023

Sun, 12 Mar 2023 04:00:00 +0000

Stylized Water Shader

the tutorial explains how to create a Stylized Water Shader using Unity from start to finish
show how to calculate water depth, apply underwater color, waves, foam shading, and more to create the effect
presents the results of the different effects and how to tweak them for the desired results

wayback-archive

Generalization of Adobe's Fresnel Model

the short paper presents an extension to the Adobe Standard Material model that allows specific reflectance at 90 degrees and the ability to control the interpolation exponent
discusses reflectance models limitations, evolutions, and proposed solutions

wayback-archive

Introduction to Spherical Harmonics

the article aims to provide an understanding of Spherical Harmonics without requiring advanced mathematics
develops the intuition from 2D cases before expanding into an extra dimension
additionally discusses why 3rd order Spherical harmonics are commonly used in computer graphics

wayback-archive

[video] Sharp Text Shader - Advanced Materials - Episode 18

the video tutorial shows how to create a text shader using signed distance fields and how to develop data for use with the effect
compares the result against a classical texture approach
implementation is shown using Unity and Unreal visual scripting

The Year of the Vulkan Book

the article discusses the author’s experience of writing “Mastering Graphics Programming with Vulkan”
explains the approach taken to concept development, lessons learned along the way and a look at what could be improved

wayback-archive

Vectors, Matrices & Matrix Order

the article discusses matrix and vector representation
shows the distinction between logical row vs. vector and the memory order
explains the effects of different layouts for multiplication order
additionally lists the pros/cons of different combinations

wayback-archive

Thanks to Jasper Bekkers for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 277 - March 6th, 2023

Sun, 05 Mar 2023 04:00:00 +0000

Float Compression 7: More Filtering Optimization

the article continues the series on float compression topics
presents how to optimize the process by redesigning the system to take advantage of SIMD instruction sets
shows how much of a performance difference the usage can make

wayback-archive

PIX 2303.02: You asked, we listened! A bumper PIX release

new release of PIX contains a vast list of new developments
some examples are RayGen debugging, the ability to show selected draw objects, pix capture diffs, improved memory allocation view, and much more

wayback-archive

Understanding Vulkan device buffer address alignment

the article explains the alignment requirements of buffer loads from VK_KHR_buffer_device_address
provides a walkthrough of the generated SPIR-V and explains why the issue occurs by explaining the spec requirements

wayback-archive

Real-time Cluster Path Tracing for Remote Rendering

the presentation covers a real-time cluster-based path-tracing renderer
discusses how the architecture was designed to allow linearly scaling with the number of GPUs

wayback-archive

[video] Simple Lighting in Defold - Screen Space Light Maps

the video tutorial presents a simple lighting model that uses sprites to define light effects
this is done by defining lights as one render target and combining it with the base world
implementation using Defold is presented (using GLSL shaders)

Vulkan all the way: Transitioning to a modern low-level graphics API in academia

the paper explains the experience of transitioning university classes to be taught using Vulkan instead of OpenGL
discusses difficulties and advantages encountered
shows how it affects student learning, grades, and project results

wayback-archive

[video] How to Improve Shader Performance by Resolving LDC Divergence

the video discusses the problem of non-uniform constant loads within a single wrap
shows how to use Nvidia NSight to identify the problem
discusses in detail how to correlate counters, latency, and instruction traces
using Structured Buffers instead of Constant Buffers will be able to resolve the problem once identified

CUDA LOD Generation

the paper presents how to use GPU-based techniques to implement LOD construction of point clouds
discusses the different implementation approaches’ impact on performance and quality

wayback-archive

[video] Lighting // Terrain Rendering episode #5

the latest part of the video tutorial discusses how to apply lighting to a terrain using OpenGL
discusses standard diffuse lighting and Slope Lighting
provides a high-level overview of each technique and discusses the implementation

Thanks to Matt Pharr for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 276 - February 26th, 2023

Sun, 26 Feb 2023 04:00:00 +0000

How to render it. Ten ideas to solve Computer Graphics problems.

the article presents an overview of 10 aspects to consider when approaching solving a computer graphics problem
discusses the importance of understanding the working space, data representation, as well as time constraints
presents how to take advantage of generic data science techniques (such as data visualization/exploration, Numerical optimization, …) to gain new insights
additionally shows how ground truth and Machine learning techniques can be combined to develop an intuition of the limits of a given solution

wayback-archive

Setting up a bindless rendering pipeline

the talk describes to setup a bindless rendering pipeline using Vulkan, D3D12, and HLSL shaders
shows how to set up the CPU side management to allow GPU side validation
describes the emulations required for Vulkan

wayback-archive

Reading Veach’s Thesis, Part 2

the article continues a series of understanding the Robust Monte Carlo Methods for Light Transport Simulation master thesis
this article focuses on the understanding of multiple-importance sampling
explains the insights required to better understand the balance heuristic especially

wayback-archive

Two-pass Gaussian blur coeffifients generator

the article provides a calculator that generates offsets and weights for a separable Gaussian blur filter
allows the specification of a couple of settings (radius, sigma, filtering mode, …) and generates GLSL code
explains the underlying logic and shows how to implement the filter in GLSL

wayback-archive

WebGPU Error Handling best practices

the article describes the error handling techniques that are available when using WebGPU
defaults will print detailed errors to the console, but developers can define scopes to collect information from the program and attach additional information to objects
additionally presents how to collect detailed information from shader compilation errors

wayback-archive

Vulkanised 2023

the official website collects the links to the videos and slides of the talks presented at the Vulkanised 2023 conference
not all talks have slides at this time

wayback-archive

An Open Letter to ARM / Mali: Please stop doing this

the article presents issues with the ARM/mali GPU device IDs and how they relate to GPU performance for game setting tweaking
shows how that reusing the same ID for multiple chips with large performance delta makes it challenging to identify capabilities correctly

wayback-archive

Thanks to Aras Pranckevicius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 275 - February 19th, 2023

Sun, 19 Feb 2023 04:00:00 +0000

Impressions from Vulkanised 2023 Conference

the author presents his impression from the Vulkanied conference
presents an overview of the topics covered, what discussions revealed during panel discussions, and what are common issues

wayback-archive

[video] Vulkanised 2023

the playlist of video recordings of the talks presented at the Vulkanised 2023 in Munich
covers a large number of topics such as Mesh Shader best practices, source-level shader debugging, performance optimizations
ranges from mobile and desktop to virtual reality

Teardown Teardown

the article presents a breakdown of how Teardown is being rendered
shows all stages of the pipeline required for the final frame
shows how the G-Buffer is drawn, how details are applied to the voxel
additionally presents how the weather effects, lighting, as well as denoising are implemented
additionally covers many more steps of the frame pipeline

wayback-archive

Swapping Colours

the article provides an overview of different techniques to adjust object colors from objects
shows how to implement the presented techniques using Unity visual shader language as well as in HLSL

wayback-archive

[video] Calculating Ray-Sphere Intersections

the video tutorial explains how to implement ray-sphere intersection testing
discusses the mathematic derivation of the technique
shows how to implement the intersection testing using GLSL in shadertoy

Fast Real-Time Shading for Polygonal Hair

the paper presents a technique to approximate hair lighted by an environment map, direct lighting, or a global illumination
build around the modeling of obstruction around each hair using spherical harmonics instead of requiring deep opacity maps

wayback-archive

Float Compression 6: Filtering Optimization

the blog post continues the series on float compression techniques
investigates how SIMD instruction sets can be used to optimize
presents how it affects the results

wayback-archive

[video] Parallax Occlusion Optimization - Advanced Materials - Episode 15

the video discusses the difference between Parallax Occlusion and normal mapping
presents how to optimize the implementation to adjust the steps only for cases where precision is required
implementation is shown in both Unity and Unreal

Thanks to Aras Pranckevicius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 274 - February 12th, 2023

Sun, 12 Feb 2023 04:00:00 +0000

Screen Space Indirect Lighting with Visibility Bitmask

the paper proposes an expansion of Horizon-based indirect illumination by using visibility bitmasks instead of horizon angles
stores (occluded / un-occluded) of N sectors uniformly distributed around the hemisphere slice instead
meant to improve results for thin surfaces

wayback-archive

Raymarching Clouds

the post provides a walkthrough of how to implement raymarching for volumetric clouds
provides an implementation using shadertoy
additionally discusses further issues and further steps

wayback-archive

GM Shaders Mini: Blendmodes

the short tutorial shows how to recreate photoshop blend modes using GLSL shader code
contains a link to a GLSL implementation of additional blend mode implementations

wayback-archive

A fast and precise triangle rasterizer

the article presents how to implement a software triangle rasterizer
discusses how to evaluate if pixels are inside a triangle
covers how to deal with edge cases, how to improve constant precision through the use of a fixed-point number representation
additionally presents performance optimizations

wayback-archive

Getting Started with Vulkan Compute Acceleration

the tutorial explains the basics of compute shader usage with Vulkan by implementing a compute-shader-based particle system
shows how to load compute shaders, bind resources and interact with graphics resources
additionally covers how the hardware executes compute shaders by explaining concepts such as workgroups and invocations

wayback-archive

Technically Art: Issue 138 (11.02.2023)

a collection of tech art tweets covering topics such as procedural modeling, volumetric motion blur, skin shader, VFX and visual shader WIP reports

wayback-archive

[video] Texturing // Terrain Rendering episode #4

the video tutorial explains how to apply textures to a terrain system
provides a recap of texture mapping techniques and how to apply textures based on the height of the terrain
expands upon the techniques to tile texture across the terrain
additionally shows how to use mipmapping and how it improves the quality of the results

Thanks to Wiktor Czosnowski for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 273 - February 5th, 2023

Sun, 05 Feb 2023 04:00:00 +0000

Float Compression 0: Intro

the start of a series of blog posts that explores the space of compressing floating point data
this post explains the source of the data and patterns of the underlying data
series compares a large number of techniques, compression solutions, and libraries

wayback-archive

GM Shaders Mini: Normal Maps

short tutorial explains the concept of normal maps and how it influences the lighting computations
shows how to interpret the meaning of the colors
additionally shows the importance of normal map orientation

wayback-archive

Shader Tutorial: Subsurface Scattering

the article explains how to create a shader in Unity that gives an object a subsurface scattering effect
shows what effect subsurface scattering has on the lighting model
presents how to integrate it into the standard surface shader

wayback-archive

Compute Shader thread index to 2D coordinate

the blog post explains how to convert a one-dimension threadIndex from compute shader into a 2D coordinate
shows how to use Quad-wide Shuffle Operations to reduce reliance on group-shared memory

wayback-archive

[video] Sand Shader - Advanced Materials - Episode 14

the video tutorial shows how to adjust Unity and Unreal Shading models to be more fitting for Sand rendering
shows how to adjust textures sources for efficient usage from shaders

WebGL / WebGPU Jan 2023 meetup highlights

the article presents a summary of what was discussed at the WebGL / WebGPU meetup
lists new extensions coming for WebGL and the state of WebGPU rollout
shows how the most significant obstacle for ThreeJS to adopt WebGPU is the requirement of WGSL shader language

wayback-archive

The Energy Distance as a Replacement for the Reconstruction Loss in Conditional GANs

the paper presents an alternative way to deal with the instability of generative adversarial networks (cGANs)
suggests replacing the reconstruction loss with the energy distance
paper contains a one-page summary of the technique

wayback-archive

PS2 Vector Unit Lighting on Shadowman2

the article presents a look back at the Shadowman game implementation for the PS2
describes how to implement and optimize the four-point light setup while staying within PS2 limitations

wayback-archive

Thanks to Top-OR for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 272 - January 29nd, 2023

Sun, 29 Jan 2023 04:00:00 +0000

Teardown Frame Teardown - Rendering analysis

the article presents a rendering analysis of the game Teardown
shows a look at video captures of the game to develop an intuition before diving into RenderDoc
shows that the game objects are drawn using a 3D Sprite concept
the game uses a volumetric shadow map that is updated from the CPU
additionally covers Lighting, Compositing as well as Post-Processing

wayback-archive

Accelerated Photon Mapping for Hardware-based Ray Tracing

the paper presents how to take advantage of ray tracing hardware for progressive photon mapper
shows how ray tracing–based collection outperforms hash-based GPU photon mapping algorithms
additionally introduces Photon Culling, a technique to reduce the number of photons stored per iteration

wayback-archive

Bringing Nanite to Fortnite Battle Royale in Chapter 4

the article explains updates required for Chapter 4 of Battle Royale
shows how increasing triangle counts of the mesh tented is better than masked materials and techniques to preserve vegetation density
discusses how to handle object animation and improve culling

wayback-archive

Introducing Compressonator v4.3

the new release introduces support for the Brotli-G lossless compression format
additionally adds support for RGBA_10101002, R8 and 16-Bit PNG File support

wayback-archive

[video] Image-based Lighting (IBL) of PBR Materials [Shaders Monthly #11]

the video presents how to implement image-based lighting of the Cook-Torrance microfacet BRDF
contains how to derive the Ground Truth Solution and shows how the Split Sum Approximation can simplify the equation
presents how to implement the required shaders using GLSL

Infinite Quadtrees – Fractal Coordinates

the article introduces the idea of expression quadtrees in terms of a collection of square grids
this allows the space to grow indefinitely as the used spaces change (movement or zooms)

wayback-archive

Learn WebGPU

the WIP guide covers how to use the WebGPU graphics API from C++
at this time, presents how to create a render a basic 3D mesh
additionally shows how to load and apply textures

wayback-archive

The LookAt Matrix

the article presents how to implement a camera look-at matrix
visually shows how the components combine to form the result
mentions the difference between rasterization and ray-tracing workloads

wayback-archive

Lumen brings real-time global illumination to Fortnite Battle Royale Chapter 4

the blog post describes what changes were required to make Lumen work in 60 FPS mode for the new season of Fortnite
discusses how a reverse lookup structure is used to accelerate per-mesh surface cache information for sharper reflections and lighting when using software ray tracing at low resolutions
shows how spatiotemporal blue noise was able to improve results from the same number of rays

wayback-archive

Virtual Shadow Maps in Fortnite Battle Royale Chapter 4

the article explains the issue that needed to be solved for Virtual Shadow Maps at 60fps
explains common issues that are often encountered when trying to cache sun shadow maps
additionally explains a collection of techniques required to improve performance and quality for the Fortnite art style

wayback-archive

Thanks to Bruno Opsenica for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 271 - January 22nd, 2023

Sun, 22 Jan 2023 04:00:00 +0000

[video] SIGGRAPH 2022 - Advances in Spatial Hashing

the video explains how Spatial hashing applies to storing sparse spatial data
presents how to extend the technique for cache coherence using view-dependent effects using world-space temporal filtering
additionally presents how to improve quality by using visibility-aware environment sampling

Fast, Near Lossless ‘Compression’ of Normal Floats

the article explains a method to compress 32-bit floats into 24-bits
shows how IEEE floats are defined and how to take advantage of conventions to further compress them for constrained ranges
HLSL and C++ code is provided

wayback-archive

High-Performance Graphics 2023 - Call for Participation

the High-Performance Graphics 2023 conference is open for submissions
the pages list topics covered and important dates for the submission

wayback-archive

Jobs

Graphics Engineer (m/f/x)
Darmstadt/Germany (partly remote possible)

YOU are looking to revolutionize the world of 3D in industrial environments and enjoy working in a highly innovative team?

Develop next-gen rendering technology, create high-performance pipelines and write complex real-time shaders. We are guaranteed to have interesting topics for YOU!

Would you like to advertise your job openings here too? More information

Announcing GFXReconstruct (v0.9.17) with DirectX®12 and DirectX® Raytracing support

the article announces that the GFXReconstruct now supports D3D12 (previously was Vulkan only)
explains how to use the tool to record D3D12 applications
additional shows workflows to reduce capture size and increase playback speed

wayback-archive

[video] Midpoint Displacement // Terrain Rendering episode 3

the video explains a second technique to generate terrains taken from the Focus on 3D Terrain Programming book
provides a high-level overview of the algorithms as well as an OpenGL implementation
additionally, details on how to deal with edge cases of the technique

Rotation with three shears

the article shows how to rotate a 2D sprite using 3 shear operations
discusses the properties and advantages of this method

wayback-archive

Thanks to Michael Hazani for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 270 - January 15th, 2023

Sun, 15 Jan 2023 04:00:00 +0000

AMD RDNA™ 3 Instruction Set Architecture (ISA) reference guide is now available

the new AMD hardware guide for RDNA3 has been released
covers the shader execution model, the various wave execution models
as well as how the shader core interacts with the memory hierarchy

wayback-archive

Approximate projected bounds

the article shows techniques implement conservative techniques to project bounding boxes and spheres into screen-space
these techniques are optimized for use in culling use cases as it affects the meaning of near-z clipping
presents trade-offs between the techniques in terms of computational cost and culling efficiency

wayback-archive

Use.GPU Goes Trad

the article describes how the Use.GPU level of abstraction is continuing to evolve
presents how scene management can be natively expressed as part of the same pass-based architecture
shows how the same high-level logic allows switching between deferred and forward rendering easily
additionally discusses strange limitations in the graphics APIs that make switching work between texture formats, pixel shaders, and compute shaders more difficult

wayback-archive

Jobs

Graphics Engineer (m/f/x)
Darmstadt/Germany (partly remote possible)

YOU are looking to revolutionize the world of 3D in industrial environments and enjoy working in a highly innovative team?

Develop next-gen rendering technology, create high-performance pipelines and write complex real-time shaders. We are guaranteed to have interesting topics for YOU!

Would you like to advertise your job openings here too? More information

Tangent Spaces and Diamond Encoding

the article provides an overview of Tangen Space Encodings
covers how to use Octahedral Encoding and further compress it with Tangent Angle
from there, develops the suggested Diamond Encoding technique that extends the Octahedral approach into the tangent angle space
additionally provides a brief section on rethinking how tangent space encoding might be better expressed on a mesh(let) level on modern hardware

wayback-archive

Optimize Your Graphics with RenderDoc Meta Fork

the article presents the Meta Quest exclusive features of the RenderDoc fork
the extensions allow the visualization of the tiled-based hardware binning into screen tiles and how they are executed
allows drawing call tracing to gather the latency of draw calls
additionally allows the collection of hardware statistics of shaders through KHR_pipeline_executable_properties

wayback-archive

An Introduction to Vulkan: A Full Day Tutorial

during the Vulkanised 2023 conference in Munich, a full-day tutorial will take place
this post explains the target audience of the course and the associated price

Water Wave Simulation

the article aims to develop an intuition for FFT (Fast Fourier Transform) and how it’s underlying the math of waves
provides a large number of interactive examples to experiment with the effects of different parameters
contains a high-level introduction to complex numbers and how they relate to rotation and scaling

wayback-archive

Random thoughts after moving from GLSL to HLSL

the author describes the personal experience with GLSL and HLSL gained through moving AnKi 3D between the shading languages
mentions why HLSL seems like a better bet for the long-term future
also mentions shortcomings of using HLSL when developing Vulkan applications

wayback-archive

Min/Max Buffer Precision Improvement

the blog post explains how to improve the precision when encoding min-max per tile
the author suggests storing only one as an absolute value and a delta to reconstruct the other

wayback-archive

How to accelerate AI applications on RDNA 3 using WMMA

the article covers how Wave Matrix Multiply Accumulate (WMMA)
presents how to use the intrinsics available in the HIP framework to accelerate the matrix operations typically found in machine learning work

wayback-archive

Thanks to Peter Kohaut for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 269 - January 8th, 2023

Sun, 08 Jan 2023 04:00:00 +0000

Practical Tips for Optimizing Ray Tracing

the article provides techniques to speedup raytracing workloads
discusses techniques to integrate “importance sampling” for dynamic objects that are off-screen but still contribute to effects
how to optimize shader table updates
additionally presents the idea of aligning TLAS boxes so that bounding boxes are aligned with the world axis

wayback-archive

Snowglobe

the article presents a breakdown of how a Snowglobe can be implemented using Unity
shows how to set up glass sphere refraction/reflections
additional covers on how to simulate the snow using particles

wayback-archive

Let’s talk about (GPU) crashes

the article presents a discussion of different sources of GPU hangs
shows techniques that can be used to track down the cause of hangs
techniques available in D3D12 and Vulkan that can be used to develop techniques to track down the source of the issue

wayback-archive

[pptx] Deep Dive into FidelityFX Super Resolution 2

the presentation contains a step-by-step walkthrough of the FSR implementation
shows how the API is structured and what updates have been made from FSR 2.0 to 21

wayback-archive

Updates in d3dx12.h: Nuget Packaging, Header Bloat Reduction, and D3DX12GetCopyableFootprints

a new version of the D3D Agility SDK has been released
includes the d3dx12 headers, and those have been split into separate headers so users can only include what they need
additionally, the implementation of GetCopyableFootprints has been open-sourced

wayback-archive

[video] Fault Formation // Terrain Rendering episode 2

the video shows how to implement a Fault Formation algorithm for a procedural terrain using OpenGL
additionally presents how a (Finite impulse response) FIR filter can be used to smooth the results
presents an overview of the filter, visualize the effects using Excel, and shows how to implement it using GLSL

[video] niagara: Culling optimization

another part of the Vulkan series that implement GPU culling
this part focuses on optimizations and cleanup tasks
presents the effects on the performance of the different techniques covered

Experimenting with fp16, part 2

the blog post continues the discussion of the effects of using 16-bit floating point values in the temporal resolve shader from the FidelityFX SSSR sample
looks into AMD hardware instruction generated by the compiler
shows how why the VGPR usage is so different
presents alternative ways to express the work and how it affects the generated code

wayback-archive

Requiem for piet-gpu-hal

the article discusses the reasoning why Vello (a GPU compute-centric 2D renderer) choose to transition to WebGPU
discusses the choices made during the implementation
looks at strengths and open issue
additionally provides a look at more advanced features and how WebGPU limits are affecting the project

wayback-archive

Thanks to Unai Landa for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 268 - January 1st, 2023

Sun, 01 Jan 2023 04:00:00 +0000

Experimenting with fp16 in shaders

The article discusses the use of 16-bit floating point numbers (fp16) in shaders
Using fp16 can reduce the memory and bandwidth requirements of a shader
The article presents the results of experiments and how it affects the generated code

wayback-archive

Improving color quantization heuristics

the article discusses techniques for improving color quantization algorithms
presents several heuristics for improving the quality of quantization
the article discusses the trade-offs involved in using different heuristics and provides examples of the results

wayback-archive

Implement MacOS Monterey screen saver in shadertoy(less than 100 lines of code)

the tutorial shows how to implement an effect that recreates the color and wave pattern of the screensaver found in macOS
presents how to create the different aspects using shadertoy and how to combine the effects

wayback-archive

Screen-space Variable Rate Shading in Unity with DirectX 12.

The article discusses screen-space variable rate shading (VRS), a technique that can improve performance
VRS allows the shading rate to be varied across the screen
code examples show how to use the technique from Unity

wayback-archive

Column Major and Row Major Vectors and Matrices (for games)

the article explains the difference between row-major and column-major matrices
discusses the relationship between matrix storage format, matrix layout, and operation order
presents that the choice of storage format can affect the performance of matrix operations

wayback-archive

[video] Hexagonal Tiling Explained!

The video explains how to create a hexagon using SDFs in shadertoy
expands the concepts to show how to tile the grid of hexagons
demonstrates how to expand on the concepts to create more complex shapes

Unity Mobile Game Performance Optimization: Balance between Graphics Performance and GPU Pressure

the article discusses strategies for optimizing the performance of mobile games in Unity
presents the importance of tradeoffs between quality and performance
shows techniques for improving performance, such as reducing draw calls, minimizing overdraw, and using batching and instancing

wayback-archive

Thanks to Leonardo Etcheverry for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 267 - December 25th, 2022

Sun, 25 Dec 2022 04:00:00 +0000

Two-Pass Occlusion Culling

the blog posts describes how Hierarchical Z-Buffer (HZB) Occlusion Culling uses a depth buffer to improve culling efficiency
describes two possible solutions that can be used to solve the problem that a depth buffer of the view is required to accelerate the rasterization of the same view
focuses on a technique that uses information about which objects have been visible in the previous frame to accelerate the current

wayback-archive

Ghost of Tsushima SIGGRAPH Talks

summary of two Siggraph talks by the author covering Ghost of Tsushima
the talks cover Lighting, Atmosphere, Tonemapping as well as PBR Shading in Ghost of Tsushima

wayback-archive

Some News About the 4th Edition of Physically Based Rendering

the post announces that the new edition of PBR will be released on March 28, 2023
chapter 11 - Volume Scattering and Chapter 14, Light Transport: Volume Rendering are available as PDF download already

wayback-archive

[video] niagara: Triangle culling

the stream covers the implementation and exploration of triangle culling into a GPU culling pipeline
discusses trade-offs of different techniques and locations in the pipeline
shows the effects of different culling techniques on the number of primitives that need rasterization

Path tracing workshop

Intel released a Path tracing workshop of 76 minutes of videos and ShaderToy exercises
shows how to implement a ray tracer, the path tracer
how to speed up the algorithms through the use of importance sampling

wayback-archive

rust-gpu v0.4

a new version of rust-GPU that allows Rust code to generate SPIR-V has been released
this release adds support for raytracing
additional contains many new APIs such as support for ByteAddressableBuffer or debug_printf

wayback-archive

[video] Coding a Bezier curve from scratch!

the video presents how to implement Bezier Interpolation
shows how curves are defined, visualizing how the factors are combined to create the final curve
all implementations are presented in ShaderToy

Introduction of the Raytracing Technology Part 2

the article continues the series by covering an overview of raytracing techniques
covers the Path Tracing Equations, Direct Lighting (single and multiple lights), Indirect Illumination
Additionally covers high-level approaches such as Bidirectional Path Tracing and Metropolis Ray Tracing

wayback-archive

Meshlet sizing theory

the article presents metrics to calculate to judge the optimal size for meshlets
compares the AMD and Nvidia limits to see how they might affect the choices

wayback-archive

[video] Compute Shaders in Bevy

the video presents how to integrate a compute shader into the Rust-based bevy engine
shows how to integrate the compute pass into the render graph system
additionally shows how to read back simulation results back to the CPU

Deferred Shading

the article provides an explanation of deferred shading
discusses the issues with forward shading and how deferred shading can solve them
shows how deferred shading can be implemented, including techniques to reduce memory and bandwidth usage for the technique

wayback-archive

Stream compaction using wave intrinsics

the article presents how to use wave intrinsics to reduce the number of atomic operations required when compacting sparse arrays into packed arrays
presented technique is based on FidelityFX’s SSSR implementation

wayback-archive

Thanks to Vivitsu Maharaja for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 266 - December 18th, 2022

Sun, 18 Dec 2022 04:00:00 +0000

Introducing AMD Render Pipeline Shaders SDK

This article provides an overview of the Render Pipeline SDK design and implementation
it shows how the SDK can reduce the complexity of render graph implementations
presents that it’s able to manage resource barriers and transient memory
additionally presents a demonstration of the performance effects that could be observed from real game workloads
video version is available

wayback-archive

Introduction of the Raytracing Technology Part 1

the article provides an overview and history of raytracing
it covers different styles of raytracing, common elements
additionally provides a brief on how different phenomena can be simulated

wayback-archive

[video] Heightmaps // Terrain Rendering episode 1

the video is the start of a new video series to render a height map using OpenGL
shows how to load and render a terrain from a textural heightmap

[video] World Normal Mix Shader in Godot

the video tutorial shows how to implement a shader in Godot that mixes two textures into a single material based on the normal directions of the mesh
explains all the necessary vector space transformations, how to unpack normals as well as combine normals

[video] CUDA 12 New Features and Beyond

the video discusses new features in Cuda 12 and a look at future developemnts
covering Dynamic Parallelism (GPU side task launching), lazy loading to reduce load time and memory usage
additionally covers updates to the CUDA compiler, math library updates as well as compability updates

GM Shaders Mini: Fluids

the article presents a technique to improve the look of a particle based fluid system
uses Metaballs to more smoothly blend the particles together as well as simple Refraction model
implementation is provided in GLSL for Game Maker

wayback-archive

Bringing Nvidia® and AMD support to oneAPI

the article explains how the oneAPI API can be used to target intel, nvidia and AMD GPUs
presents a high level explanation of the technical implementation and goals for the future

wayback-archive

Thanks to Jon Greenberg for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 265 - December 11th, 2022

Sun, 11 Dec 2022 04:00:00 +0000

Resolving Long Standing Issues with Vulkan Windowing System Integration (WSI)

the blog post explains two new extensions that have been added to Vulkan to improve interaction with windowing systems
applications can now better be sure when to release swap chains, clean up the deletion flow as well as added additional flags to open the opportunity for driver optimizations during swap chain resize operations

wayback-archive

Understanding The Math Behind ReStir DI

the in-depth article explains the mathematics behind the original ReStir and an in-depth analysis of why it works
covers the preliminary knowledge required (Multiple)Importance Sampling, Sample Importance Resampling (SIR), Resampled Importance Sampling (RIS) as well, as Weighted Reservoir Sampling (WRS))
uses the information to develop a mental framework for understanding ReStir (Reservoir Spatio-Temporal Importance Resampling), how it works and why it’s an unbiased technique

wayback-archive

UE5.1 - New shading models and changing the GBuffer

the article presents how to integrate a custom toon shading model into UE5.1
explains the necessary C++ modifications and shader work to integrate it
presents the complexity and limitations connected to the integration

wayback-archive

[video] Live Coding: 3d Truchet Weave

the video presents a walkthrough of how to replicate a Truchet Weave pattern using ShaderToy
covering how to define an SDF for a Grid, Truchet, or Weave pattern and combine everything for the final result

Fast CDF generation on the GPU for light picking

the blog post explains how to build a cumulative distribution function (CDF) to accelerate the sampling of lights in a real-time ray tracer
explains the high-level concept of a CDF and shows how to implement this on the GPU
presents how to optimize the implementation to better take advantage of GPU hardware and utilize wave instructions for further optimizations

wayback-archive

[video] The Continuity of Splines

the detailed video explains splines and concepts derived/extended from these
covering Bézier Curves and Bézier Splines, explaining the underlying mathematics and concepts
provides an in-depth explanation of the concepts of continuity, yet again in a large number of contexts
with this information, the video dives deeper into extended concepts such as Hermite Spline, B-Spline, NURBS, and color splines (to name a few)

Area Lights

the tutorial explains how to implement area lighting using OpenGL
implements the “Linearly Transformed Cosines” technique as published originally in 2016

wayback-archive

[video] Shader Code and Maths to Node Graphs

the presentation focuses on how to approach the implementation of abstract code/math expressions to make it easier to work with
presents the importance of breaking down more complex expressions into sub-expression and visualizing individual components
shows the approaches by implementing randomized water puddle placement, a Gerstner Waves simulation, as well as using flow maps to displace water around obstacles

ECCV 2022 Tutorial - Neural Volumetric Rendering for Computer Vision

slides and videos for the Neural Volumetric Rendering for Computer Vision have been released
covering the fundamentals of Neural Radiance Fields (NeRFs), how to apply them to Volumetric data sources
additional presents existing challenges as well as a brief walkthrough of a NeRFs workflow

wayback-archive

Behind the Pretty Frames: Death Stranding

the article provides a detailed look into a frame breakdown from the Decima engine-powered Death Stranding
shows how the frame is rendered in a large number of compute passes, showing what resources are used in each pass and how it’s combined
includes an overview of a large number of post-processing effects and how they appear to be implemented and combined to create the desired look

wayback-archive

Thanks to Graham Wihlidal for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 264 - December 4th, 2022

Sun, 04 Dec 2022 04:00:00 +0000

MIPNet: Neural Normal-to-Anisotropic-Roughness MIP Mapping

the paper presents a new method to calculate texture MIP maps that preserves compatibility with existing MIP mapping techniques
the technique uses neural networks to optimize the transfer of material appearance under varying view distances and lighting conditions
presents the results on two distinct BRDF models (Anisotropic GGX and Anisotropic Beckmann)

wayback-archive

[video] How Big Budget AAA Games Render Clouds

the video provides a summary of the cloud rendering techniques covered in Horizon: Zero Dawn and the FrostBite engine papers
shows the individual components visually and how they are combined to create the final cloud effect
a brief discussion of performance optimization possibilities

Studying 'Spectral Primary Decomposition'

the article continues the series on spectral rendering
this part focuses on methods to “upsample” sRGB colors to spectral representations
presents an implementation of Spectral Primary Decomposition for Rendering with sRGB Reflectance and discusses possible improvements

wayback-archive

[video] I Made a Game Entirely Within a Shader (almost) | Game Dev Challenge

the video presents how the author developed a pong game using only a pixel shader in Unity
shows how to use the alpha channel of the render target to store persistent state

[video] How I Made The World with SINE

the video focuses on the definition of a procedural terrain from a vertex shader
presents how to combine different noises and rotate patterns to create a planet

[video] [Episode 23] From Local to World Space (Model Matrix Transformation)

the video is the latest part of an OpenGL learning series that focuses on the explanation of vertex data transformation
explains the concepts of space transformations, focusing on how to change object positions in the world through the use of a world matrix
shows how to pass information from the C++ runtime to the OpenGL shaders

Shaders Explained: Dithering

the article explains how two implements two different types of dithering in metal shaders
presents and compares ordered and diffusion dithering algorithms

wayback-archive

[video] Why Did Link's Cel Shading Disappear?

the video does a deep dive into deferred shading techniques to explain why a graphical artifact in Zelda’s Breath of the Wild appears in a specific place
starting with a discussion of lighting techniques
shows how the scenes are rendered, what intermediate information is stored, and how it’s used for light calculations (including many visualizations)
finally, it concludes by showing how the error happened and why it’s localized to specific locations in the world

Announcing ComputeSharp 2.0 — run C# on the GPU with ease through DirectX 12 and D2D1!

the article presents the library that allows C# code to be executed via HLSL, D2D1, XAML, and more
shows the developer experience, explaining how the code is transformed for GPU execution
presents the two execution models that showcase performance vs. ease of use

wayback-archive

Thanks to Jan-Harald Fredriksen for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 263 - November 27th, 2022

Sun, 27 Nov 2022 04:00:00 +0000

VK_EXT_descriptor_buffer

discusses issues with the current Vulkan binding model
presents how the new descriptor buffer extension allows decoupling draw calls from the descriptor binding
presents how it helps with the D3D12 layer and can solve common issues with the current binding model
it additionally covers how this extension also allows GPU timeline descriptor copying

wayback-archive

How to make Sage's ice wall ability from Valorant

the tutorial explains how to create an ice wall VFX inspired from the game Valorant in Godot
covers the code setup, art asset creation as well as shader authoring

wayback-archive

Jobs

3D Tools Engineer
Remote Work

Marmoset, developer of the real-time rendering software, Marmoset Toolbag, is looking for an experienced developer to help build bigger and better software tools for 3D artists.

The responsibilities of a Tools Engineer on the Marmoset team will focus on technical design and implementation of UI systems, and refining the user experience for new and existing workflows in 3D art production.

Would you like to advertise your job openings here too? More information

Technically Art: Issue 135 (25.11.2022)

contains a collection of tweets covering procedural texturing with MaterialX, shader VFX examples
WIP and prototype effects, as well as VFX breakdowns

wayback-archive

[video] Car Paint Shader - Advanced Materials - Episode 9

the video tutorial presents several techniques for creating a car paint shader
covers base coloring, the addition of sparkles, as well as a clear-coat layer
additionally presents how to implement a carbon fiber material
implementation is shown in Unity and Unreal visual shader authoring

Shader Reflection using the DirectX Shader Compiler

the article presents how to use the DXC library to compile and gather information from compiled D3D12 shaders
shows how to use the API to generate root signatures

wayback-archive

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

Double Fine Productions is looking for a full time graphics programmer to join its San Francisco based development studio. Having recently shipped the award winning Psychonauts 2, we are looking to expand our graphics and systems programming team to support the development of our future titles.

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Applicants should have a strong preference for working in a highly creative, innovative, and nimble development environment, where collaborating with design, audio, art, animation, tech, and other disciplines is standard.

Would you like to advertise your job openings here too? More information

Brotli-G: An open-source compression/decompression standard for digital assets that is compatible with GPU hardware

AMD introduces a GPU-compatible implementation of the Brotli lossless compression algorithm
the SDK provides a CPU compressor and a compute shader implementation of the decompressor
code is released as open-source using the MIT license

wayback-archive

Introduction of the ASTC Texture Compression

the article provides an overview of the different ASTC Texture Compression formats available
shows the quality and file size that can be expected for gradients, normal maps, as well as facial albedo textures

wayback-archive

Thanks to Sondre Kongsgård for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 262 - November 20th, 2022

Sun, 20 Nov 2022 04:00:00 +0000

[video] But what is a convolution?

the video provides a great visual explanation of convolution filters
starting with random number examples, expanding to image progressing filters such as blurring and sharpening
additionally provides more details on methods to compute large convolution filters more quickly

Spherical Elevation Adjusting Arbitrary Normals

the article explains how to offset normals along spheres so that displacement doesn’t cause self-intersections
additionally shows how to adjust the normas/tangents to match the displaced normals

wayback-archive

Radeon™ Raytracing Analyzer source code available + meet amdrdf

the AMD Radeon Raytracing Analyzer has been open-sourced
it allows for visualization and inspection of Bounding Volume Hierarchies

wayback-archive

Jobs

3D Tools Engineer
Remote Work

Marmoset, developer of the real-time rendering software, Marmoset Toolbag, is looking for an experienced developer to help build bigger and better software tools for 3D artists.

Would you like to advertise your job openings here too? More information

Agility SDK 1.608.0: Enhanced Barriers and more

new agility SDK release contains Enhanced Barriers (no longer in preview SDK, removing the need for developer mode)
the Depth Bias and Index Buffer Strip Cut Value can now be changed after a pipeline has been set

wayback-archive

VK_EXT_descriptor_buffer

new Vulkan proposal outlines improvements to the management of descriptor memory
to allow descriptors to be treated more explicitly and managed alongside other buffer objects
shows how a form of GPU descriptor updates can be enabled

wayback-archive

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

[video] GCAP22 Highlights: Expert Level Debugging

the presentation provides an overview of x64 assembly
uses the presented information to show how to debug a stack corruption issue

AMD lab notes

the series of blog posts aimed to share the lessons learned from tuning applications for AMD GPUs
at this time, covering the Laplacian Finite Difference Method

wayback-archive

Decompiling Nvidia shaders, and optimizing

the article presents how to decompile NVidia OpenGL and Vulkan shader
shows which tools are required to unpack the Nvidia caches and remap to the source shader names
presented steps are Linux, but windows should follow similar procedures
additionally, it presents a couple of examples of optimizations and their effect on the generated assembly

wayback-archive

Technically Art: Issue 134 (18.11.2022)

a collection of tweets covering a flood filling, VFX breakdowns, unit shader books
blender geometry nodes and work-in-progress game showcases

wayback-archive

Thanks to Michael Hazani for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 261 - November 13th, 2022

Sun, 13 Nov 2022 04:00:00 +0000

[video] Metal Shader - Advanced Materials - Episode 7

the video tutorial explains how to create a metal material
explains the effect of the metallic parameter, metal reflectance values as well as specular reflection
shows the implementation with both Unity and Unreal Engine

BC1 Compression Revisited

the article describes how to compress high-quality BC1 images efficiently
explains how the compression space is optimized
in-depth explanation of the vectorization process and how to efficiently use SSE, AVX, … to optimize the implementation

wayback-archive

Accelerating Load Times for DirectX Games and Apps with GDeflate for DirectStorage

the article presents an overview of GPU-based GDeflate compression
shows the influence of staging buffer size on compression speed
list several best practice recommendations

wayback-archive

Graphics API secrets: format casting

the article presents the API rules for casting between texture formats in both Vulkan and D3D12
discussing sRGB, BC(Block Compression), Depth and generic color format rules
additionally, it shows Sparse/Tiled resources can be used to alias textures

wayback-archive

Jobs

3D Tools Engineer
Remote Work

Marmoset, developer of the real-time rendering software, Marmoset Toolbag, is looking for an experienced developer to help build bigger and better software tools for 3D artists.

Would you like to advertise your job openings here too? More information

GPU submission strategies

the presentation shows how submitting/recording commands lists from the API to the GPU affects performance
shows how to use GPU View and Radeon GPU Profiler to understand the execution behavior
presents different strategies and how they differ
additionally presents insights into the driver behavior by discussing the Open Source Linux driver behavior

wayback-archive

Implicit half edges

the presentation explains what Half edges data structure is
discusses use cases and issues
presents how to overcome some of the issues by using an Implicit half edges structure

wayback-archive

Triplanar, Dithered Triplanar, and Biplanar Mapping in Unreal

the article provides an overview of the implementation of three different techniques for procedural texture mapping (Triplanar, Dithered Triplanar, and Biplanar Mapping)
implementation is provided in UE5 visual shader code
explains the trade-offs of the different solutions

wayback-archive

[video] Physically Based Rendering // Intermediate OpenGL Series

the video provides an overview of a Physically Based shading model
discusses the Cook-Torrance BRDF model, Schlick GGX, and Fresnel
provides both the theoretical overview as well as the GLSL shader code implementation of the presented technique

Bindless rendering — validation

the blog post describes the design of a validation system for bindless shader resource access
shows how the shader code is protected against invalid resource usage
presents how shaders can report failures back to the CPU to be able to inform the user about the error

wayback-archive

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

[video] SIGGRAPH 2022 Real-Time Live!

recording of the Siggraph showcase of original, interactive projects of the year
includes Horizon Forbidden West, Unity-based machine learning character posing, hybrid VR, desktop sculpting, the cavern UE5 demo from the coalition, Unity Digitial Humans facial capture system, and much more

Nubis, Evolved: Real-Time Volumetric Clouds for Skies, Environments, and VFX

the slides for the Real-Time Volumetric Clouds of Horizon Zero West from SIGGRAPH have been released
covers the cloud modeling, authoring, and improved lighting implementation
additionally covers optimizations and presents performance numbers

wayback-archive

[video] Deferred Lights - Pixel Renderer Devlog #1

the video explains the implementation of a 2D deferred shading system
shows a breakdown of the individual steps of the lighting pipeline
presents how to render shadows using a stencil-based shadow approach
shows how to generate shadow mask extension meshes, update stencil buffers and deal with shadows overlapping multiple objects

GM Shaders Mini: Noise 2

the article explains how to generate Worley, Voronoi, and fractal noise in a GLSLS shader
ShaderToy example is provided

wayback-archive

Thanks to Jonathan Tinkham for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 260 - November 6th, 2022

Sun, 06 Nov 2022 04:00:00 +0000

[video] Global Lecture with Ed Catmull - The Wild, Unexpected, Exponential Ride Through Computer Graphics

the lecture presents an overview of computer-graphics technology of the last 50 years as experienced by Ed Catmull
shows how individual developments combine over time and cause the speed of innovation to accelerate
contains a large number of anecdotes about the history of computer-graphics

GM Shaders Mini: Noise

the tutorial covers how to generate different noise type in shaders
covers a basic hash function, value noise as well as perlin noise
shader code is provided in ShaderToy

wayback-archive

[video] Shader Sauce: How to Use Shaders to Create Stylized VFX

the video talk introduces a collection of fundamental shader concepts and tricks aimed at the creation of VFX
some tricks covered are UV distortion, Masks, LUTs & Gradient Mapping, Debugging advice, and much more
code examples are provided in Unreal Engine 4

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

Vector text rendering in Unreal Engine

the article covers how to extend UE4 with a custom vertex format and shading pass
the provided example code is meant to replicate the logic required to implement the Slug text rendering library

wayback-archive

[video] Investigating and Dispelling Shader Myths... with Science!

the talk presents a set of common misconceptions about shader code patterns
shows what instructions are generated and how these patterns affect performance
examples are provided using UE 5.1 custom shader nodes
talking about multiply vs. divide, packing floats, use of Lut’s vs. Math, as well as the effect of exponential powers

Write your first GPU Kernel using Metal

the tutorial explains the basic steps required to execute a metal compute shader kernel
shows how to initialize the metal library, upload buffers, compile shaders and execute compute-shaders

wayback-archive

Unreal Engine Game Optimization on a Budget

the presentation provides an overview of essential concepts when optimizing an Unreal Engine game
explains the foundational settings that are required for correct profiling
covers how rendering performance can be optimized
touches on culling, draw distances, occlusion queries, shadow proxies
additionally provides a valuable list of debug commands

wayback-archive

Thanks to Jonathan Tinkham for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 259 - October 30th, 2022

Sun, 30 Oct 2022 04:00:00 +0000

MeshTaichi: A Compiler for Efficient Mesh-based Operations (SIGGRAPH Asia 2022)

the paper presents a mesh computation compiler that separates mesh operations from the data partitioning
the system partitions meshes into sub-patches and reorganize mesh data so that attributes can be accessed from local on-chip memory
presents performance results and compares against RXmesh, another system that tries to optimize mesh access patterns

wayback-archive

[video] ICC Colour Profiles, AdobeRGB & sRGB, and "Colour Management" on Windows. The Nightmare Part 1

the video shows the importance of color profiles
presents how in the absence of profiles, applications are free to interpret the results
shows how the most reliable way to get consistent results across applications is to convert from authoring color space into sRGB
additionally shows how to inspect color profiles

Jobs

3D Engineer
Darmstadt/Germany (remote possible)

As a 3D Engineer at Threedy, you develop our core system’s algorithms and data structures, always optimizing data representations for efficient and cutting-edge 3D data streaming and visual computing.

Would you like to advertise your job openings here too? More information

[video] Intel’s New AI: Amazing Ray Tracing Results!

the video presents a new upsampling technique developed by intel (Temporally Stable Real-Time Joint Neural Denoising and Supersampling)
presents a comparison against previous techniques
shows that the technique can significantly improve denoising and also upscale the image to higher output resolutions

Shader Tutorial: Enter The Matrix

the tutorial presents how to rotate a texture in 2D space
explains rotation matrices, how to rotate around different positions of the plane
additionally presents the necessary steps to integrate into Unity for demonstration

wayback-archive

Low Discrepancy Color Sequences

the article describes a possible solution to generate a color palette with neighboring colors being most different from each other
presents issues with some possible solutions
it additionally presents ideas about weaknesses of the offered solution and possible improvements

wayback-archive

Thanks to Marius Horga for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 258 - October 23rd, 2022

Sun, 23 Oct 2022 04:00:00 +0000

Performance Comparison of Bounding Volume Hierarchies for GPU Ray Tracing

the paper presents a comparison of a large number of methods for the construction of BVHs for ray tracing workloads
concludes by making suggestions for future technological developments that appear to offer the most potential at the time of writing

FSR 2.1 UE plugin enhancements part 1: Intro & improving foliage appearance using the base pass

the 5 part series provides a walkthrough of common issues when using the FSR 2.0 upscaler in Unreal Engine Projects
discusses why the issues occur, what solutions are available and how FSR 2.1 was improved to deal with the issues

binary search for sdfs - 2018, 2022

the article presents the story of how the author experimented with binary search in a shader for accelerating SDF tracing workloads
shows how to implement a stackless GPU-based traversal
presents why the binary search is unable to outperform the SDF raymarching loop

Godot SDFGI - Solving the accessible Global Illumination problem in Godot

the slides discussing the new GI solution implemented for Godot
the talk will happen on Friday, 28th twitter DM for signup
discusses how the technique is based on sphere tracing distance fields
how to generate the distance fields, trace lights
additionally spends a large chunk of the presentation on optimizations to make the technique viable

Jobs

3D Engineer
Darmstadt/Germany (remote possible)

Would you like to advertise your job openings here too? More information

Opening HLSL Planning

the blog post announces that a new, more open model for HLSL language development
discusses what feature will be able to be discussed in public and how the process will work

SIGGRAPH Asia 2022 papers on the web

a collection of papers from SIGGRAPH Asia 2022
the list is updated every couple of days at this time

Snowy Rock Shader - Advanced Materials - Episode 4

the video shader tutorial series covers how to create a shader that allows procedural rock shading with snow support
previous tutorials covered how to create the individual pieces, and those are combined in this part
video shows the implementation in both Unreal and Unity visual shader authoring

GI-1.0: A Fast Scalable Two-Level Radiance Caching Scheme for Real-Time Global Illumination

the AMD paper presents the findings for a new dynamic GI solution
proposes the separation into a screen and world space cache that complement each other with additional information
provides a detailed description of the individual steps, performance results as well as known limitations

stanford - Computer Science cheatsheets

a collection of cheatsheets on the high-level concepts of topics such as AI, machine learning, and statistics

Ray Tracing: How NVIDIA Solved the Impossible!

the video presents a history of light transport algorithms development
shows a breakdown of each technique and improvements in each iteration

Emulating Double Precision on the GPU to Render Large Worlds

the article presents that the Godot engine supports compilation in double-precision mode
shows how to emulate double precision calculation on GPUs that don’t support double by using two floats
presents what limitations still exist with this solution

My mesh shaders talk at XDC 2022

the blog post provides the text version of the mesh shader talk presented
the presentation covers the issues with the classic graphics pipeline and how mesh shaders can address these
presents how mesh shaders are authored, limitations, and hardware preference differences

Thanks to Keith O’Conor for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 257 - October 16th, 2022

Sun, 16 Oct 2022 04:00:00 +0000

Better outline rendering using surface IDs with WebGL

the article presents how to improve an outline rendering technique by using surface IDs instead of normals
discusses which issues the use of normals can cause and how surface Ids can improve
presents what kind of data issues can occur and how to pre-process the data

wayback-archive

Improve Shader Performance and In-Game Frame Rates with Shader Execution Reordering

the article presents how the Nvidia hardware feature Shader Execution Reordering (SER) can be leveraged in D3D12 ray tracing workloads
shows how to integrate the API and the necessary Root signature and shader changes
presents how the new feature was integrated into UE5 Path Tracing and Lumen
additionally mentions when the feature should be used and what kind of speedups can be expected

wayback-archive

Transparent and Crystal Clear: Writing Unity URP Shaders with Code, Part 3

the article (and video) explains how to author and integrate shaders with transparency support for use in Unity
covers Alpha Blending, Alpha Cutouts, sorting as well as shadow integrations
presents code examples for all stages with detailed explanations

wayback-archive

Jobs

3D Engineer
Darmstadt/Germany (remote possible)

Would you like to advertise your job openings here too? More information

DirectStorage 1.1 Coming Soon

the article presents that the next DirectStorage release will start to support GPU-based GDeflate decompression
drivers can provide optimized implementation, but a generic DirectCompute fallback will be provided
lists what hardware and software will support the feature

wayback-archive

[video] Sparkling Snow Shader - Advanced Materials - Episode 2

the video tutorial series covers how to build a complex rock shader
this episode shows the implementation of a snow shader in both UE and Unity with view-dependent sparkles
presents how to analyze source texture data and separate information so that smaller texture resolutions can be used without quality loss
shows how to pack textures and manually unpack them from the shader

Intel® Arc™ Graphics Developer Guide for Real-Time Ray Tracing in Games

the Developer Guide provides a functional description of Intel’s hardware ray-tracing implementation
additionally provides a list of guidelines for developers to allow them to maximize performance

wayback-archive

Upscale SDK comparison

the blog post provides a comparison of DLSS 2.4, FSR 2.1.1, and Intel XeSS upscaling techniques
provides uncompressed images of different scenes for better comparison

wayback-archive

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

[video] What is NVIDIA DLSS 3? | The Performance Multiplier

the video provides a high-level explanation of the DLSS 3 system
covering the hardware and system components required for the functionality
presents how motion vectors and optical flow are combined to generate intermediate frames

Lighting Test for Unreal Engine 5

a collection of simple test scenes for light conditions in UE5 and NVIDIA Falcor 5.2 Mogwai path tracer
contains Perfect Lambert Plane, Perfect Mirror Plane, Perfect Mirror Weak White Plane, as well as a Glossy Plane

wayback-archive

My take on shaders: Compute shaders

the article presents how to implement a compute shader that can be used to paint on vertex meshes in realtime
explains the fundamentals of compute shaders
shows how to integrate the system with code examples in Unity

wayback-archive

[video] How to blend skeletal animations // Intermediate OpenGL Series

the video explains how to implement blending between two skeletal animations
shows what information the ASSIMP library provides and how the data is structured
additionally presents how to update the OpenGL implementation to allow blending

Post-Processing – In-Depth Camera Distortion Effects

the article provides examples of different camera distortion effects (with code examples)
presents distortion, expansion/contraction, longitudinal/horizontal stretch as well as extrusion effects

wayback-archive

PIX 2210.10-preview: Initial support for Preview Agility SDK v706

PIX adds a separate preview branch of the tool that supports the Preview Agility SDKs
supports Enhanced Barriers, Independent Front/Back Stencil Refs and Masks, Triangle Fans
lists known limitations and considerations when starting to use the preview tool

wayback-archive

Thanks to Keith O’Conor for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 256 - October 9th, 2022

Sun, 09 Oct 2022 04:00:00 +0000

[video] How Ray Tracing (Modern CGI) Works And How To Do It 600x Faster

the video provides a walkthrough of ray tracing fundamentals
explaining the required concepts, such as BRDF and energy preservation, to understand the rendering equation
discusses patterns that cause raytracing techniques to require a large number of calculations
explains what the ReSTIR technique is and how it allows a significant reduction in the calculations required by taking advantage of spatial and temporal reuse

Progressive Material Caching

the paper introduces a progressive technique to cache material evaluations at runtime
presents the implementation details of updating a fixed-size hash table on the GPU
additionally shows the performance of the method and presents the effect of different cache sizes

wayback-archive

On AlphaTensor’s new matrix multiplication algorithms

the article discusses recent AlphaTensor’s discovery on matrix multiplication
explains what the algorithm applies to and how it compares to existing techniques
clarifies the performance results reported in articles

wayback-archive

Real-time distance field builder twitter thread

the Twitter thread summarises the real-time distance field generator used by AMD research work
can maintain the scene representation in < 0.5 ms each frame

wayback-archive

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

Fused BVH to Ray Trace Level of Detail Meshes

the paper presents a method to extend a mesh BVH with additional data so that it can be shared between multiple LODs
presents how to store the fused BVHs
shows performance and memory impact of using a different number of LODs

wayback-archive

Combining GPU Tracing Methods within a Single Ray Query

the paper presents a method that combines distance field tracing with hardware ray tracing
distance field generation is described in the “Real-time distance field builder Twitter thread” above
describes when to choose between hardware ray tracing and where to fall back to distance field

wayback-archive

Technically Art: Issue 128 (07.10.2022)

a collection of Twitter posts about a large variety of tech artist topics
breakdowns of techniques, tree animation breakdowns, and a showcase of effects

wayback-archive

Notes about Nanite in UE5.1 preview

the article presents an overview of ongoing Nanite developments the developer noticed in the UE5.1 preview
appears to start adding support for programmable pixel shader evaluation to allow masked materials
additionally, initial support for vertex modifications and existing culling limitations

wayback-archive

Simulating Wind on Procedural Terrain using GPU Accelerated Lattice Boltzmann Method

the blog post discusses a numerical method for fluid flow to simulate wind flow over terrain
discusses the underlying theory and how to mathematically express the simulation
shows how to implement the method using compute shaders in OpenGL

wayback-archive

Thanks to Denis Gladkiy for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 255 - October 2nd, 2022

Sun, 02 Oct 2022 04:00:00 +0000

Notes on screenspace reflections with FidelityFx SSSR

the article provides an overview of the implementation underlying AMDs’ FidelityFx screen space reflection technique
discusses how the decision is made if to trace a screen space ray or to fallback to cubemap reflections
presents performance optimizations done across the different stages

wayback-archive

[video] Introduction to Raytracing with the Radeon Developer Tools Suite

the video provides an introduction to the AMD raytracing tool
shows how to use the tools to gather performance information about the raytracing passes
video explanation of the Improving raytracing performance with the Radeon™ Raytracing Analyzer (RRA) that was covered in the week 253

Screen Post-processing Effects: Gamma Space and Linear Space

the article provides a summary of two plots for the existence of gamma space related to CRT and human perception
presents how the workflows are integrated into Unity and Unreal
it additionally presents how rendering results are incorrect when done in the wrong space

wayback-archive

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

Screen Post-processing Effects: Color Models and Color Grading

the article discusses the RGB and HSV color spaces
presents how to convert between the two spaces
it additionally shows how to use the HSV model to implement fullscreen color adjustments effects such as desaturation

wayback-archive

[video] An In-Depth look at Lerp, Smoothstep, and Shaping Functions

the video presents visual explanations of lerp (linear interpolation)
takes the knowledge to extend how to visualize and shape the curve for different effects
presents standard functions and presents different use-cases
it additionally shows cases where linear interpolation is not enough (camera movement, rotations, ..) and how to resolve them

Bindless Rendering in DirectX12 and SM6.6

the blog post provides an introduction level guide to using the D3D12 bindless model
shows how RenderDoc and Nsight show the accessed resources for debugging purposes

wayback-archive

An Algorithm for Polygon Intersections

the article presents how to calculate the intersection between axis-aligned rectangles
extends the methods to cover rotated and more generic polygon shapes
interactive code samples provided in javascript

wayback-archive

[video] Nvidia DLSS 3 on RTX 4090 - Exclusive First Look - 4K 120FPS and Beyond

the video explains how DLSS uses motion vectors and optical flow fields to implement AI Frame Generation
presents performance and quality comparison
discusses the upsides and downsides of the new AI frame generation technique

Vulkanised conference - call for submissions

the 2023 Vulkanised conference has been announced for in-person in Munich in February
organizes are currently looking for speakers for the event

wayback-archive

Intel(R) Xe Super Sampling (XeSS) SDK

Intel has released the SDK for the XeSS upscaler
closed source release that exposes the API for D3D12-based applications

wayback-archive

Thanks to Stephen Hill for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 254 - September 25, 2022

Sun, 25 Sep 2022 04:00:00 +0000

Ray Tracing of Signed Distance Function Grids

the paper presents a comparison of traversal and voxel intersection testing of signed distance function grids
compares the performance of the different methods
it additionally introduces a new method for interpolating normals for smoother edges across voxel edges

wayback-archive

Color-Perception-Guided Display Power Reduction for Virtual Reality

the paper presents a method designed for VR applications that adjust colors to reduce display color consumption
shows how to develop a perceptual model to detect what color changes in the peripheral vision are acceptable without being noticeable

wayback-archive

Animation Retargeting

the blog post provides a method to allow the retargeting of animations between models that share a common rig setup
presented method is meant for offline (tool) processing of the 3D model files

wayback-archive

Jobs

Software / Graphics Engineer Unity 3D (m/w/d)
Darmstadt/Germany (partly remote possible)

Als Rendering-Geek bist du mit den komplexesten Konzepten der Unity3D-Engine (z.B. Scriptable Rendering Pipeline) bestens vertraut.

Bei uns hast du die Möglichkeit Next-Level-3D-Datenstreaming innerhalb komplexer XR-Szenarien in enger Abstimmung mit unseren Kunden umzusetzen.

Would you like to advertise your job openings here too? More information

[video] Post Process VHS Filter Part 3 - Shader Graph Basics - Episode 62

the video tutorial presents how to implement a noise that recreates the interference of unshielded cables
shows how to generate white noise and animate it for movements

Advances in Real-Time Rendering in Games 2022

the slides for the Siggraph 2022 Advances in Real-Time Rendering course have been released
covering runtime Catmull Clark Subdivision, Global Illumination and Ray Tracing in Unreal Engine 5, Unity hair system as well as water rendering in Horizon Forbidden West
missing slides for Volumetric Clouds in Horizon Forbidden West as well as Cluster Path Tracing for Remote Rendering

wayback-archive

Quaternions: a geometrical interpretation.

the article presents a visual interpretation of Quaternion mathematics
starting from 2D rotations and developing towards 3D rotations from there

wayback-archive

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

[video] Easily Remaster Classic Games with NVIDIA RTX Remix

the video introduces the NVIDIA RTX Remix engine
the runtime allows the interception of DX9 applications
replaces the application renderer with the custom renderer
it additionally allows all assets to be intercepted and exported into a USD format where the assets can be modified and reloaded into the original game

[video] Soft Shadows - PCF & Random Sampling // OpenGL Advanced Rendering Series

the video tutorial explains how to improve an OpenGL shadow mapping implementation to allow softer edges
presents a Percentage Closer Filtering implementation, discussing weaknesses and limitations of the techniques
it also shows how to implement a method to improve the edge filtering by varying the sample positions

Thanks to Leonardo Etcheverry for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 253 - September 18, 2022

Sun, 18 Sep 2022 04:00:00 +0000

Improving raytracing performance with the Radeon Raytracing Analyzer (RRA)

the post provides insights into ray tracing BVH performance
shows how splitting BVHs, usage of instances, BVH splitting, and model creation can affect performance
the effect of deformations on update vs. rebuild
additionally presents a comparison of iterative and recursive ray tracing

wayback-archive

Vulkan Render-Queues and how they Sync

the article presents how a render graph gets updated to handle exclusive resource ownership between multiple GPU queues
examples are provided in Vulkan terms
explain the difference between binary and timeline semaphores
shows how to integrate swap chain synchronization into such a system

wayback-archive

[video] SIGGRAPH 2022 Talk - A Fast & Robust Solution for Cubic & Higher-Order Polynomials

the video presentation provides a walkthrough of methods to find the real roots of polynomials
presents an example of how to use the technique for hair rendering to calculate hair strand intersections

Defeat Banding – Part II

the article discusses a method to detect artifacts in video
applies the concept to detect banding artifacts and present a visual representation of the artifacts present over time

wayback-archive

Jobs

Software / Graphics Engineer Unity 3D (m/w/d)
Darmstadt/Germany (partly remote possible)

Als Rendering-Geek bist du mit den komplexesten Konzepten der Unity3D-Engine (z.B. Scriptable Rendering Pipeline) bestens vertraut.

Bei uns hast du die Möglichkeit Next-Level-3D-Datenstreaming innerhalb komplexer XR-Szenarien in enger Abstimmung mit unseren Kunden umzusetzen.

Would you like to advertise your job openings here too? More information

[video] Pixelation Filter - Shader Graph Basics - Episode 61

the video tutorial presents how to create a fullscreen post-screen effect that pixelates the screen
provides a walkthrough of the implementation in Unity and Unreal using visual shader graphs

Fast Post-Processing on the Oculus Quest and Unity

a short article that shows an option to apply tone mapping in forward shading without wanting to use a separate fullscreen pass
discusses the shortcomings of the technique

wayback-archive

Screen Post-processing Effects: Depth of Field (DOF) and Its Implementation

the article provides an overview of depth of field effects
shows the effect of different camera parameters on the visual results
presents an implementation in Unity shader code

wayback-archive

[video] Practical Skeletal Animation // Intermediate OpenGL Series

the video tutorial provides a walkthrough of issues in supporting animated models
shows how to extend to larger support bone counts, dealing with zero bone influences as well as supporting multiple animations

Thanks to Mike Turitzin for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 252 - September 11, 2022

Sun, 11 Sep 2022 04:00:00 +0000

Visualizing General Relativity

the article explains a method to simulate and render different warped space-times
shows how to simulate the light to form a black hole

wayback-archive

Rendering my balls in a fragment shader

the blog post provides a walkthrough of how to render 2D billiard balls in a pixel shader
shows how to render a sphere, calculate normals, apply textures and specular lighting

wayback-archive

Parallel curves of cubic Béziers

the article describes a method to generate a cubic Bézier curve that is parallel with a defined offset distance to another curve
compares different methods and presents examples to experiment with the proposed techniques

wayback-archive

Improving Vulkan graphics state tracking in Mesa

the article discusses how API pipeline state maps onto different hardware types
presents how the open source Mesa stack provides solutions to the problem that can take advantage of the underlying hardware

wayback-archive

Technically Art: Issue 124 (9.09.2022)

a collection of tweets about tech art, VFX, and related topics
showcases in-progress developments and experiments

wayback-archive

Gradient-descent optimized recursive filters for deconvolution / deblurring

the post discusses infinite impulse response (IIR filter)
shows when one might want to use an IIR filter, discussing problems with the filters
proposes a solution that uses a gradient descent optimization process to learn an IIR filter

wayback-archive

[video] Post Process VHS Filter Part 2 - Shader Graph Basics - Episode 60

the second video of the series VHS filter series adds support for worn-out tape and tracking-out-of-phase effect
implementation is done using Unity and Unreal shader graph system

Thanks to Ken Russell for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 251 - September 5, 2022

Mon, 05 Sep 2022 04:00:00 +0000

[video] Ray Marching, and making 3D Worlds with Math

the short video provides a great visual introduction to distance functions and ray marching
presents how to express shapes using implicit surfaces
showing techniques to combine different shapes and animate them

Lighting participating media with thousands of lights

the article shows the Grid-Based Reservoirs sampling technique for dynamic lights in participating media
this enables the temporal reuse of samples among neighboring rays
shows the different stages of the implementation and how different sampling and noise distributions change the results

wayback-archive

Mesh Shading for Vulkan

mesh shader support has been added to Vulkan through VK_EXT_mesh_shader
the article compares the API against D3D12 and the previous Nvidia extension
Khronos additionally provides several queryable attributes that developers can use to tune the algorithms for the hardware capabilities and requirements

wayback-archive

[video] Intel Arc Graphics | Intel Arc A-Series Graphics Ray Tracing Technology Deep Dive

the video starts with a visual overview of rasterization, raytracing, and hybrid rendering techniques
the talk focuses on how intel hardware is designed to efficiently support raytracing
contains benchmark comparisons of expected performance compared to an RTX3060

Progressive image stippling and greedy blue noise importance sampling

the article presents a method to generate Progressive blue noise samples that follow the image content
shows the implementation in python
discusses the effects of different parameters and how they can be used for the required results

wayback-archive

[video] Post Process VHS Filter - Shader Graph Basics - Episode 59

the video presents how to implement two VHS effects, interlacing lines and YIQ color grading, in a post-processing effect
walkthrough of the effect is provided in both Unreal and Unity

Compressing global illumination with neural networks

the blog presents the idea of using a simple neural network to encode diffuse indirect light for a scene
discusses the various steps in the experiment
presents the final results and discusses weaknesses of the approach

wayback-archive

[archive] Practical Aspects of Spectral Data in Digital Content Production - SIGGRAPH 2022

second year of the spectral rendering Siggraph course
focusing on the practical aspects of spectral rendering
shows the limitations of RGB and discusses the advantages of spectral rendering and workflows

Technically Art: Issue 123 (2.09.2022)

a collection of tweets about tech art, VFX, and related topics
showcases of in-progress developments and experiments

wayback-archive

Thanks to Giuseppe Modarelli for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 250 - August 28, 2022

Sun, 28 Aug 2022 04:00:00 +0000

Barycentric Quad Rasterization

presents why and when a quad is being drawn as two triangles can cause discontinuities along the edge
the paper presents a geometry shader implementation of generalized barycentric coordinates for quads
this concept was introduced in 2004 for CPU rasterization when hardware support was not available

wayback-archive

Practical Real-Time Hex-Tiling

the paper introduces an adaptation of the Heitz and Neyret texture tiling technique
the original technique required offline preprocessing to enable histogram-preserving tiling
the new method removes the requirement and presents the implementation in shader code only
presents how to apply the technique for color and normal maps

wayback-archive

Clip control on the Apple GPU

the blog post provides an insight into how the apple metal driver is separated into components
shows how it’s possible to call internal APIs and reconstruct hardware behavior
presents a discussion of OpenGL clip space mapping and limitations of different emulation behaviors

wayback-archive

[video] Creating an Outline Effect as a Post-Process in Unity

the video tutorial explains how to implement an outline effect in Unity
presents how to detect edges using the depth buffer, create an outline at the edges
it additionally shows how to adjust the effect so that objects behind objects get a separate show-through-wall effect

HPG 2022 Keynote: The Journey to Nanite - Brian Karis, Epic Games

the talk discusses the issues artist encounter and how Nanite goals are designed to resolve them
presents a large number of topics Brian Karis had researched along the way
shows a brief overview of the techniques, shortcomings, and reasons why they failed
discusses how to structure long-term research, focusing on challenges of the field and the importance of coding like a scientist

CoG 2022: Automatic Testing and Validation of LoD Reductions Through Supervised Learning

the paper introduces two convolutional neural networks (CNN) based techniques that can detect LOD transitions and the quality of that transition
two models are presented to solve these two issues separately
discusses the issue with the current approaches and how the presented techniques could be used to support artists

wayback-archive

Thanks to Daniel Fortes for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 249 - August 21, 2022

Sun, 21 Aug 2022 04:00:00 +0000

The GPU Banana Stand

the article presents an overview of the composable declarative GPU authoring
shows how chain compute dispatches, handles historical data as well as visualizes temporary results
it additionally discusses how the tree representation allows internal composability and enables background optimizations

My personal hell of translating DXIL to SPIR-V – finale

the article continues the series of translating DXIL to SPIR-V for use with vkd3d-proton
the part covers how to convert structured control flow. DXIL is unstructured and needs to be converted into structured SPIR-V
discusses the limitations, oddities and solutions developed to make the conversion work and debuggable

wayback-archive

Exploring Shaders with Compiler Explorer

the article presents how to integrate new compilers into the compiler explorer infrastructure (which can be run locally)
discusses the DXC and AMD Radeon™ GPU Analyzer integration
shows the limitations of the existing integration

[video] Let There Be Light (And Shadow) | Writing Unity URP Code Shaders Tutorial [2/9]

the video tutorial presents how to write universal rendering pipeline shaders in HLSL
shows how to implement simple diffuse & specular lighting, explaining the render pipeline as the author goes along
it also shows how to integrate shadow rendering
additionally presents the debugging tools available

Deconstructing Bézier curves

the article explains the underlying theory for Bézier curves and shows how the different component interacts
presents how to express the curve mathematically so that intersections between a ray and the curve can be found
shows how to use the information to detect if a pixel is inside or outside of a shape

wayback-archive

Journey to Lumen

the article discusses the different approaches that were tried during the development of lumen
presents tradeoffs of the different techniques and how the decision was made on which one to use
it additionally shows how the arrival of Nanite changed several variables significantly and therefore made a new evaluation of approaches necessary

wayback-archive

[video] Resampled Importance Sampling: Foundations of ReSTIR

the video presents the foundation how to general ReSTIR sampling
this allows resampling with importance sampling for arbitrary domains
continues to show how to apply these concepts to allow ReSTIR for path-tracers
shows how to allow reuse across paths, discusses considerations and limitations

[video] Coding a crazy weave pattern

the video shows how to implement a Truchet effect using shadertoy
presents the whole implementation from start to finish, showing all intermediate steps
it additionally discusses how to extend the concepts and possible future extensions

Lightweight Multidimensional Adaptive Sampling for GPU Ray Tracing

the paper presents how to adapt multidimensional adaptive sampling for interactive real-time ray tracing
applies the technique to stochastic effects such as motion blur, depth of field, and indirect illumination
presents a performance comparison against Halton sampling

wayback-archive

[video] Fog Rendering - Part 2 // 'ShaderX2 In Practice' series

the OpenGL fog rendering series extends the previous works and implements Layered and animated fog
explains the underlying theory before showing the implementation using GLS

[video] Post Process Cartoon Outlines - Shader Graph Basics - Episode 57

the video tutorial shows how to implement cartoon outlines in screen space
discontinuities in scene depth and normals are used to detect edges
the resulting filtered edge mask is used to apply outlines around objects

Thanks to Aras Pranckevičius for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 248 - August 14, 2022

Sun, 14 Aug 2022 04:00:00 +0000

NVIDIA Announces Full Open Source of Material Definition Language to Streamline Graphics Pipelines

Nvidia open-sources MDL distiller and the GLSL backend
MDL distiller is a system for automated shader simplifications
the GLSL backend enables the usage of MDL for Vulkan applications

wayback-archive

Physically Based: a Database of PBR Values for Real-World Materials

A database of physically based values for CG artists (materials, Light Sources, Cameras)
contains material information of familiar materials in a unified interface
materialX, unity, and unreal shader graphs are available for the different materials

wayback-archive

PIX 2208.10: SM 6.7 support, GPU and Timing Capture Improvements

new PIX release allows profiling to target different GPU clock rates (controlled by the hardware manufacturer)
added the ability to export metrics to CSV
additionally, added support trimming of captures

wayback-archive

Using performance budgets in the Timing Capture metrics view

the post explains how to set up budgets for pix metrics
can be defined for the user or system metrics

wayback-archive

Screen Post Processing Effects Chapter 1 – Basic Algorithm of Gaussian Blur and Its Implementation

the article explains the theory of a Gaussian blur algorithm
shows how the filter is defined, sample weights calculated
it additionally presents how to implement the technique using a Unity Pixel Shader

wayback-archive

Descriptors are hard

the article presents a description of the texture/buffer/sampler binding model supported by different hardware manufacturers
discusses how Vulkan and D3D12 models map onto the hardware
additionally discusses problems arising from the differences

wayback-archive

Real-Time Path Tracing and Beyond

the presentation provides a brief overview of the implementation details for the Nvidia path tracer and the level of optimizations required to archive the performance
presents open problems in data authoring, scene description, and material complexity
shows ideas on how techniques can be developed together to deliver improved results

wayback-archive

SIGGRAPH 2022 Links

a growing collection of content from SIGGRAPH 2022
presentations, slides, videos, and posters

wayback-archive

Beyond Linear Perspective: Art, Human Vision, and Computer Graphics

discusses the limitations of linear perspective and how classical artists rarely used it
present non-linear projection techniques and how they can be used
starts a discussion on how to computationally model and apply these methods

wayback-archive

Explosion Decals

the article presents a technique to generate explosion decals aimed at a 3D topdown game
based around forward shading, a projected 3D sphere with procedural noise

wayback-archive

[video] Bloom & Glow Post Process Effect - Shader Graph Basics - Episode 56

video tutorial shows how to implement a bloom effect using Unreal and Unity shader graphs
starts by showing visually how the effect works using photoshop before implementing the code
followed by presenting a walkthrough of the total effect

Thanks to Keith O’Conor for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 247 - August 7, 2022

Sun, 07 Aug 2022 04:00:00 +0000

High-Performance Graphics 2022

the program has been updated with links to the recording of all talks
not all papers are available yet; only the author-released copies are available at this time

wayback-archive

Vertex packing

the article describes the trade-offs between storing vertex information in a single buffer compared to storing the data across multiple streams
presents how splitting can have a positive impact on cache usage as well as reduced power consumption

wayback-archive

Paper Digest: SIGGRAPH 2022 Highlights

a collection of papers presented at SIGGRAPH 2022 with a one-sentence summary
provides links to the ACM entries that provide access to the papers

wayback-archive

Comparison of single image HDR reconstruction methods — the caveats of quality assessment

the paper presents that common image metrics are not a great metric to detect the subjective quality of HDR reconstruction methods
shows that only significant changes in metric results are likely to be an improvement
suggests that color shifts are more noticeable to the human perception system than most metrics

wayback-archive

[video] Microfacet BRDF: Theory and Implementation of Basic PBR Materials [Shaders Monthly #9]

the video shows how to implement the Cook-Torrance microfacet BRDF
provides an overview of the theory first
shows how to implement the technique with GLSL

HLSL Shader Model 6.7

the spec for the new features of shader model 6.7 has been released
contains summaries and links to the detailed specification section for each feature

wayback-archive

Shaders Explained: Gradients

the article presents how to write a metal shader to generate a 1D gradient
this is taken as the basis and expanded to generate a 2D, radial, and angular gradients
source code is provided

wayback-archive

Porting AnKi to Android… again after ~8 years

the article contains a small overview of steps taken to port the AnKi engine to support Android
discusses how the problem was broken down, issues encountered, and workarounds required

wayback-archive

[video] Fog Rendering - Part 1 // ShaderX2 In Practice Series

the video tutorial presents how to implement 3 different methods of distance fogs from the ShaderX2 book (released in 2003)
implementation is shown in OpenGL/GLSL
presents a comparison of the three presented techniques

Thanks to Trevor Black for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 246 - July 31, 2022

Sun, 31 Jul 2022 04:00:00 +0000

[video] Compute Shaders || Lou Kramer || AMD

the presentation introduces compute-shaders, explaining the software and hardware concepts
expands upon the basis to explain execution patterns, memory, and cache hierarchies
texture reading/writing patterns as well as common mistakes

Introducing our brand new tool: Radeon™ Raytracing Analyzer 1.0

new tool from AMD to provide more insights into the performance of raytracing applications
show much memory is used, if redundant information is stored, all geometric axis aligned, etc
video presentation covering the information available is linked

wayback-archive

Synchronizing Present Calls Between Applications on Distributed Systems with DirectX 12

the article presents an Nvidia API extension that allows multiple buffer swaps (between windows and applications) to be synchronized
shows the D3D12 API and discusses the usage, conditions for correct usage as well as limitations

wayback-archive

Best Practices for Using NVIDIA RTX Ray Tracing (Updated)

Nvidia has updated the performance best practices for RTX usage
contains new recommendations enabled with shader model 6.6, updated guidelines for inline ray tracing
and many more minor updates across the categories

wayback-archive

GPU Memory Pools in D3D12

the detailed article explains the different memory pools available and how they differ between different types
shows how D3D12 exposes the memory management
discussing strategy for texture and buffer uploads
presents performance numbers for CPU and GPU reads/writes and uploads to different memory types

wayback-archive

A Rust shading language EDSL

the article discusses the Rust shades crate that allows writing Rust domain-specific language that can be used to generate GLSL code
explains the motivation, implementation as well as open issues
it additionally provides a comparison against other solutions

wayback-archive

A better point light attenuation function

the article presents a derivation of a light attenuation function to separately control the maximum intensity and radius
function is designed to reach zero influence to be used with clustered shading

wayback-archive

UVs and You

the article aimed at beginners explains how images are applied to 3D objects
presents what UV (Texture coordinates are) and how to visualize them
shows how to explore the relationship between mesh and UV coordinates from Unity shaders

wayback-archive

GL_EXT_fragment_shader_barycentric: Wireframe

the article presents an overview of barycentric coordinates
shows that barycentric can be interpreted as a distance field
derives how to render wireframe line rendering from these distances

wayback-archive

Adventures in Text Rendering: Kerning and Glyph Atlases

the article provides an overview of font rendering
looks at the different levels that cover glyph evaluation, line layouts, and antialiasing
presents rasterization constraints, how to cache glyphs for efficient rendering
additional covers how to deal with sub-pixel positioning

wayback-archive

[video] Generation of simplified representations of the city, characters and vehicles for Cyberpunk 2077

the presentation video discusses the LOD generation used in Cyberpunk 2077 (3D models and materials)
discusses the different algorithms that were used for different types of models and materials
provides an overview of the pipeline and infrastructure integration

Adventures with deferred texturing in horizon forbidden west

slides for the GDC presentation talking about the deferred texturing solution has been released
summary in week 231

wayback-archive

zig-gamedev project

a growing collection of graphics samples and libraries for the zig programming language
the provided samples cover how to use the released libraries

Thanks to [Michael Hazani] for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 245 - July 24, 2022

Sun, 24 Jul 2022 04:00:00 +0000

Efficently rendering glTF models

the article discusses how to load and process glTF models for efficient execution
presented techniques aimed at WebGPU but mainly applicable to D3D12/Vulkan as well

wayback-archive

Behind the Pretty Frames: Resident Evil

a super detailed analysis of the RE Engine used by Resident Evil
shows the passes, what data structures are used, and detailed breakdowns of the effects of the passes

wayback-archive

[video] Shadow Mapping Unleashed! // Intermediate OpenGL Series

the video tutorial explains common shadow problems and why they occur
proceeds to present different solutions to the issues and compare the methods

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

High Performance Graphics 2022 papers on the web

list of papers presented at High-Performance Graphics 2022
contains links to the projects, papers, and youtube videos if available

wayback-archive

[video] Rain Drips On The Lens Post-Process Effect - Shader Graph Basics - Episode 54

the video tutorial presents how to implement a fullscreen camera space rain effect
implementation is done using Unity and Unreal visual shader system

[video] Spartan Engine Livestream #2: FSR 2.0 Integration

the stream shows a practical example of how to implement FSR 2.0 into the authors’ personal engine
presents the complete process, including example project setup, engine integration, and testing

Swallowing the elephant into Blender

collecting of optimizations done to reduce the Moana USD scene import time into Blender from 3 hours to 1.5 minutes
includes generally applicable advice for performant CPU code implementations

wayback-archive

Some SIGGRAPH 2022 Info

a collection of advice for SIGGRAPH 2022 (virtual) attendees
list of links and events around the event

wayback-archive

Performance Boosts and Enhanced Features in New Nsight Graphics, Nsight Aftermath Releases

article presents improvements in the new Nsight and Aftermath releases
improved Ray Tracing Acceleration Structure Viewer and VK_KHR_graphics_pipeline_library extension support for Nsight graphics
Aftermath has better support for tracking page faults from data writes

wayback-archive

Thanks to Leonardo Etcheverry for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 244 - July 17, 2022

Sun, 17 Jul 2022 04:00:00 +0000

[video] Procedural Grass in 'Ghost of Tsushima'

the GDC presentation covers how the grass is procedurally generated in compute shaders
how vertex shader animates the blades and wind influences the shapes
presents the LOD transitions, how shadows are processed
it additionally covers how artists can control the effects

Order independent transparency: endgame

the article presents a couple additional order-independent transparency algorithms
provides a brief overview of Weighted Blended Order-Independent Transparency (WBOIT) as well as Moment based OIT (MBOIT)
shows the influence of screen size, quality setting as well as render target formats on the performance of the techniques

wayback-archive

Jobs

Animation Engineer / Code Supremo
Remote working / Flexible hours

The Indie Stone, developers of Project Zomboid, are looking for AAA coders to join them on their quest for the ultimate zombie survival simulation.

The applicant would be in charge of maintaining and developing our game’s animation system for Project Zomboid using a custom built OpenGL engine, while also working with the animator to improve our output, systems and toolset. Initial tasks would deal with root motion, blending and masking – later moving on to integration of inverse kinematics and ragdoll physics.

The Zomboid team is small and have their fingers in a lot of pies, so there are many opportunities to get involved in other areas of the game too - depending on the applicant’s skillset.

Competitive salary and a prominent role in a tight, passionate team. Remote and flexible working, anti-crunch mindset.

Would you like to advertise your job openings here too? More information

Advanced API Performance: SetStablePowerState

Nvidia presents best practices to achieve stable performance results on NVIDIA hardware
it recommends not only using SetStablePowerState as it doesn’t lock memory clocks
instead recommends using the NVidia-smi utility

wayback-archive

[video] HPG 2022 Monday, Day 1 (enhanced)

the video recording of the first day of the High-Performance Graphics conference
covers temporally stable upscaling and denoising, variance-guided filtering for motion blur, as well as virtual blue noise lighting
the recordings of the other days are available on youtube as well

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

Agility SDK 1.606.3: Shader Model 6.7 is now publicly available!

the article focuses on the new capabilities added in shader model 6.7
now supports integer border colors, dynamic programmable offset, as well as new quad all/any operations
adds support for writing to MSAA targets via UAV as well as more relaxed uint castable texture formats (same idea as Vulkan, creation time list of allowed formats)
it additionally adds support for raw gather instructions

wayback-archive

Preview Agility SDK 1.706.3-preview: SM 6.7, Enhanced Barriers and more

a new preview of the Agility SDK improves the enhanced barrier API support, significantly better debugging support
as well as it allows Independent Front/Back Stencil Refs and Masks

wayback-archive

AMD support for Shader Model 6.7 and enhanced barriers in the Agility SDK

a brief summary of the main features of shader model 6.7 and what is supported by the new AMD pre-release drivers

wayback-archive

[video] How do you use shaders to dissolve a sphere?

the video shows how to implement a custom material into the Rust-based Bevvy engine
presents the necessary Rust and Shader(WGSL) code required to achieve the effect of a dissolving object

Creating a physically-based path tracer

the article presents a brief overview of techniques that can be used to upgrade a simple raytracer to generate results that converge quicker
shows the effect of importance sampling and what possibilities exist

wayback-archive

Space Rangers with Cornrows

the short paper presents the Pixar technique for Modeling Braids and Curls

wayback-archive

Thanks to Jonathan Tinkham for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 243 - July 10, 2022

Sun, 10 Jul 2022 04:00:00 +0000

EGSR 2022 Presentation – Generalized Decoupled Shading

the paper discusses a decoupled shading implementation that separates rasterization from shading by shading pixels before they are rasterized
presents how it determines what pixels will need to be shaded
what space to allocate for storing the shading results and how to execute the shading
discusses strengths and weaknesses of the approach
presents performance comparisons against a forward shading implementation
it additionally covers numerous considerations that are required for a robust implementation

wayback-archive

Spatiotemporal Blue Noise Masks

the paper presents how to generate multiple 2D blue noise textures so that the blue noise is both spatially and temporally a blue noise pattern
the presented solution is a drop-in replacement for applications that are already using independent blue noise textures
discusses how to generate the textures and compare multiple methods
it additionally presents a comparison of the technique in multiple test cases and compares against other methods
take a look at the supplemental for more practical information for real-time use cases

wayback-archive

Jobs

Animation Engineer / Code Supremo
Remote working / Flexible hours

The Indie Stone, developers of Project Zomboid, are looking for AAA coders to join them on their quest for the ultimate zombie survival simulation.

The Zomboid team is small and have their fingers in a lot of pies, so there are many opportunities to get involved in other areas of the game too - depending on the applicant’s skillset.

Competitive salary and a prominent role in a tight, passionate team. Remote and flexible working, anti-crunch mindset.

Would you like to advertise your job openings here too? More information

[video] Vulkan 1.3 explained

the 4-hour video stream discusses the evolution of the Vulkan API
discusses the underlying concepts, issues, and how the changes in Vulkan 1.3 try to improve
talking about pipeline management, render passes, new synchronization API
it additionally also covers the other more minor extensions added to the core

Temporally Stable Real-Time Joint Neural Denoising and Supersampling

the paper presents a neural network architecture that allows both denoising and supersampling to be applied as part of a single network
this is achieved by sharing a joint feature extractor
discusses the different stages of the network, what inputs are required and how they interact
presents a comparison against existing solutions and offers performance numbers

wayback-archive

GPU-Driven Real-Time Mesh Contour Vectorization

the paper presents a new GPU-based method to generate 2D contour strokes from 3D meshes
proposed solution uses a preprocessing step to analyze the adjacency and geometric information
discusses the different steps of implementation
it additionally shows how to further utilize the counter edge lines to support different patterns
example implementation in Unity is provided

wayback-archive

Volume Rendering for Developers: Foundations

the lesson provides the foundations of ray marching through a volume
explains how light interacts with a medium, introducing the required terms along the way

wayback-archive

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

Advanced Rendering Research Group at AMD

the new home for the AMD research team
provides a collection of publications, projects, presentations as well as blog posts

wayback-archive

Getting Started With DirectX Raytracing

the post provides a walkthrough of all the D3D12 elements that are involved in getting started with a raytracing workload
discusses the different concepts and how they relate to each other
shows how to author raytracing shaders
it additionally shows how the integration in Microsoft Mini Engine has been achieved

wayback-archive

Planetary Shadow-Aware Distance Sampling

the paper introduces a visibility-aware transmittance sampling technique for rendering atmospheric scattering
this is achieved by adjusting the sample locations along the view vector past the shadow boundary so that all samples contribute meaningful data
compares the solutions against others and presents cases where the proposed solution is not able to improve
it additionally provides an example of a CPU implementation

wayback-archive

Thanks to Jonathan Tinkham for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 242 - July 03, 2022

Sun, 03 Jul 2022 04:00:00 +0000

Order independent transparency, part 2

the second part of the blog series that talks about order independence transparency
this week focuses on techniques that aim at solving transmittance contribution first and then applying the factors while shading
shows how Rasteriser Order Views (ROVs) can be used to implement custom blending operations
presents performance implications of the proposed techniques

wayback-archive

Seperation of mesh types

the Twitter thread discusses the terminology that applies to meshes
presents the difference between static, dynamic, deformable, and procedural meshes

wayback-archive

[video] Creating Portals in Unreal for Psychonauts 2

the Xfest presentation discusses the portal implementation for Psychonauts 2
covers how portals are represented in the world, how to render the portal world, discusses issues encountered and how they have been overcome
it also presents essential performance optimizations
it additionally covers how to calculate the required transformations and solve system interaction problems

Jobs

Senior Graphics Programmer
San Francisco, CA (remote work is an option)

You will be responsible for developing rendering features, optimizing game performance and memory usage, and building low level systems on PC and Xbox.

Would you like to advertise your job openings here too? More information

Single-pass stratified importance resampling

the paper presents a new method for stratified resampling
shows a single pass solution to inverse CDF sampling (similar to reservoir sampling)
extends the presented solution to other domains and compares it against existing techniques

wayback-archive

[video] Giving Personality to Procedural Animations using Math

the video presents how to use second-order systems to allow dynamic motion control in procedural animation scenarios
presents the mathematics and an example implementation in Unity

Fog for Top-Down Games

the article presents how to combine multiple tricks to create the appearance of volumetric fog
combines a height map-based mesh with depth & translucency fading to create the illusion
discusses the steps required and provides examples in C++ / Unreal visual script

wayback-archive

Jobs

Senior/Lead Rendering Engineer
Los Angeles, Vancouver, Montreal or San Mateo

We have several project openings for a Senior/Principal or Lead Rendering Engineer to work on new/all original IP’s, which are being developed in Unreal 5 and are true cross-play multiplayer games on PC, Console & Mobile.

You will work collaboratively with artists, designers and engineers to realize our beautiful, stylized visual target.

The ideal candidates are broadly experienced with optimization & profiling CPU/GPU on multiple platforms, creating content workflows/pipelines and experienced with both R&D and production systems/features.

Would you like to advertise your job openings here too? More information

Advances in Real-Time Rendering in Games - 2022

overview of the talks that will be presented at the Advances course as part of Siggraph 2022

wayback-archive

Advanced API Performance: Vulkan Clearing and Presenting

the article presents Nvidia’s best practices for clearing textures and depth buffers
clarifies what methods are preferred and how clear values can influence performance
it additionally presents the tradeoffs between the different presentation modes

wayback-archive

[video] Underwater Post-Process Effect - Shader Graph Basics - Episode 52

the video tutorial presents how to create a post-processing effect that simulates an underwater look
covers depth-fog, distortion, lens distortion, and caustics
presented using Unity and Unreal visual shading system

Icosphere From Octahedron to Icosahedron

the article presents how to generate a procedural Icosahedron mesh
shows and discusses the differences in point distribution compared to other sphere mesh structures

wayback-archive

Boosting Application Performance with GPU Memory Access Tuning

the article presents how to improve compute shader performance when workloads are memory limited
presents how to detect if a CUDA shader runs into register limits
it additionally shows how CUDA launch bounds (promises on work sizes) can give the compiler more information for more aggressive optimizations

wayback-archive

Thanks to Vivitsu Maharaja for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Graphics Programming weekly - Issue 241 - June 26, 2022

Sun, 26 Jun 2022 04:00:00 +0000

Order independent transparency, Part 1

the article presents how to use per-pixel linked lists to implement order-independent transparency
presents performance and memory results of the solution
it additionally discusses limitations and a look at alternatives to reduce memory overhead

wayback-archive

Physical Units for Lights

the article presents a discussion of the different physical Units used for light description
provides explanations for each unit and the relationship between them
it includes a handy summary graphic as a cheat sheet to remember the relationships

wayback-archive

Comparing BCn texture decoders

the article compares BC decompression libraries
compares the level of format support, decoding performance, and build complexity

wayback-archive

Jobs

Senior/Lead Rendering Engineer
Los Angeles, Vancouver, Montreal or San Mateo

You will work collaboratively with artists, designers and engineers to realize our beautiful, stylized visual target.

Would you like to advertise your job openings here too? More information

DirectML Plugin for TensorFlow 2 is here

the blog posts announce the release of a first preview of the DirectML backend for the TensorFlow 2
this allows workloads to be executed on generic D3D12 capable GPUs (AMD, Intel)

wayback-archive

It’s time to see the FSR 2 source code!

AMD released FidelityFX™ Super Resolution 2 (FSR2) to the public
source and documentation about the integration is available
it additionally provides information about the different modes and provides comparison images in different scenes

wayback-archive

Khronos cross-vendor mesh shader extension update

Khronos is sharing the first details about what the cross-vendor Vulkan mesh shader extension will look like
presents what the differences to the VK_NV_mesh_shader will be and what to take into consideration when designing a solution today

wayback-archive

[video] NVIDIA’s Ray Tracer: Wow, They Nailed It Again!

the paper presents an overview of the NVidia Fast Volume Rendering with Spatiotemporal Reservoir Resampling paper
video compares against previous results and how ReSTIR techniques can help to reduce noise and require a large reduction in sample counts

Thanks to Peter Kohaut for support of this series.

Would you like to see your name here too? Become a Patreon of this series.

Weekly on Jendrik Illner - 3D Programmer

Graphics Programming weekly - Issue 436 - April 12th, 2026

Graphics Programming weekly - Issue 435 - April 5th, 2026

Graphics Programming weekly - Issue 434 - March 29th, 2026

Graphics Programming weekly - Issue 433 - March 22nd, 2026

Graphics Programming weekly - Issue 432 - March 15th, 2026

Graphics Programming weekly - Issue 431 - March 8th, 2026

Graphics Programming weekly - Issue 430 - March 1st, 2026

Graphics Programming weekly - Issue 429 - February 22nd, 2026

Graphics & Tools Programmer Remote Work

Graphics Programming weekly - Issue 428 - February 15th, 2026

Graphics Programming weekly - Issue 427 - February 8th, 2026

Graphics Programming weekly - Issue 426 - February 1st, 2026

Graphics Programming weekly - Issue 425 - January 25th, 2026

Graphics & Tools Programmer
Remote Work