# Hash-Based Hierarchical Caching and Layered Filtering for Interactive Previews in Global Illumination Rendering

^{1}

^{2}

^{3}

^{4}

^{*}

## Abstract

**:**

## 1. Introduction

## 2. Related Work

## 3. Method

#### 3.1. Cache Structure

- Diffuse illumination for the front and back of each cell as six
`half`values (96 bits); - compressed cell normal (32 bits);
- currently accumulated number of samples (32 bits);
- the frame index denoting when the cell has last been wiped (32 bits).

#### 3.2. Caching

#### 3.3. Reconstruction

- The hash key for the neighboring grid cell may belong to another cell that belongs to the scene’s geometry. In such a case, visual artifacts may occur.
- The hash key for the neighboring grid cell may yield an empty entry in the hash map. In this case, the irradiance value is set to the average of the pixel’s neighbors, i.e., invalid or unsampled pixels resulting from spatial jittering are filled in.

#### 3.4. Layered Filtering

- Path segment length ${D}_{i}={\parallel {\mathbf{x}}_{i+1}-{\mathbf{x}}_{i}\parallel}_{2}$,
- accumulated path length ${D}_{i}^{\sum}={\sum}_{j<i}{D}_{j}+{\parallel {\mathbf{x}}_{i}-{\mathbf{x}}_{i-1}\parallel}_{2}$, serving as an extended depth buffer,
- geometric normal of the current vertex ${\overrightarrow{n}}_{i}$,
- throughput for the next generated ray ${\mathbf{T}}_{i}$,
- shininess of the current material ${\alpha}_{i}$,
- reconstructed diffuse illumination ${\mathbf{E}}_{i}$, and
- diffuse material color (albedo) ${\mathbf{C}}_{i}$.

## 4. Results and Evaluation

#### 4.1. Visual Quality

#### 4.2. Performance

#### 4.3. Memory Requirements

#### 4.4. Comparison to the State-of-the-Art

## 5. Conclusions and Outlook

## Author Contributions

## Funding

## Conflicts of Interest

## Abbreviations

BRDF | Bidirectional Reflectance Distribution Function |

CK | Country Kitchen |

CRF | Caching Resolution Factor |

GI | Global Illumination |

MC | Monte Carlo |

MS-SSIM | Multi-Scale Structural Similarity |

relMSE | Relative Mean-Square Error |

SoA | Streets of Asia |

## References

