├── .eslintrc.js ├── .github └── workflows │ └── main.yml ├── .gitignore ├── .npmrc ├── .vscode └── settings.json ├── LICENSE ├── README.md ├── assets ├── diary-svgrepo-com.svg ├── github.svg ├── question-svgrepo-com.svg ├── search-heart-fill.svg └── search-heart.svg ├── entries ├── GI │ ├── gibs.md │ ├── large_scale_gi_activision.md │ └── radiance_caching_lumen.md ├── antialiasing-upscaling │ ├── FSR1.md │ └── FSR2.md ├── deferred │ └── adventures_deferred_texturing.md ├── gpu │ └── efficient_use_of_gpu_memory.md ├── lighting │ ├── real_time_samurai_cinema.md │ └── variable_rate_compute_shaders_xsx.md ├── optimization │ ├── rendering_doom_eternal.md │ └── software_vrs.md ├── rasterization │ ├── geometry_rendering_activision.md │ └── nanite.md ├── raytracing │ └── spatiotemporal_reservoir_resampling.md ├── rendering_equation.md ├── shaders │ └── shader_permutation_problem.md ├── shading │ └── preintegrated_skin_shading.md ├── shadows │ └── shadows_of_cold_war.md └── terrain │ └── terrain_concurrent_binary_trees.md ├── entry_template.md ├── index.html ├── package-lock.json ├── package.json ├── project.sublime-project ├── scripts ├── build.js └── color_conversion.js ├── src ├── main.css └── main.js └── tailwind.config.js /.eslintrc.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | "env": { 3 | "browser": true, 4 | "es2021": true 5 | }, 6 | "extends": "eslint:recommended", 7 | "parserOptions": { 8 | "ecmaVersion": "latest", 9 | "sourceType": "module" 10 | }, 11 | "rules": { 12 | "no-undef": [0], 13 | "max-len": [2, { "ignoreComments": false }], 14 | "indent": [2, 2], 15 | "no-unused-vars": [0], 16 | "brace-style": [2] 17 | }, 18 | } 19 | -------------------------------------------------------------------------------- /.github/workflows/main.yml: -------------------------------------------------------------------------------- 1 | # This is a basic workflow to help you get started with Actions 2 | 3 | name: CI 4 | 5 | # Controls when the workflow will run 6 | on: 7 | # Triggers the workflow on push or pull request events but only for the main branch 8 | push: 9 | branches: [ main ] 10 | 11 | # Allows you to run this workflow manually from the Actions tab 12 | workflow_dispatch: 13 | 14 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel 15 | jobs: 16 | # This workflow contains a single job called "build" 17 | build: 18 | # The type of runner that the job will run on 19 | runs-on: ubuntu-latest 20 | 21 | # Steps represent a sequence of tasks that will be executed as part of the job 22 | steps: 23 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it 24 | - uses: actions/checkout@v3 25 | 26 | - name: Setup Node.js environment 27 | uses: actions/setup-node@v3.1.0 28 | with: 29 | # Version Spec of the version to use. Examples: 12.x, 10.15.1, >=10.15.0 30 | node-version: 16.x 31 | # Target architecture for Node to use. Examples: x86, x64. Will use system architecture by default. 32 | architecture: x64 33 | # Used to specify a package manager for caching in the default directory. Supported values: npm, yarn, pnpm 34 | cache: npm 35 | # Used to specify the path to a dependency file: package-lock.json, yarn.lock, etc. Supports wildcards or a list of file names for caching multiple dependencies. 36 | cache-dependency-path: package-lock.json 37 | - run: npm install 38 | 39 | - name: Push to deploy branch 40 | run: | 41 | git config --global user.email "deploy@donotemail.com" 42 | git config --global user.name "PaperBug Deploy Action" 43 | git fetch origin 44 | git checkout deploy 45 | git reset --hard main 46 | npm run build 47 | npm run tailwind 48 | git add -f dist 49 | git commit -m 'Automated deploy' 50 | git push origin deploy -f 51 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | dist 3 | *.sublime-workspace 4 | -------------------------------------------------------------------------------- /.npmrc: -------------------------------------------------------------------------------- 1 | engine-strict=true -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "editor.defaultFormatter": "rvest.vs-code-prettier-eslint", 3 | "editor.formatOnSave": true, 4 | "[javascript]": { 5 | "editor.defaultFormatter": "vscode.typescript-language-features" 6 | }, 7 | "eslint.format.enable": true, 8 | "editor.tabSize": 2, 9 | "[html]": { 10 | "editor.defaultFormatter": "vscode.html-language-features" 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2022 Jeremy Ong 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 4 | 5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 6 | 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 8 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # [Paper Bug](https://jeremyong.com/paperbug) 2 | 3 | _CONTRIBUTIONS WANTED_ 4 | 5 | ## What is this? 6 | 7 | The idea is to have an annotated and easily searchable repository of papers, presentations, articles, etc. 8 | 9 | ## How can I help? 10 | 11 | To run the site locally, you must: 12 | 13 | - Clone this repository 14 | - Install dependencies 15 | - Ensure you have `node` and `npm` in your path (installing node will install the latter) 16 | - Run `npm i` in this repository 17 | - Run `npm run start` in a terminal to start a live server and several utilities that will regenerate files when content changes 18 | 19 | The site is a set of markdown files in the `entries/` folder. You can place entry files anywhere you like in this folder, and name them however you like. 20 | 21 | The index is built from the front-matter at the top of the markdown file, which is parsed as YAML. Be sure that the front-matter contains at least the year, authors, title, and url. 22 | 23 | The contents of the markdown can contain LaTeX delimited by dollar signs (rendered using KaTeX), arbitrary HTML, and typical markdown elements. 24 | 25 | ## Are there guidelines for adding entries? 26 | 27 | An ideal entry: 28 | 29 | - is relatively concise 30 | - mentions the important ideas 31 | - links any supporting materials needed 32 | - mentions if a newer paper, result, or code supersedes the contents of the entry 33 | 34 | ## Why is it called "Paper Bug"? 35 | 36 | In Korean, the word for "bug" (벌레) is a suffix sometimes used to indicate that an individual is an enthusiast about a particular topic. Sort of like "bookworm" but it can be applied to other things also in a colloquial setting. 37 | -------------------------------------------------------------------------------- /assets/diary-svgrepo-com.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 7 | 9 | 11 | 12 | 14 | 16 | 18 | 20 | 21 | 23 | 25 | 29 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | -------------------------------------------------------------------------------- /assets/github.svg: -------------------------------------------------------------------------------- 1 | GitHub -------------------------------------------------------------------------------- /assets/question-svgrepo-com.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 7 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | -------------------------------------------------------------------------------- /assets/search-heart-fill.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /assets/search-heart.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /entries/GI/gibs.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Global Illumination Based on Surfels 3 | authors: 4 | - Henrik Halen 5 | - Andreas Brinck 6 | - Kyle Hayward 7 | - Xiangshun Bei 8 | year: 2021 9 | conference: SIGGRAPH 10 | url: http://advances.realtimerendering.com/s2021/SIGGRAPH%20Advances%202021%20-%20Surfel%20GI.pdf 11 | tags: 12 | - Global Illumination 13 | - GI 14 | - Raytracing 15 | - Real-Time GI 16 | --- 17 | 18 | 19 | 20 | GIBS is a real-time raytracing solution for global illumination. The talk describes: 21 | 22 | - The acceleration structure used to cache surfel data 23 | - The use of screen-space to keep memory costs predictable 24 | - Handling dynamic/skinned geometry and transparency 25 | - Spatio-temporal filtering 26 | - Ray guiding and ray binning 27 | -------------------------------------------------------------------------------- /entries/GI/large_scale_gi_activision.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Large-Scale Global Illumination at Activision 3 | url: https://advances.realtimerendering.com/s2021/Silvennoinen%20-%20SIGGRAPH%202021%20Advances_slim.pptx 4 | authors: 5 | - Ari Silvennoinen 6 | year: 2021 7 | conference: SIGGRAPH 8 | tags: 9 | - Global Illumination 10 | - GI 11 | - Probes 12 | - Spherical Harmonics 13 | --- 14 | 15 | 16 | 17 | This talk presents work to implement precomputed GI large-scale maps used for Call of Duty: Warzone 18 | 19 | * Discusses the probe-based approach used for storing GI data throughout the map, including an warped distribution for adaptive placement of probes along the terrain 20 | * Presents a novel compression scheme called "Moving Basis Decomposition" for reducing the storage space for GI by a ratio of 44:1 21 | * Uses a simple technique to prevent leaking between probes in the exterior and interior of buildings 22 | * Discusses approaches to contraining spherical harmonics light probe data to avoid ringing artifacts 23 | -------------------------------------------------------------------------------- /entries/GI/radiance_caching_lumen.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Radiance Caching for Real-Time Global Illumination 3 | url: https://advances.realtimerendering.com/s2021/Radiance%20Caching%20for%20real-time%20Global%20Illumination%20(SIGGRAPH%202021).pptx 4 | authors: 5 | - Daniel Wright 6 | year: 2021 7 | conference: SIGGRAPH 8 | tags: 9 | - Global Illumination 10 | - GI 11 | - Raytracing 12 | - Real-Time GI 13 | --- 14 | 15 | 16 | 17 | Presents the Final Gather system used for the real-time GI system (Lumen) built into Unreal Engine 5 18 | 19 | * A screen-space radiance cache is built at a low resolution (1/16), which is generated by tracing rays with importance sampling at 0.5 rays per pixel 20 | * Radiance is stored in an 8x8 octahedral atlas with a border, and probes use adaptive placement with Hierarchal Refinement 21 | * Structured importance sampling is used within the octahedral quadtree structure to improve quality 22 | * Probes are filtered in cache space, not in screen space, using depth and angle weighting to reduce leaking 23 | * The screen-space cache is augmented with a world space cache that represents stable distant lighting 24 | * The final integration is performed at full resolution using a temporal filter and a full-resolution bent normal 25 | -------------------------------------------------------------------------------- /entries/antialiasing-upscaling/FSR1.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Improved Spatial Upscaling through FidelityFX Super Resolution for Real-Time Game Engines 3 | url: http://advances.realtimerendering.com/s2021/Unity%20AMD%20FSR%20-%20SIGGRAPH%202021.pdf 4 | authors: 5 | - Timothy Lottes 6 | - Kleber Garcia 7 | year: 2021 8 | conference: SIGGRAPH 9 | tags: 10 | - upscaling 11 | - image processing 12 | --- 13 | 14 | 15 | 16 | Two part presentation covering techniques and optimizations used in the FSR1 algorithm, as well as the integration experience into Unity's HDRP. 17 | 18 | Note that FSR1 is superseded by [FSR2](https://community.amd.com/t5/gaming/announcing-and-first-look-at-amd-fidelityfx-super-resolution-2-0/ba-p/516395), with the primary disadvantage of FSR1 being that the input image needs to be anti-aliased already. 19 | -------------------------------------------------------------------------------- /entries/antialiasing-upscaling/FSR2.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: FidelityFX Super Resolution 2.0 3 | url: https://www.youtube.com/watch?v=97JIldpUGE4&list=PLx15eYqzJifdT1M-vOTz74fwdqHIlMrVc&index=6&t=1829s 4 | authors: 5 | - Colin Riley 6 | - Thomas Arcila 7 | year: 2022 8 | conference: GDC 9 | tags: 10 | - upscaling 11 | - temporal antialiasing 12 | - image processing 13 | - motion vectors 14 | - TAA 15 | --- 16 | 17 | 18 | 19 | This presentation describes a number of improvements over FSR 2.0's predecessor. It contains a useful overview of heuristics needed to achieve a high quality TAA image, and describes solutions for a number of problems typical in this space: 20 | 21 | - Preserving thin features 22 | - Estimating the contribution of a sample in a frame 23 | - Blending the contributions of multiple samples 24 | - Resampling contributions during upscale 25 | - Motion vector dilation based on MV with nearest depth to the current sample 26 | - Avoiding ghosting (best effort) due to disocclusion or shading changes 27 | -------------------------------------------------------------------------------- /entries/deferred/adventures_deferred_texturing.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Adventures with Deferred Texturing in 'Horizon Forbidden West' 3 | url: https://www.gdcvault.com/play/1027553/Adventures-with-Deferred-Texturing-in 4 | authors: 5 | - James McLaren 6 | year: 2022 7 | tags: 8 | - Optimization 9 | - Foliage 10 | - Deferred 11 | - Visibility Buffer 12 | - Variable Rate Shading 13 | - VRS 14 | conference: SIGGRAPH 15 | --- 16 | 17 | ![](https://pbs.twimg.com/media/FOiwlP-VgAQQ3Sh?format=png) 18 | 19 | Describes how the rendering of alpha-tested foliage was optimized by using a deferred texturing renderer combined with a software VRS system. 20 | 21 | * Dense alpha-tested foliage suffered from low pixel shader quad occupancy, and the depth prepass requires transforming vertices twice 22 | * A visibility buffer approach outputs primitive IDs to a render target that can be used to shader during a compute shader pass, avoid quad occupancy issues 23 | * Pixels within 128x128 tiles are binned by shader program and launched as complete waves using multiple indirect dispatches 24 | * A pipelined system for filling a ring buffer with transformed vertices is used as a cache for the shading passes 25 | * Shading rate is also encoded in the visibility buffer, which feeds into a compute-based VRS system for scheduling and broadcasting shading results 26 | 27 | A video recording is available on the GDC Vault with paid membersip. 28 | -------------------------------------------------------------------------------- /entries/gpu/efficient_use_of_gpu_memory.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Efficient Use of GPU Memory in Modern Games 3 | url: https://gpuopen.com/wp-content/uploads/2022/01/Efficient-Use-of-GPU-Memory-Digital-Dragons-2021.pdf 4 | authors: 5 | - Adam Sawicki 6 | year: 2022 7 | conference: Digital Dragons 8 | tags: 9 | - VRAM 10 | - GPU memory 11 | - Smart Access Memory 12 | - ReBAR 13 | - BAR 14 | --- 15 | 16 | 17 | 18 | Major takeaways: 19 | 20 | - Explores different memory heaps available 21 | - In particular, covers "aperture memory" and SAM (smart access memory) as device-local memory that is also host-visible (exposed in Vulkan) 22 | - Covers some common pitfalls, such as reading back write-combined (WC) memory 23 | -------------------------------------------------------------------------------- /entries/lighting/real_time_samurai_cinema.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Real-Time Samurai Cinema: Lighting, Atmosphere, and Tonemapping in Ghost of Tsushima" 3 | authors: 4 | - Jasmin Patry 5 | url: https://advances.realtimerendering.com/s2021/jpatry_advances2021/index.html 6 | year: 2021 7 | conference: SIGGRAPH 8 | tags: 9 | - Tone Mapping 10 | - Atmospheric Scattering 11 | - Lighting 12 | - GI 13 | - Dynamic Time Of Day 14 | - Skies 15 | - Volumetrics 16 | - Probes 17 | - Spherical Harmonics 18 | --- 19 | 20 | 21 | 22 | Presents a selection of graphics techniques from the PlayStation 4 exclusive "Ghost of Tsushima", focusing on indirect lighting, atmospheric effects, and tone mapping. 23 | 24 | * Discusses how the game used a mixture of low-density regular grids of spherical harmonics probes combined with dense tetrahedral meshes for areas with more complex geometry (such as villages and castles) 25 | * Used a combination of precomputed and runtime probe information combined with runtime updates to handle dynamic time-of-day 26 | * Applied an interior/exterior mask as an additional probe interpolation weight to reduce leaking between probes 27 | * Computed indirect specular by dynamically re-lighting sparse cubemap probes containing G-Buffer informations, combined with shadow trace through captured cube map depth 28 | * Used precomputed LUT textures to apply atmospheric lighting and scattering, with calculations performed in a custom Rayleigh color space 29 | * Described how the Bilateral Grid algorithm was used to apply localized tone mapping, along with a custom color space for achieving desired roll-off behavior. 30 | -------------------------------------------------------------------------------- /entries/lighting/variable_rate_compute_shaders_xsx.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Variable Rate Compute Shaders - Halving Deferred Lighting Time 3 | authors: 4 | - Martin Fuller 5 | url: https://www.youtube.com/watch?v=Sswuj7BFjGo 6 | year: 2022 7 | conference: GDC 8 | tags: 9 | - VRS 10 | - Variable Rate Shading 11 | - Deferred Lighting 12 | - Compute 13 | --- 14 | 15 | 16 | 17 | Prior to this talk, the primary application of VRS was a forward lit pipeline, since VRS reduces the PS invocation rate. The main idea here is to apply VRS to a deferred lighting pipeline, lighting fewer pixels than there are in the raster, and "hole-filling" the results to each 1x2, 2x1, or 2x2 block (it's mentioned that block sizes larger than 2x2 impacted quality too much). 18 | 19 | One important topic covered in this talk is handling coverage during the hole-filling phase. The abbreviated pipeline described in the talk: 20 | 21 | 1. Determine which pixel values are duplicated from the VRS buffer (and respect coverage) 22 | 2. Sparsely light the pixels (e.g. 1x2 and 2x1 blocks are lit at half-rate, 2x2 block at quarter-rate) 23 | 3. Fill holes 24 | 4. (Optionally) Each frame, rotate which pixel is lit and leverage TAA to approximate full-rate signal 25 | -------------------------------------------------------------------------------- /entries/optimization/rendering_doom_eternal.md: -------------------------------------------------------------------------------- 1 | --- 2 | # these are required 3 | title: Rendering the Hellscape of Doom Eternal 4 | urls: 5 | - https://advances.realtimerendering.com/s2020/RenderingDoomEternal_compressed.pptx 6 | - https://advances.realtimerendering.com/s2020/RenderingDoomEternal.pdf 7 | - https://advances.realtimerendering.com/s2020/index.html 8 | authors: 9 | - Jean Geffroy 10 | - Yixin Wang 11 | - Axel Gneiting 12 | year: 2020 13 | tags: 14 | - Optimization 15 | - Decals 16 | - Water 17 | - Clustered Rendering 18 | - Culling 19 | conference: SIGGRAPH 20 | --- 21 | 22 | ![](https://advances.realtimerendering.com/s2020/index_files/image011.gif) 23 | 24 | This presentation covers several rendering techniques used to optimize performance and implement new features for the idTech 7 engine used for Doom: Eternal 25 | 26 | * A compute-based software rasterizer was written to improve cluster culling granularity for lights and decals 27 | * A new technique called "geometry decals" was used to allow for many tiny decals to be added to meshes 28 | * Geometry caches were generated from Alembic caches to handle complex vertex animations 29 | * A new system was implemented to blend up to 4 material stacks within a shader using vertex weights and height maps 30 | * A compute-based geometry processing pipeline was used to perform frustum and occlusion culling of triangles, and also batch together small models into a single draw 31 | * Finally, a water rendering system was developed that included displacement, screen-space reflections, dynamic hit effects, caustics, and flowing surfaces 32 | -------------------------------------------------------------------------------- /entries/optimization/software_vrs.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Software-Based Variable Rate Shading in Call of Duty: Modern Warfare" 3 | url: https://advances.realtimerendering.com/s2020/Drobot-SIGGRAPH_2020_VRS_Final.pptx 4 | authors: 5 | - Michal Drobot 6 | year: 2020 7 | conference: SIGGRAPH 8 | tags: 9 | - Variable Rate Shading 10 | - VRS 11 | - Optimization 12 | --- 13 | 14 | ![](https://advances.realtimerendering.com/s2020/index_files/image010.jpg) 15 | 16 | Presents the software implementation of variable rate shading (VRS) used by Activision in Call of Duty: Modern Warfare, which does not leverage or require the hardware functionality for VRS that's available through D3D12 and Vulkan. 17 | 18 | * Provides an overview of hardware VRS available in recent GPUs, which can set pixel shading rate for 8x8 tiles in screen space as well as per-primitive or per-draw 19 | * Describes how hardware VRS can suffer from quad overshading (poor quad occupancy) due to effectively decreasing triangle size in screen space 20 | * Presents an alternative approach that stores swizzled/intereaved samples in MSAA buffers, where shading rate can be varied at a fine granularity by using the stencil buffer to cull MSAA subsamples. This approach also does not suffer from the same issues with quad occupancy. 21 | * Describes a full implementation of the alternative software approach, including a screen-space analysis pass that dynamically determines the appropriate shading rate based a reprojection of the previous frame 22 | -------------------------------------------------------------------------------- /entries/rasterization/geometry_rendering_activision.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Geometry Rendering Pipeline Architecture at Activision 3 | url: http://enginearchitecture.realtimerendering.com/downloads/reac2021_geometry_pipeline_rendering_architecture.pptx 4 | authors: 5 | - Michal Drobot 6 | year: 2021 7 | conference: SIGGRAPH 8 | tags: 9 | - rendering 10 | - meshlets 11 | - culling 12 | - forward+ 13 | - deferred 14 | - visibility buffer 15 | - vrs 16 | --- 17 | 18 | 19 | 20 | When deciding how to rasterize meshes, there are quite a number of degrees of freedom. This talk summarizes a few options available, from a full forward-plus style renderer, to a fully deferred renderer, to the usage of an "intermediate" approach using a visibility buffer. 21 | 22 | The talk covers an opinionated approach to meshlet clustering, index packing, culling, and other details for laying down the visibility buffer with an eye toward variable rate shading done in software. 23 | -------------------------------------------------------------------------------- /entries/rasterization/nanite.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: A Deep Dive into Nanite Virtualized Geometry 3 | authors: 4 | - Brian Karis 5 | - Rune Stubbe 6 | - Graham Wihlidal 7 | url: http://advances.realtimerendering.com/s2021/Karis_Nanite_SIGGRAPH_Advances_2021_final.pdf 8 | year: 2021 9 | conference: SIGGRAPH 10 | tags: 11 | - software rasterization 12 | - culling 13 | - virtualized geometry 14 | - shadows 15 | --- 16 | 17 | 18 | 19 | In addition to virtualized shadows, a compute based hierarchical culling system, a software rasterizer, and a host of other techniques, this talk introduces a novel technique for transitioning between LOD levels in a mesh without alpha cross-fading, dithering, or other such methods. 20 | -------------------------------------------------------------------------------- /entries/raytracing/spatiotemporal_reservoir_resampling.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Spatiotemporal reservoir resampling for real-time ray tracing with dynamic direct lighting 3 | url: https://research.nvidia.com/publication/2020-07_Spatiotemporal-reservoir-resampling 4 | authors: 5 | - Benedict Bitterli 6 | - Chris Wyman 7 | - Matt Pharr 8 | - Peter Shirley 9 | - Aaron Lefohn 10 | - Wojciech Jarosz 11 | year: 2020 12 | conference: SIGGRAPH 13 | tags: 14 | - Raytracing 15 | - ReSTIR 16 | - Monte Carlo 17 | - Lighting 18 | --- 19 | 20 | Demonstrates the use of the ReSTIR reservoir sampling technique to interactively sample direct lighting from thousands to millions of dynamic emissive triangles. 21 | 22 | Leverages a biased estimator to further improve the results as shown below with a 35-65x speedup (albeit with some energy loss). 23 | 24 | ![teaser](https://research.nvidia.com/sites/default/files/publications/piratesTeaser_nvrSite_scaled.png) 25 | 26 | -------------------------------------------------------------------------------- /entries/rendering_equation.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: The rendering equation 3 | url: http://www.cse.chalmers.se/edu/year/2011/course/TDA361/2007/rend_eq.pdf 4 | authors: 5 | - Kajiya, James T. 6 | year: 1986 7 | conference: SIGGRAPH 8 | tags: 9 | - general 10 | --- 11 | 12 | $$L_o(\mathbf{x}, \omega_o, \lambda, t) = L_e(\mathbf{x}, \omega_o, \lambda, t) + \int_\Omega f_r(\mathbf{x}, \omega_i, \omega_o, \lambda, t)L_i(\mathbf{x}, \omega_i, \lambda, t)(\omega_i \cdot \mathbf{n})d\omega_i$$ 13 | 14 | The integral above (with notation from wikipedia instead of as presented in the original paper) encapsulates effectively all of rendering as the transport of light scattered from a surface as seen in the image below. 15 | 16 | ![Rendering equation](https://upload.wikimedia.org/wikipedia/commons/thumb/d/d1/Rendering_eq.png/300px-Rendering_eq.png) 17 | -------------------------------------------------------------------------------- /entries/shaders/shader_permutation_problem.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: The Shader Permutation Problem 3 | authors: 4 | - MJP 5 | urls: 6 | - https://therealmjp.github.io/posts/shader-permutations-part1/ 7 | - https://therealmjp.github.io/posts/shader-permutations-part2/ 8 | year: 2021 9 | tags: 10 | - Shaders 11 | - Permutations 12 | - Variants 13 | - Materials 14 | --- 15 | 16 | This is a two part series describing the problem statement and possible solutions for shader permutations. 17 | 18 | The problem statement is described in pretty gory detail. Shaders permeate the alpha and omega of graphics programming, affecting iteration time, performance, load times, memory and more. The discussion of "what variants to even compile" is a multi-faceted problem (shader size, compile times, register pressure, ILP, feature requirements, and more). 19 | 20 | The solution described at Ready At Dawn is to rely on uber-shaders with dynamic branching for all available options and swap in specialized shaders as they become ready. Specialization constants as provided in Vulkan and Metal are discussed as a possible avenue for compiling static branches at runtime, with the caveat that it's unclear whether CSE and CF actually will occur (common sub-expression elimination + constant folding). A nice table of practical options is provided also (with discussion): 21 | 22 | - Compile what you need 23 | - Specialize at runtime 24 | - Cache material evaluation 25 | - Just branch/loop at runtime (especially for uniform branches) 26 | - Split the pipeline (e.g. deferred rendering) 27 | - Link offline 28 | - Dynamic function calls (only works with RT) 29 | -------------------------------------------------------------------------------- /entries/shading/preintegrated_skin_shading.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Pre-Integrated Skin Shading 3 | url: https://advances.realtimerendering.com/s2011/Penner%20-%20Pre-Integrated%20Skin%20Rendering%20(Siggraph%202011%20Advances%20in%20Real-Time%20Rendering%20Course).pptx 4 | authors: 5 | - Eric Penner 6 | year: 2011 7 | conference: SIGGRAPH 8 | tags: 9 | - subsurface scattering 10 | - skin 11 | --- 12 | 13 | ![](https://advances.realtimerendering.com/s2011/index_files/image022.png) 14 | 15 | This presentation shows a technique for rendering skin with subsurface scattering that's compatible with a forward renderer. 16 | 17 | Key takeaways: 18 | 19 | * The technique can approximate scattering from punctual light source directly in a pixel/fragment shader with a combination of loopup textures, normal map mip biasing, and mesh curvature 20 | * Does not rely on [texture-space rendering](https://developer.nvidia.com/gpugems/gpugems3/part-iii-rendering/chapter-14-advanced-techniques-realistic-real-time-skin), [screen-space scattering](http://advances.realtimerendering.com/s2018/Efficient%20screen%20space%20subsurface%20scattering%20Siggraph%202018.pdf), or ray tracing 21 | * The scattering effect utilizes a pre-computed 3D lookup texture to approximate scattering for a single skin type, as well as an additional 2D lookup texture for approximating scattering across a shadow penumbra 22 | * The technique relies on pixel shader derivatives to compute the local surface curvature, which automatically adapts to mesh deformation but can result in visible discontinuities at triangle edges. 23 | * Like most real-time techniques for subsurface scattering, it does not handle translucency from light that enters a surface and then exits on the other side (such as light scattering through the ears) 24 | 25 | This technique was also presented as an article in GPU Pro 2. 26 | 27 | Related articles: 28 | 29 | * [https://blog.selfshadow.com/publications/s2013-shading-course/rad/s2013_pbs_rad_notes.pdf](https://blog.selfshadow.com/publications/s2013-shading-course/rad/s2013_pbs_rad_notes.pdf) 30 | * [http://c0de517e.blogspot.com/2011/09/mathematica-and-skin-rendering.html](http://c0de517e.blogspot.com/2011/09/mathematica-and-skin-rendering.html) 31 | * [http://simonstechblog.blogspot.com/2015/02/pre-integrated-skin-shading.html](http://simonstechblog.blogspot.com/2015/02/pre-integrated-skin-shading.html) 32 | * [https://therealmjp.github.io/posts/sss-intro/](https://therealmjp.github.io/posts/sss-intro/) 33 | * [https://therealmjp.github.io/posts/sss-sg/](https://therealmjp.github.io/posts/sss-sg/) -------------------------------------------------------------------------------- /entries/shadows/shadows_of_cold_war.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: "Shadows of Cold War: A Scalable Approach to Shadowing" 3 | url: https://www.activision.com/cdn/research/CWS.pptx 4 | authors: 5 | - Kevin Myers 6 | year: 2021 7 | conference: GDC 8 | tags: 9 | - Bindless 10 | - Shadows 11 | - Raytracing 12 | - Denoising 13 | --- 14 | 15 | Historically, shadows are often spoken about with respect to a "shadow atlas," meaning that a number of shadow maps for lights in the scene are packed together in a larger atlas. This talk points out quite correctly that with bindless texture arrays, you can free yourself of the difficulties associated with addressing textures within atlases. This flexible addressing scheme means you can allocate maps with arbitrary resolution based on the detail needed. 16 | 17 | Other main takeaways addressed in this talk include: 18 | 19 | - Some iteration was done to the static shadow cache solution employed in previous activision titles ([link](https://www.activision.com/cdn/research/2017_DD_Rendering_of_COD_IW.pdf)) with extensions made when bindless is available 20 | - Compared to previous titles, offline baking is only done for the 3rd split 21 | - Shadow map compression and decompression 22 | - Depth-aware filtering (dilated PCF) to provide contact hardening 23 | - Usage of ray-tracing/denoising to render shadows (transparencies use SM fallback, spatial-temporal denoiser from NVIDIA) 24 | -------------------------------------------------------------------------------- /entries/terrain/terrain_concurrent_binary_trees.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Experimenting With Concurrent Binary Trees for Large-scale Terrain Rendering 3 | url: https://advances.realtimerendering.com/s2021/Siggraph21%20Terrain%20Tessellation.pdf 4 | authors: 5 | - Thomas Deliot 6 | - Jonathan Dupuy 7 | - Kees Rijnen 8 | - Xiaoling Ya 9 | year: 2021 10 | conference: SIGGRAPH 11 | tags: 12 | - terrain 13 | - tessellation 14 | - subdivision 15 | --- 16 | 17 | 18 | 19 | Presents ongoing research to develop a large-scale terrain renderer for tje Unity game engine 20 | 21 | * Presents a novel adaptive tessellation scheme that's run entirely on the GPU 22 | * Utilizes a recursive subdivision scheme known as "Longest Edge Bisection" that divides a triangle along its longest edge and effectively forms a binary tree 23 | * Does not utilize tessellation shader stages, only uses compute and vertex shaders 24 | * Discusses the integration into Unity -------------------------------------------------------------------------------- /entry_template.md: -------------------------------------------------------------------------------- 1 | --- 2 | # these are required 3 | title: 4 | url: 5 | authors: 6 | - 7 | year: 8 | tags: 9 | - 10 | 11 | # these are optional 12 | # conference: 13 | 14 | # for multiple URLs, use "urls:" followed by a dashed list 15 | --- 16 | 17 | 20 | 21 | 24 | 25 | 28 | 29 | 32 | -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | Paper Bug 7 | 8 | 9 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 19 | 20 | 21 | 24 | 25 | 26 | 29 | 30 | 31 | 74 | 75 | 76 | 77 | 78 | 97 |
98 |
99 | 100 | 153 | 154 | 155 | 156 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "paperbug", 3 | "version": "1.0.0", 4 | "description": "", 5 | "main": "main.js", 6 | "scripts": { 7 | "build": "node scripts/build.js", 8 | "build-watch": "npm run build && onchange \"entries/**/*.md\" \"scripts/**/*.js\" -- node scripts/build.js", 9 | "tailwind": "tailwindcss -m -i ./src/main.css -o ./dist/output.css", 10 | "tailwind-watch": "tailwindcss -m -i ./src/main.css -o ./dist/output.css --watch", 11 | "server": "live-server", 12 | "start": "concurrently --kill-others \"npm run tailwind-watch\" \"npm run build-watch\" \"npm run server\"" 13 | }, 14 | "repository": { 15 | "type": "git", 16 | "url": "git+https://github.com/jeremyong/paperbug.git" 17 | }, 18 | "author": "Jeremy Ong", 19 | "license": "MIT", 20 | "bugs": { 21 | "url": "https://github.com/jeremyong/paperbug/issues" 22 | }, 23 | "homepage": "https://github.com/jeremyong/paperbug#readme", 24 | "devDependencies": { 25 | "concurrently": "^7.1.0", 26 | "eslint": "^8.12.0", 27 | "live-server": "^1.1.0", 28 | "markdown-it": "^12.3.2", 29 | "markdown-it-front-matter": "^0.2.3", 30 | "onchange": "^7.1.0", 31 | "tailwindcss": "^3.0.23", 32 | "yaml": "^1.10.2" 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /project.sublime-project: -------------------------------------------------------------------------------- 1 | { 2 | "folders": 3 | [ 4 | { 5 | "path": "entries/", 6 | "name": "entries" 7 | }, 8 | { 9 | "path": "src", 10 | "name": "src" 11 | }, 12 | { 13 | "path": "scripts", 14 | "name": "scripts" 15 | } 16 | ], 17 | "settings": 18 | { 19 | "trim_trailing_white_space_on_save": true, 20 | "ensure_newline_at_eof_on_save": true, 21 | "translate_tabs_to_spaces": true, 22 | "tab_size": 2, 23 | }, 24 | "build_systems": 25 | [ 26 | { 27 | "name": "Run Local Server", 28 | "cmd": ["npm", "run", "start"], 29 | "cancel": ["killall", "node"], 30 | "windows": { 31 | "cmd": ["C:\\Program Files\\nodejs\\npm.cmd", "run", "start"], 32 | "cancel": ["taskkill", "/f", "/im", "node.exe"] 33 | } 34 | }, 35 | { 36 | "name": "Kill Local Server", 37 | "cmd": ["killall", "node"], 38 | "windows": { 39 | "cmd": ["taskkill", "/f", "/im", "node.exe"] 40 | } 41 | } 42 | ] 43 | } 44 | -------------------------------------------------------------------------------- /scripts/build.js: -------------------------------------------------------------------------------- 1 | // Parse all documents present in the "entries" folder and emit HTML fragments 2 | // and a searchable index 3 | 4 | const promisify = require('util').promisify; 5 | const fs = require('fs'); 6 | const path = require('path'); 7 | const readdir = promisify(fs.readdir); 8 | const readFile = promisify(fs.readFile); 9 | const writeFile = promisify(fs.writeFile); 10 | const stat = promisify(fs.stat); 11 | const md = require('markdown-it'); 12 | const front_matter = require('markdown-it-front-matter'); 13 | const YAML = require('yaml'); 14 | const crypto = require('crypto'); 15 | const { okhsl_to_srgb, okhsv_to_srgb } = require('./color_conversion'); 16 | 17 | const outputdir = path.resolve(__dirname, '..', 'dist'); 18 | 19 | try { 20 | fs.statSync(outputdir); 21 | } catch (e) { 22 | fs.mkdirSync(outputdir); 23 | } 24 | 25 | // This script finds all files in the "entries" folder recursively and 26 | // loads and parses them asynchronously. When this count reaches 0, the last 27 | // entry to process finalizes the index 28 | let entry_count = 1; 29 | let entries = []; 30 | 31 | const required_fields = ['title', 'year']; 32 | 33 | function fnv1a(value) { 34 | // eslint-disable-next-line max-len 35 | // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash 36 | let seed = 4; 37 | for (let i = 0; i !== value.length; ++i) { 38 | seed = ((seed * 16777619) ^ value.charCodeAt(i)) >>> 0; 39 | } 40 | // JS bitwise operations are interpreted as signed, so force an unsigned 41 | // interpretation 42 | return seed >>> 0; 43 | } 44 | 45 | function tag_to_rgb(tag) { 46 | const hash = fnv1a(tag.toLowerCase()); 47 | let color = okhsl_to_srgb(hash / 0xffffffff, 0.5, 0.7); 48 | color = color.map(v => Math.round(v)); 49 | return color; 50 | } 51 | 52 | // Map from tags to colors 53 | const tags = { 54 | '...': [225, 225, 225] 55 | }; 56 | 57 | function emit_entry(entry, render) { 58 | // Hash entry title as the identifier 59 | entry.id = crypto.createHash('md5').update(entry.title).digest('hex') 60 | + `_${entry.year}`; 61 | 62 | entries.push(entry); 63 | entry.offset = entries.length - 1; 64 | 65 | if (!entry.tags) { 66 | console.log(`Entry ${entry.title} missing tags!`); 67 | return; 68 | } 69 | 70 | entry.tags = entry.tags.map(tag => tag.toUpperCase()); 71 | entry.tags = entry.tags.sort((a, b) => a < b ? -1 : 1); 72 | 73 | for (let i = 0; i !== entry.tags.length; ++i) { 74 | if (!tags[entry.tags[i]]) { 75 | tags[entry.tags[i]] = tag_to_rgb(entry.tags[i]); 76 | } 77 | } 78 | console.log(entry.tags, tags); 79 | 80 | writeFile(path.resolve(outputdir, `${entry.id}.txt`), render); 81 | } 82 | 83 | function finalize() { 84 | entries.sort((a, b) => b.year - a.year); 85 | 86 | const data = { 87 | entries, 88 | tags 89 | }; 90 | writeFile(path.resolve(outputdir, 'index.json'), JSON.stringify(data)); 91 | } 92 | 93 | async function process_entry(entry_path) { 94 | const data = await readFile(entry_path, { encoding: 'utf-8' }); 95 | let entry = null; 96 | let render = md({ 97 | html: true 98 | }).use(front_matter, (meta) => { 99 | entry = YAML.parse(meta); 100 | }).render(data); 101 | 102 | render = render.replaceAll('