Graphics Programming Weekly Database

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the project presents how to implement Material Mapping using MaterialX
  • the included demo video shows the effect
  • code is provided
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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.
  • archive / summary

  • 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
  • archive / summary

  • the article provides a look at various anti-aliasing techniques
  • presents many interactive examples to demonstrate the techniques and allows experimentation with them
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the video explains how to set vertex buffers using Vulkan
  • shows the implementation for allocation memory and uploading data for GPU access
  • archive / summary

  • 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
  • archive / summary

  • the blog post provides an overview of what has been discussed for changes to WebGPU
  • archive / summary

  • the tool allows the visualization of Monte Carlo samplers
  • many different methods can be selected
  • allows the exploration of settings through interactive controls
  • archive / summary

  • 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
  • archive / summary

  • 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.
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the slides discuss the design of the C4 Engine
  • present how the engine has been separated into separate components and what these components do
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • single header HLSL library for spherical harmonics
  • implements support for L1 (2 bands, 4 coefficients) and L2 (3 bands, 9 coefficients) SH (spherical harmonics)
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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)
  • archive / summary

  • intel released the rendering toolkit as open source under Apache 2
  • the technologies include Embree, Open Image Denoising, OpenOSPRay, and others
  • archive / summary

  • 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  
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • The schedule for the graphics programming conference was released
  • conference will happen in November in Breda, Netherlands
  • contains a mix of talks and courses
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the video tutorial presents how to implement a progress bar using SDFs
  • implementation is shown using Unity and Unreal Visual Shading languages
  • archive / summary

  • 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  
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the blog post shows how to profile an application with multiple processes using PIX for Windows
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • a diagram that visually explains left-handed vs. right-handed coordinate systems
  • additionally presents which concepts are independent of the handedness
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the release adds support for new Vulkan extensions
  • exposes VK_AMD_anti_lag, VK_KHR_calibrated_timestamps, VK_KHR_pipeline_binary and others
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • SDL GPU abstraction has been merged into the main branch
  • provides a D3D11, D3D12, Metal and Vulkan implementation layer
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the short blog post presents how to use human-readable ISA documentation to decode one CDNA instruction
  • archive / summary

  • AMD released ISA documentation for RDNA2 and CDNA ISA
  • additionally, it presents a small example application that presents how to use the released data
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the talk provides an overview of the D3D12 work graph API
  • provides details into how the API is mapped onto AMD hardware
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the video tutorial explains the Vulkan render pass concept
  • shows how to use a render pass to clear the framebuffer to a constant color
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • a collection of links to SIGGRAPH 2024 resources
  • includes courses, talks, posters as well as open source data releases
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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  
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • A brief blog post discusses what aspects of the new mesh nodes preview for d3d12 can be debugged using Pix
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the video provides a comparison to present the improvements done with FSR 3.1
  • presents a comparison against other upscaling solutions
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • a new graphics programming-focused conference in Breda, Netherlands
  • The call for speakers is still open till July 31st
  • archive / summary

  • 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
  • archive / summary

  • X thread with a collection of Spatial Indexing Algorithms
  • covers the pros/cons and what the techniques are typically used for
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the conference program for the High-Performance Graphics has been released
  • will take place between July 26 to 28 in Denver
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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.).
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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  
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the latest version of Renderdoc includes a custom and improved DXIL disassembler
  • additionally lists the improvements for SM6.6 feature support
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the article explains an approach to implementing Sun Beams using Billboarding techniques
  • implementation is shown using the visual shading language of Unity
  • archive / summary

  • 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
  • archive / summary

  • 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  
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • AMD released documentation for the Micro engine and the RDNA 3 ISA
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the article provides a full explanation of the derivation of multiple-importance sampling
  • explains the different components and how to combine them correctly
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • a new graphics programming conference to happen in Breda (Netherlands) in November
  • currently looking for speaker and master class proposals
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the latest version adds support for Slang with Vulkan, additional extensions support, D3D12 Pixel history support, and many bug fixes
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the article discusses updates in the Nvidia developer tools
  • covers new debugging capabilities, improved performance collection, and profiling tools
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the article provides an overview of the announcements AMD made during GDC
  • additionally provides links to the slides and videos of the presentations
  • archive / summary

  • 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
  • archive / summary

  • the article provides a suggested collection of resources for beginners in graphics programming
  • covers mathematics, working with APIs, and writing shaders
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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.
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the short video tutorial explains how to create and destroy a surface handle from a GLTF window
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the article explains the extension method to gradient descents called Adam
  • provided implementation is shown in C++
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the blogpost discusses the changes AMD made to LLVM
  • these changes might indicate hardware changes coming for the upcoming RDNA4 generation
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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.
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • the video tutorial presents several use cases that vertex offset enables
  • shows how to implement the techniques in Unity and Unreal Engine
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary

  • 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
  • archive / summary