- Roth, T.; Weier, M.; Bauszat, P.; Hinkenjann, A.; Li, Y. Hash-based Hierarchical Caching for Interactive Previews in Global Illumination Rendering. Comput. Graph. Vis. Comput.
**2019**, 85–93. [Google Scholar] [CrossRef] - Kajiya, J.T. The rendering equation. In Proceedings of the 13th Annual conference on Computer Graphics and Interactive Techniques, Dallas, TX, USA, 18–22 August 1986; pp. 143–150. [Google Scholar]
- Choi, M.G.; Ju, E.; Chang, J.W.; Lee, J.; Kim, Y.J. Linkless Octree Using Multi-Level Perfect Hashing. Comput. Graph. Forum
**2009**, 28, 1773–1780. [Google Scholar] [CrossRef] [Green Version] - Jensen, H.W. Global illumination using photon maps. In Rendering Techniques 96; Springer: Cham, Switzerland, 1996; pp. 21–30. [Google Scholar]
- Spencer, B.; Jones, M.W. Hierarchical Photon Mapping. IEEE Trans. Vis. Comput. Graph.
**2009**, 15, 49–61. [Google Scholar] [CrossRef] [PubMed] [Green Version] - Binder, N.; Fricke, S.; Keller, A. Fast Path Space Filtering by Jittered Spatial Hashing. In ACM SIGGRAPH 2018 Talks; ACM: New York, NY, USA, 2018; pp. 71:1–71:2. [Google Scholar]
- Keller, A.; Dahm, K.; Binder, N. Path Space Filtering. In ACM SIGGRAPH 2014 Talks; ACM: New York, NY, USA, 2014; p. 66:1. [Google Scholar]
- Scherzer, D.; Yang, L.; Mattausch, O.; Nehab, D.; Sander, P.V.; Wimmer, M.; Eisemann, E. Temporal Coherence Methods in Real-Time Rendering. Comput. Graph. Forum
**2012**, 31, 2378–2408. [Google Scholar] [CrossRef] - Ward, G.J.; Rubinstein, F.M.; Clear, R.D. A Ray Tracing Solution for Diffuse Interreflection. In Proceedings of the 15th Annual Conference on Computer Graphics and Interactive Techniques, Atlanta, GA, USA, 1–5 August 1988; pp. 85–92. [Google Scholar]
- Bala, K.; Dorsey, J.; Teller, S. Interactive Ray-Traced Scene Editing Using Ray Segment Trees. In Rendering Techniques’ 99; Lischinski, D., Larson, G.W., Eds.; Springer: Vienna, Austria, 1999; pp. 31–44. [Google Scholar] [CrossRef]
- Walter, B.; Drettakis, G.; Parker, S. Interactive Rendering using the Render Cache. In Rendering Techniques (Proceedings of the Eurographics Workshop on Rendering); Lischinski, D., Larson, G.W., Eds.; Springer-Verlag: Berlin, Germany, 1999; Volume 10, pp. 235–246. [Google Scholar]
- Ward, G.; Simmons, M. The holodeck ray cache: An interactive rendering system for global illumination in nondiffuse environments. ACM Trans. Graph. (TOG)
**1999**, 18, 361–368. [Google Scholar] [CrossRef] - Sloan, P.P.; Kautz, J.; Snyder, J. Precomputed radiance transfer for real-time rendering in dynamic, low-frequency lighting environments. In Proceedings of the 29th Annual Conference on Computer Graphics and Interactive Techniques, San Antonio, TX, USA, 23–26 July 2002; pp. 527–536. [Google Scholar] [CrossRef]
- Tole, P.; Pellacini, F.; Walter, B.; Greenberg, D.P. Interactive global illumination in dynamic scenes. ACM Trans. Graph. (TOG)
**2002**, 21, 537–546. [Google Scholar] [CrossRef] - Bala, K.; Walter, B.; Greenberg, D.P. Combining edges and points for interactive high-quality rendering. ACM Trans. Graph. (TOG)
**2003**, 22, 631–640. [Google Scholar] [CrossRef] - Krivánek, J.; Gautron, P.; Pattanaik, S.; Bouatouch, K. Radiance Caching for Efficient Global Illumination Computation; INRIA: Rocquencourt, France, 2004. [Google Scholar]
- Christensen, P.H.; Batali, D. An Irradiance Atlas for Global Illumination in Complex Production Scenes. In Proceedings of the Fifteenth Eurographics Conference on Rendering Techniques, Grenoble, France, 21–23 June 2004; pp. 133–141. [Google Scholar]
- Dietrich, A.; Schmittler, J.; Slusallek, P. World-Space Sample Caching for Efficient Ray Tracing of Highly Complex Scenes; Technical Report; Computer Graphics Group, Saarland University: Saarbrücken, Germany, 2006. [Google Scholar]
- Gautron, P.; Bouatouch, K.; Pattanaik, S. Temporal Radiance Caching. IEEE Trans. Vis. Comput. Graph.
**2007**, 13, 891–901. [Google Scholar] [CrossRef] [PubMed] [Green Version] - Brouillat, J.; Gautron, P.; Bouatouch, K. Photon-driven Irradiance Cache. Comput. Graph. Forum
**2008**, 27, 1971–1978. [Google Scholar] [CrossRef] [Green Version] - Křivánek, J.; Gautron, P.; Pattanaik, S.; Bouatouch, K. Radiance Caching for Efficient Global Illumination Computation. IEEE Trans. Vis. Comput. Graph.
**2005**, 11, 550–561. [Google Scholar] [CrossRef] - Omidvar, M.; Ribardière, M.; Carré, S.; Méneveaux, D.; Bouatouch, K. A radiance cache method for highly glossy surfaces. Vis. Comput.
**2016**, 32, 1239–1250. [Google Scholar] [CrossRef] - Wang, R.; Wang, R.; Zhou, K.; Pan, M.; Bao, H. An Efficient GPU-Based Approach for Interactive Global Illumination; Association for Computing Machinery: New Orleans, LA, USA, 2009; pp. 1–8. [Google Scholar] [CrossRef] [Green Version]
- Hachisuka, T.; Jensen, H.W. Parallel Progressive Photon Mapping on GPUs; ACM: New York, NY, USA, 2010; p. 1. [Google Scholar]
- Crassin, C.; Neyret, F.; Sainz, M.; Green, S.; Eisemann, E. Interactive Indirect Illumination Using Voxel-Based Cone Tracing: An Insight; ACM: New York, NY, USA, 2011; p. 1. [Google Scholar]
- Thiedemann, S.; Henrich, N.; Grosch, T.; Müller, S. Voxel-based Global Illumination. In Symposium on Interactive 3D Graphics and Games; ACM: New York, NY, USA, 2011; pp. 103–110. [Google Scholar]
- Ritschel, T.; Dachsbacher, C.; Grosch, T.; Kautz, J. The State of the Art in Interactive Global Illumination. Comput. Graph. Forum
**2012**, 31, 160–188. [Google Scholar] [CrossRef] - Scherzer, D.; Nguyen, C.H.; Ritschel, T.; Seidel, H.P. Pre-convolved Radiance Caching. Comput. Graph. Forum
**2012**, 31, 1391–1397. [Google Scholar] [CrossRef] - Dammertz, H.; Sewtz, D.; Hanika, J.; Lensch, H. Edge-Avoiding A-Trous Wavelet Transform for fast Global Illumination Filtering. In Proceedings of the Conference on High Performance Graphics, Saarbrücken, Germany, 25–27 June 2010; pp. 67–75. [Google Scholar]
- Bauszat, P.; Eisemann, M.; Magnor, M.; Ahmed, N. Guided Image Filtering for Interactive High-quality Global Illumination. Comput. Graph. Forum
**2011**, 30, 1361–1368. [Google Scholar] [CrossRef] - Gastal, E.S.L.; Oliveira, M.M. Adaptive Manifolds for Real-Time High-Dimensional Filtering. ACM Trans. Graph. (TOG)
**2012**, 31, 1–13. [Google Scholar] [CrossRef] - Mara, M.; Luebke, D.; McGuire, M. Toward Practical Real-time Photon Mapping: Efficient GPU Density Estimation. In Proceedings of the ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games, Orlando, FL, USA, 21–23 March 2013; pp. 71–78. [Google Scholar]
- Schwenk, K. Filtering Techniques for Low-Noise Previews of Interactive Stochastic Ray Tracing; Technische Universität Darmstadt: Darmstadt, Germany, 2013. [Google Scholar]
- Nguyen, C.H.; Scherzer, D.; Ritschel, T.; Seidel, H.P. Material Editing in Complex Scenes by Surface Light Field Manipulation and Reflectance Optimization. Comput. Graph. Forum
**2013**, 32, 185–194. [Google Scholar] [CrossRef] [Green Version] - Zimmer, H.; Rousselle, F.; Jakob, W.; Wang, O.; Adler, D.; Jarosz, W.; Sorkine-Hornung, O.; Sorkine-Hornung, A. Path-space Motion Estimation and Decomposition for Robust Animation Filtering. Comput. Graph. Forum
**2015**, 34, 131–142. [Google Scholar] - Munkberg, J.; Hasselgren, J.; Clarberg, P.; Andersson, M.; Akenine-Möller, T. Texture Space Caching and Reconstruction for Ray Tracing. ACM Trans. Graph. (TOG)
**2016**, 35, 249:1–249:13. [Google Scholar] [CrossRef] - Chaitanya, C.R.A.; Kaplanyan, A.S.; Schied, C.; Salvi, M.; Lefohn, A.; Nowrouzezahrai, D.; Aila, T. Interactive Reconstruction of Monte Carlo Image Sequences Using a Recurrent Denoising Autoencoder. ACM Trans. Graph. (TOG)
**2017**, 36, 98:1–98:12. [Google Scholar] [CrossRef] - Bako, S.; Vogels, T.; Mcwilliams, B.; Meyer, M.; NováK, J.; Harvill, A.; Sen, P.; Derose, T.; Rousselle, F. Kernel-predicting Convolutional Networks for Denoising Monte Carlo Renderings. ACM Trans. Graph. (TOG)
**2017**, 36, 1–14. [Google Scholar] [CrossRef] [Green Version] - Silvennoinen, A.; Lehtinen, J. Real-time global illumination by precomputed local reconstruction from sparse radiance probes. ACM Trans. Graph. (TOG)
**2017**, 36, 1–13. [Google Scholar] [CrossRef] - Schied, C.; Kaplanyan, A.; Wyman, C.; Patney, A.; Chaitanya, C.R.A.; Burgess, J.; Liu, S.; Dachsbacher, C.; Lefohn, A.; Salvi, M. Spatiotemporal Variance-guided Filtering: Real-time Reconstruction for Path-traced Global Illumination. In Proceedings of the High Performance Graphics, Los Angeles, CA, USA, 28–30 July 2017; pp. 2:1–2:12. [Google Scholar]
- Schied, C.; Peters, C.; Dachsbacher, C. Gradient Estimation for Real-time Adaptive Temporal Filtering. Proc. ACM Comput. Graph. Interact. Tech.
**2018**, 1, 24:1–24:16. [Google Scholar] [CrossRef] - Binder, N.; Fricke, S.; Keller, A. Massively Parallel Path Space Filtering. arXiv
**2019**, arXiv:1902.05942. Available online: https://arxiv.org/abs/1902.05942 (accessed on 14 February 2020). - Hirvonen, A.; Seppälä, A.; Aizenshtein, M.; Smal, N. Accurate Real-Time Specular Reflections with Radiance Caching. In Ray Tracing Gems: High-Quality and Real-Time Rendering with DXR and Other APIs; Haines, E., Akenine-Möller, T., Eds.; Apress: Berkeley, CA, USA, 2019; pp. 571–607. [Google Scholar] [CrossRef]
- Luksch, C.; Wimmer, M.; Schwärzler, M. Incrementally baked global illumination. In Proceedings of the ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games, Montreal, QC, Canada, 21–23 May 2019; pp. 1–10. [Google Scholar] [CrossRef] [Green Version]
- Wang, Y.; Khiat, S.; Kry, P.G.; Nowrouzezahrai, D. Fast non-uniform radiance probe placement and tracing. In Proceedings of the ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games, Montreal, QC, Canada, 21–23 May 2019; pp. 1–9. [Google Scholar] [CrossRef]
- Yalçıner, B.; Sahillioğlu, Y. Voxel transformation: Scalable scene geometry discretization for global illumination. J. Real-Time Image Process.
**2019**. [Google Scholar] [CrossRef] - Zhao, Y.; Belcour, L.; Nowrouzezahrai, D. View-dependent Radiance Caching. In Proceedings of the 45th Graphics Interface Conference on Proceedings of Graphics Interface 2019, Kingston, ON, Canada, 28–31 May 2019; Canadian Human-Computer Communications Society: Kingston, ON, Canada; pp. 1–9. [Google Scholar] [CrossRef]
- Huo, Y.; Wang, R.; Zheng, R.; Xu, H.; Bao, H.; Yoon, S.E. Adaptive Incident Radiance Field Sampling and Reconstruction Using Deep Reinforcement Learning. ACM Trans. Graph. (TOG)
**2020**, 39, 6:1–6:17. [Google Scholar] [CrossRef] [Green Version] - Alcantara, D.A.F. Efficient Hash Tables on the GPU. Ph.D. Thesis, University of California, Davis, Davis, CA, USA, 2011. [Google Scholar]
- Pérard-Gayot, A.; Kalojanov, J.; Slusallek, P. GPU Ray Tracing Using Irregular Grids. Comput. Graph. Forum
**2017**, 36, 477–486. [Google Scholar] [CrossRef] - Lefebvre, S.; Hoppe, H. Perfect Spatial Hashing. ACM Trans. Graph. (TOG)
**2006**, 25, 579–588. [Google Scholar] [CrossRef] - Laine, S.; Karras, T. Efficient Sparse Voxel Octrees. IEEE Trans. Vis. Comput. Graph.
**2011**, 17, 1048–1059. [Google Scholar] [CrossRef] [Green Version] - Wang, Z.; Simoncelli, E.P.; Bovik, A.C. Multiscale structural similarity for image quality assessment. In Proceedings of the Thirty-Seventh Asilomar Conference on Signals, Systems & Computers, Pacific Grove, CA, USA, 9–12 November 2003; pp. 1398–1402. [Google Scholar]

**Figure 2.**Computing the total number of the occupied cells using a pop count and an atomic add operation.

**Figure 3.**An overview of the caching process. Hitpoints, normals, and irradiance samples are generated by the path-tracing process. The hitpoints’ coordinates are then used to determine the HashGrid indices for each hitpoint. Using these indices, the HashGridManager is queried for the global indices to the data arrays and the cached normals. A binary orientation for each irradiance sample, the actual irradiance sample, and the global data indices are now used to collate the data in a sort-and-reduce operation. The resulting unique information per grid cell is then merged with the current cache data.

**Figure 4.**Parameters for a single path. The parameter ${\ell}_{store}$ determines the maximum depth to which values are stored in the cache. After that depth, the illumination along subpaths is computed up to a maximum length of ${\ell}_{len}$. The length of both determines the maximal recursion depth ${\ell}_{rec}$.

**Figure 5.**An overview of the reconstruction process. A ray-tracing step is performed to find the actual hitpoints that have to be reconstructed from the cache. In order to support non-lambertian materials, this step includes tracing of rays until a diffuse surface is found, the background is hit, or a user-definable maximum recursion depth is reached. The HashGrid indices computed from the hitpoints are then sorted by the appropriate octree level, and the cache is queried for the actual data indices. Together with hitpoint-wise texture and geometry information, the acquired irradiance is filtered in a denoising step in a layered back-to-front way. This means that each recursion level is filtered individually and then combined with the next (closer) level, until the primary hitpoints are reached. The result is then combined in a running estimate to achieve higher image quality when the camera is not moving.

**Figure 6.**Comparison of the same viewpoint rendered with all combinations of jittering and denoising. (

**Top left**) HashCache-based reconstruction without any spatial jittering or denoising applied. (

**Top right**) While spatial jittering cannot get rid of the high-frequency noise visible in the upper inset, it works well for hiding quantization artifacts. (

**Bottom left**) Denoising alone does work well for fine-grained noise, but cannot remove quantization artifacts very well. (

**Bottom right**) Combining jittering and denoising works well for both kinds of artifacts.

**Figure 7.**Two-dimensional example of the possible issue with spatial jittering: For a hitpoint p on an arbitrary scene surface with a jitter radius of r, the sampled cell resulting from ${p}^{\prime}=p+\overrightarrow{j}$ with $\overrightarrow{j}\in J$ and $J=\left\{\overrightarrow{j}\phantom{\rule{0.277778em}{0ex}}\right|\phantom{\rule{0.277778em}{0ex}}\overrightarrow{j}\in {[-r,r]}^{2}\}$ may not contain any scene geometry. Consequently, the according cell has no memory explicitly reserved in the hash map. The computed hash key may thus lead to empty or even plainly wrong cells. The filled area represents the set of possible jittered points J. The green area is the subset of points that result in valid keys, while the red area depicts the subset of invalid points.

**Figure 8.**Layered filtering process, illustrated for three layers. The reconstructed diffuse illumination ${\mathbf{E}}_{rec}$ for hitpoints that reached cached materials is added to the current result in each level. Together with the auxiliary buffers, such as the local G-buffer, it is then processed by the denoising method. Afterwards, albedo is taken into account, and the data are propagated to the next layer. This process is repeated until the first layer, formed by the primary hitpoints, is reached, and the final image is reconstructed.

**Figure 9.**Top: Unfiltered propagation of light bounces from the third hitpoint to the primary hitpoint (left to right). Bottom: The diffuse material colors (albedo) of each bounce above, multiplied after each filtering step. Note that non-diffuse materials appear white because they do not change the appearance of cached illumination values, which are strictly diffuse. The grey appearance of these materials resulted from tonemapping.

**Figure 10.**Interleaved comparison between filtering the first three accumulated bounces with traditional (red insets) and layered filtering (green insets). The image has been reconstructed with one sample per pixel after filling the cache with four samples per pixel just for the illustrated viewpoint. The utilization of local geometry information through layered G-buffers shows clear improvements in image quality. Filter weights for color and luminance differences have been adjusted in comparison to the weights chosen in the evaluation measurements.

**Figure 11.**Relative mean square error (relMSE, lower is better) and multi-scale structural similarity (MS-SSIM, higher is better) for the scene Country Kitchen (maximal build resolution ${4096}^{3}$) and Streets of Asia (maximal build resolution ${2048}^{3}$) at various sampling densities using path tracing and the HashCache system. The shaded area in the background outlines the respective relMSE and MS-SSIM ranges for the other rendering method for better comparison.

**Figure 12.**The appearance of noise when using the HashCache. Without filtering and jittering, the distance-dependent scale of noise becomes clearly visible. Turning jitter on improves the visual appearance of quantization artifacts. Turning denoising on clearly improves regions with low sample counts, even filling in areas where no samples have been cached at all. The bottom right image shows the result with Intel’s Open Image Denoising (https://openimagedenoise.github.io/) instead of our denoiser. It becomes clear that the method cannot cope with the kind of noise exhibited by the HashCache.

**Figure 13.**The effect of adjusting the cache resolution. The rightmost pictures show the reference rendering at 131,072 spp. The rest of the images show cache resolutions from ${2048}^{3}$ down to ${256}^{3}$, decreasing by powers of two (from right to left). It can be seen that the decreased spatial resolution leads to quantization artifacts which are effectively filtered by jittering and denoising. However, fine-grained details would not be resolvable at low resolutions, and a complete loss of spatial details may occur.

**Figure 14.**Comparison of images generated with pure path tracing and with the support of HashCache. (

**Left**) The full image subdivided horizontally into areas rendered with HashCache at 1, 8, 64, and 512 spp, as well as with Path Tracing at 131,072 spp. Insets in green are magnified on the right for the various settings. (

**Right**) Zoomed-in rendering for comparison, rendered with Path Tracing, HashCache (with three more frames in the sequence rendered before), and HashCache individual (the camera position has been rendered without filling the cache in the preceding frames). For the upper inset, the HashCache system already yields a quality at 64 spp (512 spp for individual rendering) that is on-par with the path-traced image at 131,072 spp. However, the lower inset shows more artifacts than the reference, even at 512 spp, for the HashCache rendering. The main reason for this is that we tuned the denoising filter to maintain shadows. Different denoising methods used with our layered framework should be able to resolve this well.

**Figure 15.**Comparison of images generated with pure path tracing and with the support of HashCache. (

**Left**) The full image rendered at the reference sample count of ${2}^{17}$. The green inset is magnified on the right for the various rendering settings. (

**Right**) Zoomed-in rendering for comparison, rendered with Path Tracing, HashCache (with four more frames in the sequence rendered before as a warm-up phase), and HashCache individual (without filling the cache in the preceding frames). For the upper inset, the HashCache system already yields a quality at 64 spp (512 spp for individual rendering) that is at least visually on-par with the path-traced image at 131,072 spp.

**Figure 16.**The effect of layered filtering for glossy and specular materials. The cache was filled irregularly over 128 frames at 1 spp for a random fly-through. (

**Left**) Unfiltered image at 128 reconstruction samples per pixel. (

**Center**) Layered filtering at 128 reconstruction samples per pixel. (

**Right**) Magnified insets. It is clearly visible how the noisy illumination from the back wall is reflected in the glossy surface on the ground when layered filtering is deactivated. With layered filtering, the noise can be filtered in a separate layer and then be accounted for in the glossy reflection. For the refractive material on the right, a similar effect is visible: Refracted rays pick up the noisy cache values from the back wall when layered filtering is deactivated. With layered filtering turned on, this noise can be effectively filtered before it is propagated to preceding vertices on the path. This allows for removing the noise locally without loss of details. An example for the individual layers being filtered is shown in Figure 10.

**Figure 17.**Statistics for the scene Country Kitchen with different cache settings at a resolution of ${2048}^{3}$. (

**Left**) Total rendering times, split into different steps. (

**Right**) Average number of cells updated per frame of the 500 frame sequence. These numbers include the update of all octree levels. Note that the resolution factor can be adjusted dynamically to the current situation, e.g., when the user is moving.

**Figure 18.**Path-tracing and HashCache rendering times for Country Kitchen and Streets of Asia fly-throughs. Rendering time is given for 1 spp. PT: Trace is the time for pure path tracing at a maximum recursion depth of 8, HC: Caching is the caching part of HashCache computations which includes path tracing and cache updates, and HC: Reconstruction is the reconstruction part of the HashCache computations, which includes ray tracing, fetching the respective data from the cache, and reconstructing an image from the computed data (including filtering). While caching times are significantly higher than pure path-tracing times, data are reused between frames so that the actual caching resolution factor (CRF) can be reduced either permanently or deactivated during user input, allowing for smooth interaction.

**Table 1.**Data densities and memory requirements. The data density is the quotient of occupied cells and the actual number of cells for a full grid of resolution ${n}^{3}$. Data memory is the amount of memory required to store the full data arrays. Hash memory is the amount of memory reserved for the hash map representation for the respective level.

Country Kitchen | ||||
---|---|---|---|---|

Level | Res | Density | Data Mem. | Hash Mem. |

0 | 1 | 1 | 24 B | 4.4 B |

1 | 2 | 0.5 | 96 B | 17.6 B |

2 | 4 | 0.375 | 576 B | 105.6 B |

3 | 8 | 0.193 | 2.32 kiB | 435.6 B |

4 | 16 | 0.124 | 11.93 kiB | 2.19 kiB |

5 | 32 | 0.070 | 54.07 kiB | 9.91 kiB |

6 | 64 | 0.038 | 234.47 kiB | 42.99 kiB |

7 | 128 | 0.023 | 1.11 MiB | 209.23 kiB |

8 | 256 | 0.012 | 4.66 MiB | 874.83 kiB |

9 | 512 | 0.006 | 19.43 MiB | 3.56 MiB |

10 | 1024 | 0.003 | 81.60 MiB | 14.96 MiB |

11 | 2048 | 0.002 | 362.09 MiB | 66.38 MiB |

12 | 4096 | 0.001 | 1.71 GiB | 320.90 MiB |

Sum | 2.17 GiB | 406.92 MiB | ||

Streets of Asia | ||||

Level | Res | Density | Data Mem. | Hash Mem. |

0 | 1 | 1 | 24 B | 4.4 B |

1 | 2 | 0.5 | 96 B | 17.6 B |

2 | 4 | 0.266 | 408 B | 74.8 B |

3 | 8 | 0.197 | 2.37 kiB | 444.4 B |

4 | 16 | 0.135 | 12.91 kiB | 2.37 kiB |

5 | 32 | 0.074 | 57.14 kiB | 10.48 kiB |

6 | 64 | 0.043 | 265.92 kiB | 48.75 kiB |

7 | 128 | 0.025 | 1.21 MiB | 226.35 kiB |

8 | 256 | 0.014 | 5.50 MiB | 1.01 MiB |

9 | 512 | 0.008 | 25.68 MiB | 4.71 MiB |

10 | 1024 | 0.004 | 114.77 MiB | 21.04 MiB |

11 | 2048 | 0.003 | 543.88 MiB | 99.70 MiB |

Sum | 691.37 MiB | 126.75 MiB |

© 2020 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Roth, T.; Weier, M.; Bauszat, P.; Hinkenjann, A.; Li, Y.
Hash-Based Hierarchical Caching and Layered Filtering for Interactive Previews in Global Illumination Rendering. *Computers* **2020**, *9*, 17.
https://doi.org/10.3390/computers9010017

**AMA Style**

Roth T, Weier M, Bauszat P, Hinkenjann A, Li Y.
Hash-Based Hierarchical Caching and Layered Filtering for Interactive Previews in Global Illumination Rendering. *Computers*. 2020; 9(1):17.
https://doi.org/10.3390/computers9010017

**Chicago/Turabian Style**

Roth, Thorsten, Martin Weier, Pablo Bauszat, André Hinkenjann, and Yongmin Li.
2020. "Hash-Based Hierarchical Caching and Layered Filtering for Interactive Previews in Global Illumination Rendering" *Computers* 9, no. 1: 17.
https://doi.org/10.3390/computers9010017