Preserving Shadow Silhouettes in Illumination‐Driven Mesh Reduction

A main challenge for today's renderers is the ever‐growing size of 3D scenes, exceeding the capacity of typically available main memory. This especially holds true for graphics processing units (GPUs) which could otherwise be used to greatly reduce rendering time. A lot of the memory is spent on detailed geometry with mostly imperceptible influence on the final image, even in a global illumination context. Illumination‐driven mesh reduction, a Monte Carlo–based global illumination simulation, steers its mesh reduction towards areas with low visible contribution. While this works well for preserving high‐energy light paths such as caustics, it does have problems: First, objects casting shadows while not being visible themselves are not preserved, resulting in highly inaccurate shadows. Secondly, non‐transparent objects lack proper reduction guidance since there is no importance gradient on their backside, resulting in visible over‐simplification. We present a solution to these problems by extending illumination‐driven mesh reduction with occluder information, focusing on their silhouettes as well as combining it with commonly used error quadrics to preserve geometric features. Additionally, we demonstrate that the combined algorithm still supports iterative refinement of initially reduced geometry, resulting in an image visually similar to an unreduced rendering and enabling out‐of‐core operation.


Introduction
The level of realism displayed in today's production movies largely stems from physically based light transport simulation algorithms, with many improvements regarding their quality as well as acceleration on both traditional CPUs and graphics processing units (GPUs) [DKHS14]. However, the use of global illumination for realistic images comes hand-in-hand with large scenes featuring detailed geometry; Christensen et al. [CFS*18] give an overview of the structure and typical workload of Pixar's production renderer RenderMan. The memory requirements make it difficult to use GPUs for acceleration and may prove to be out-of-core even for main memory, inspiring the need for algorithms capable of operating on scenes not fitting into the target memory.
To tackle this, two general approaches exist: either the light transport simulation is able to work on partial scenes [BBS*09] [ENSB13] [GG14], possibly by swapping in geometry or partitioning the scene, or the scene has to be reduced in size until it fits into memory. On the level of an individual mesh, the corresponding error metric is often the Hausdorff distance, maintaining a minimal deviation between the original and reduced mesh in euclidean space. Finding the reduced mesh is a computationally intensive problem and often the global optimum is traded in exchange for feasibility; locally defined reduction criteria such as error quadrics [GH97] may end up in local minina, but it is always possible to compare two reduced meshes and establish their quality with respect to the Hausdorff metric.
However, once light sources and especially full global illumination are added to the equation, the definition of error shifts: while a purely geometric error metric remains interesting, it no longer coincides with the intention behind scene simplification. To capture this intent, the error metric has to take into account the possible scene-wide effects of geometry changes in a global illumination context. One possibility is to define the metric on the measure function of the camera; the RMSE of two converged renderings would be such a metric. This has multiple downsides: not only is accurately rendering global illumination an expensive operation, it is also a noisy one; unless the image is sufficiently converged, the root mean square error (RMSE) between two renderings may be dominated by noise. As a side effect, we are now shackled to a given algorithm, which is not inherently a disadvantage. On the contrary, geometric reduction should not retain features that have no effect on the rendering; an example of such features may be (missing) caustic paths for a path tracer. Similarly to the Hausdorff distance, directly using metrics defined on final renderings to guide geometry reduction is infeasible, requiring local metrics.
In this paper, we contribute the following: • A path tracing-based formulation of illumination-driven mesh reduction [RGG15] • Preservation of shadow silhouettes for point and area light by providing a definition for an object's shadow silhouette importance in the context of next-event estimation (NEE) • An improved error metric for collapse priority by combining importance with error quadrics [GH97] to prevent excessive mesh degeneration To examine the reduction quality, we test multiple scenes and observed the progression with more aggressive reduction goals. We furthermore discuss different blendings between the original metric and our extension as a quantification of image feature preference in excessive reduction scenarios. Finally, we give an overview of the reduction performance and additional overhead of our extension.

Related Work
As a solution to the rendering equation first formulated in the same work, Kajiya [Kaj86] introduced a Monte Carlo integration-based algorithm called path tracing. To alleviate some of its issues numerous improvements such as bi-directional path tracing [LW93] [Vea98] have been suggested, aimed at both reducing the variance introduced by its stochastic nature and its inability to effectively sample certain kinds of light paths.
A different approach has been taken by photon mapping [Jen96], which distributes and stores photons in a scene using spatial data structures called photon maps. These are queried in a second pass, resulting in a radiance estimate by accounting for all stored photons within a region around camera ray hits. Progressive photon mapping [HOJ08] and stochastic progressive photon mapping (SPPM) [HJ09] improve this technique by progressively shrinking the search radius, the latter being the algorithm of choice for Reich et al. [RGG15]. However, we target vanilla path tracing, which is still often used due to its simplicity and GPU scaling.

Importance
A variety of importance techniques used in rendering exist, of which Christensen [Chr03] gives an overview. As a general concept they see importance as an adjoint to different radiometric units. In photon mapping so-called importons, first mentioned by Jensen [Jen96], may guide the distribution of photons to focus on the important parts of the scene. Reich et al. [RGG15] use this notion of importance to guide their mesh reduction, the general idea being that geometry interacting with many contributing light paths has a high impact on the rendered image. In their implementation, they use SPPM since caustics (i.e. focused light paths) have a high influence on the light distribution in the scene and are not covered by standard, lightingindependent reduction algorithms.

Shadow algorithms
Shadow algorithms for rasterizers can be grouped into shadow mapbased [Wil78] and shadow silhouette--based [Cro77] approaches; Eisemann et al. [ESAW16] give an overview of existing techniques. The latter generally works by extending a volume from a light source and through an object's silhouette, defined as the borders between faces oriented towards the light source and those facing away. Since the resulting shadow geometry can be quite large, hybrid approaches such as shadow silhouette maps [SCH03,CD04] augment shadow maps with information about the shadow silhouette to reduce aliasing.
Jensen and Christensen [JC96] propose extending the photon map to incorporate shadow photons, which are stored in shadowed locations. By checking whether a mixture of regular and shadow photons exist in the merge radius, they restrict shadow rays to pixels lying in the border regions partially shadowed.

Mesh reduction
Botsch et al. [BKP*10] give a general overview of mesh processing algorithms. Hoppe [Hop96] introduces a representation for smooth transitions between multiple level-of-details based on mesh optimization [HDD*94]. Perception-guided approaches to mesh simplification have been explored by Guthe et al. [GBBK04] as well as Menzel and Guthe [MG10]; both ignore global illumination effects and are thus ill-suited for retaining image fidelity.
Garland and Heckbert [GH97] define an algorithm based on quadric error metrics which operates solely on a geometric level, ignoring any context given by surrounding meshes or the rendering algorithm. It minimizes the square of sums of the projected distance to all faces affected by a collapse.

Illumination-driven mesh reduction
We first give an overview of the existing importance-based reduction framework following the reduction pipeline depicted in Figure 2. It is important to note that importance in this context does not denote the adjoint to radiance, but rather an empirical quantity loosely based on contribution.
At the heart of the algorithm stands computing importance. To attribute visual importance to mesh geometry, illumination-driven mesh reduction [RGG15] accrues importanceI(T) per triangle T whenever the light transport algorithm finds a closed path between a light source and the camera. This process is based on SPPM: for each photon in the merge radius, the importance of the triangle gets increased. To keep directly visible surfaces intact, viewpath vertices also add importance, regardless of whether a photon was merged. This may be repeated iteratively to reduce noise in these estimates. The importance sum I(M) = T∈M I T (T) over all triangles of a mesh M is then used to distribute reduction factors inside the scene. Each mesh is decimated via edge collapse based on the importance I(V ) = 1 |triangles(V )| T∈triangles(V ) I(T) of a vertex V and its neighbours, prioritizing collapses of low-importance vertices and gradients. Note that it is trivial to extend the framework to incorporate quads, a geometric primitive often preferred by artists. The local importance estimate is defined aŝ where x i j and x i j−1 form a path segment and n T is the surface normal at x i j . With this, the importance of a triangle is given as wherez i andȳ i are the i-th view and light sub-path, respectively, N is the number of all paths, j indicates the vertex on the sub-path and γ serves as a user-defined weight between viewpath and photon importance.
The accumulated per-face importance is then taken as input for the importance mapping step. To understand its necessity, we have to take a step back and recall the purpose of the framework: reduc-  ing a scene's geometry, which ordinarily may be out-of-core, to fit into main memory or VRAM, depending on the concrete application. The previous step of importance accretion however requires the scene to be renderable. To achieve this without having to resort to out-of-core rendering, Reich et al. proposed a pre-processing step of initial geometric reduction, which uses any regular viewindependent technique; the only requirement is that it allows tracing an edge-collapse history. Importance computation is then performed on this pre-reduced scene and the mapping step projects importance onto all vertices in the original scene via the collapse history. Importance reduction then takes the original scene mesh by mesh and performs edge collapses, prioritizing low importance vertices/edges. Note that the number of collapses per mesh is chosen proportional to the importance sumI(M); this is a critical aspect to the framework's out-of-core capabilities.

Obtaining importance with path tracing
The approach by Reich et al. [RGG15] is mostly geared towards lighting scenarios involving caustics generated by complex glass objects. This reflects in the chosen light-simulation algorithm; photon mapping generally performs well for LS + DE paths. However, in scenes mostly dominated by diffuse interactions a path tracer with next event estimation is often preferential due to its lower memory requirements, faster iteration time and ease of implementation.
To utilize the importance-based mesh reduction, we first give a notion of the importance acquisition in a way suitable for a path tracer. The original paper defines the importance computation in terms ofÎ, which scales the importance a viewpath vertex adds to a triangle with the angle between incident direction and surface normal, putting emphasis on silhouettes. We now wish to obtain a similar quantity with a path tracer. The viewpath is relatively straightforward and only requires a small adaption. SPPM classifies materials into either diffuse, glossy or specular and stops upon encountering a diffuse surface, whereas path tracing does not. Thus, we need to keep track of the BxDF sampled along the path

Figure 3: Difference in importance acquisition: Viewpath vertices ( ) increase importance for both methods directly, unless they bounced off a diffuse surface ( ). While the SPPM-based acquisition traces photons and increases importance ( , ) for successful merges along the photon's path ( ), the path tracing-based variant increases importance ( , ) upon successful next-event estimations ( ). Photons that did not get merged ( ) do not contribute anything, while for PT sub-paths after a diffuse interaction ( ) may still contribute indirect importance ( ) if later vertices contribute radiance.
and reduce the amount of importance added; we defer the search for a proper weighting for glossy reflections to future research.
Obtaining the importance from the photons is more complicated. Reich et al. [RGG15] take the number of photons within the merge radius at a viewpath segment, which is proportional to its flux. However, it also increases the importance for all triangles with which the photon has interacted previously. Instead of the flux we use the differential irradiancedE, since a path tracer cannot (easily) obtain the flux at a given point. We determine the direct differential irradiance dE NEE at each viewpath segment via next event estimation and estimate the indirect differential irradiance dE trace by tracking the path back upon termination. This presents an issue: since multiple viewpath hits of a triangle also incur multiple estimates of its irradiance, we need to store the view-and lightpath importance separately alongside the number of irradiance estimates we obtained. The final importance of a triangle is then where M is the number of all viewpath vertices.Ĵ(E, T), similarly toÎ, weights the differential irradiance dE with the angle between their incident direction and surface normal, respectively; see Figure 3 for an example in a simple scene. In the following, we assume all importance quantities as defined for the path tracer.

Shadow silhouettes as visual feature
While there currently is no closed-form error function for mesh reduction in the context of global illumination, we can state what it must encompass. From the perspective of path space, there are four possibilities for a path segment after a reduction happened: 1. the segment did not intersect the affected geometry before and after reduction; 2. the segment did not intersect the affected geometry before, but does after reduction (concave surface 'popping'); 3. the segment did intersect the affected geometry before and after; 4. the segment did intersect the affected geometry before, but not after reduction.
This taxonomy is not complete, as it ignores new path segments that are possible only after the reduction, but it helps understanding why the current illumination-driven framework is incomplete: its error function accounts for Possibilities 1 and 3, but not always for the remaining ones. A path segment blocked by an occluder does not indicate the necessity to maintain the geometric structure of said occluder according to the algorithm. While this is not an issue (and in fact, an advantage) for core shadows, it causes noticeable disruptions in the outline of shadowed image regions and may even cause the occluder to degenerate into a tetrahedron, as illustrated by the right bunny shadow in Figure 1(b). Other artefacts such as popping of concave mesh parts are partially mitigated by the use of multiple decimation passes.
We propose to extend the framework to specifically account for direct shadow silhouettes, the most noticeable issue. At its core, we extend a light sub-path whenever it hits an object's silhouette. We use the definition utilized by shadow volumes [Cro77] which states that a silhouette edge is the edge between two neighbouring faces, one oriented towards and the other oriented away from the light source. Note that an area light may have multiple silhouette 'rings' depending on its extent. To detect silhouettes we utilize the shadow rays of next-event estimations. Whenever such an estimation fails, we know that the point is not directly illuminated by a given light source. To determine whether it is a mesh's silhouette blocking the light, it is unfortunately not sufficient to check if the point is shadowed at all (usually implemented as an any-hit intersection test). Instead we attempt to find the first two faces between the light source and the shaded point, as depicted in Figure 4. It is then sufficient to check if the faces share vertices, in which case we have found a shadow silhouette; note that index buffer-based renderers may need to compare the vertices' positions if they use per-vertex attributes. Since the shadow silhouette may not actually be visible at our viewpath vertex, we then need a third check to see if there is blocking geometry between the backside of the silhouette and the viewpath (see Figure 5 for an example scene).  To integrate this into the importance framework, we define the silhouette importance of a triangle as where z i is a viewpath vertex, s(z i ) is the remaining sharpness of the viewpath at the vertex, L NEE (z i ) is the radiance estimate from the next-event estimation at z i blocked by an object, and d pen is the estimated penumbra size, as depicted in Figure 6. In our context, we define a heuristic for the sharpness of a viewpath as where ρ(z j ) is the BRDF of a prior path vertex. The overall shape ensures that we ignore silhouettes that are visible only via diffuse or glossy reflections, but has been determined entirely empirically without any theoretical basis.
The silhouette importance heuristic has been chosen for various reasons. First, the importance of a shadow silhouette has to depend on its visibility, that is, how much the local radiance function would change should it be altered. We approximate this by taking the would-be radiance difference in case of a successful NEE multiplied with a measure of radiance sharpness; in our tests we approximated this by manually classifying materials in diffuse, glossy and specular akin to SPPM, but more sophisticated weightings are possible. Secondly, extended light sources naturally may have multiple silhouette 'rings' depending on the exact location of the NEE. Be- cause the visual disturbance of a soft shadow in case of reduction is lower than that of a hard one, the importance of these rings has to be weighted down. Since it is not a trivial task for a path tracer to determine whether an NEE is fully, partially or not shadowed at all, we weight the shadow importance with the inverse of the expected penumbra size at the shadowed point. For this, we assume the worst case (i.e. the shortest side of the light's primitive) and projected it onto the shadowed surface via the intercept theorem ( Figure 6). This heuristic assumes that the light source is mostly symmetrical and the occluder intersection is close to the object's true shadow edge, which results in worse estimates for bar-like lights and large objects relative to the light's area.
To implement the pipeline so far we require additional memory. For each face, we have to track several quantities: its viewpath im-portanceÎ(z i , T), irradiance E(z i ) and sample counter to estimate its average irradiance, and the silhouette importance I sil (T). The latter may simply be added to the viewpath importance, leaving two floats and an int per face as memory overhead. However, there are some issues unaccounted for. One issue, largely solved by more importance iterations, is: if the shadow-casting mesh has a high level of detail, it may be possible to miss the silhouette. This may happen when the projected area of a silhouette face onto the shadowed surface is smaller than the footprint of the viewpath we perform the shadow test for. Figure 7 visualizes the detected silhouette faces at increasing numbers of samples. Due to jittering the starting point on each pixel, a slightly different shadow ray is cast every iteration, increasing the likelihood of detecting the full silhouette overall.

Distribution of reduction factors
A central aspect of importance-based mesh reduction is the distribution of a vertex budget across the scene; meshes located in remote corners or not directly illuminated will generally need less vertices than those in the centre of attention. Since the pipeline so far computes this budget based on I(M)without silhouette importance factored in, invisible but occluding meshes still get reduced too much. Merely summing I sil (T) as well does not help either; the two quantities are not directly comparable due to the chance of missing silhouette faces.
To achieve a fair distribution, we split the budgeting into two parts: the already known importance sum I(M) as well as a shadow importance sum where dE NEE (z i ) is the differential irradiance of the occluded NEE at z i and δ is a user-defined weighting factor indicating preservation preference. The definition is similar to the silhouette importance in Equation (4), but instead of radiance we use differential irradiance similarly to I(M). This heuristic is not exact: the influence of a shadow silhouette should be proportional to its visible perimeter length, which for area lights becomes an area instead. Both are difficult to properly estimate, which is why we instead approximate it by integrating I SS (M) for all occluded NEEs; this deviates more for highly nested silhouettes, but performed well in our tests.
Following from this, we have to track one additional quantity, but only per mesh, not per face. Figure 8 shows the effect of different light sizes on vertex distribution: note the increased detail of the visible bunny for larger penumbras of the tree due to the different budgeting. The pipeline so far is still overly preserving invisible yet occluding meshes in some scenarios though, namely, when a bright light source outshines the shadow. To avoid this, we ignore the contribution to I SS (M) as well as I sil (T) when the ratio between L NEE (z i ) and L(z i ) drops below 2%; this follows from the Weber-Fechner law [Fec58] [Web34]. It is important that this ratio has to be taken with tone-mapping applied. Figure 10 shows a more complex lighting scenario with two area light sources, which are partially outshined by two spot lights; note the largely absent silhouette importance on the bunny to the right. Unfortunately, this technique requires at least one additional NEE to estimate light from sources other than the shadowed one, which may however be used to reduce the noise level of the overall importance.

Reducing geometric errors
As noted in Section 3.2, the framework requires multiple decimation passes to suppress popping artefacts. They are a consequence of an information gap in the error metric; if multiple faces are never hit by view or light paths, then the collapse order may as well be random. Figure 9 illustrates the possible consequences for different types of local topology. This effect is most notable in non-transparent meshes with steep concavities, such as a tree with branches. A simple measure to prevent popping would be to restrict collapses to purely convex ones. However, this would restrict the decimation too much: low-importance regions may not have convex collapses at all or would need to propagate it slowly from other convex areas. To decrease the risk of incurring these artefacts in the first place, we instead propose to combine the importance-based error metric with a geometric one, which has the added benefits of more well-behaved reduction even in unproblematic unimportant mesh parts. Quadric error metrics as used by Garland and Heckbert [GH97] seem to be suitable. They define the error an edge collapse causes as the square of the distance to the planes defined by all faces affected by a collapse.
As mentioned by Reich et al., combining the two in a theoretically sound way proves difficult as the quadrics error is measured in world space distances, whereas importance is derived from path space. However, we do not require a correct combination of the two, as our primary goal is to minimize the geometric error for parts of a mesh we already deemed unimportant. We thus propose the geometric mean between a vertex' ring importance as defined by Reich et al. and the quadric error as a heuristic for prioritizing collapses: where P(V, V 1 ) is the collapse priority (lower signifying preference) of vertex V onto V 1 , Q(V ) is the error quadric of vertex V and N(V ) is the neighbourhood of vertex V . While the result itself does not relate to a known quantity, it achieved the desired result in our experiments: areas with zero geometric error may be decimated regardless of importance, while areas with low importance but high geometric error are less preferable than those with less geometric error. For regular scene sizes the term is still dominated by the importance.

Evaluation
We implemented the reduction pipeline in our workgroup renderer Mufflon [BJGB19], which uses a two-level linear BVH as acceleration structure and OpenMP for CPU-side parallelism. All performance evaluations were executed on an AMD Ryzen Threadripper 2990WX alongside DDR4-2400 RAM. We did not include comparisons to related algorithms. Unless mentioned otherwise, we initially reduced the scene by the same amount as the single final reduction with 100 importance iterations (see Figure 2) as well as one NEE per light source (see Section 3.3). To the best of our knowledge, there is no other algorithm using information about global illumination to guide mesh reduction; image-driven simplification [LT00] only incorporates one fixed light source and does not respect global light transport at all.

Reduction quality
The main goal of our work is the preservation of shadow details in reduced scenes. To this end, Figure 11 depicts a section of the Holy Bunny scene with a total of 4.3 million triangles. Figure 11(a) shows the unreduced scene rendered with a path tracer; Figure 11(c) shows a wireframe rendering from a different angle. To evaluate the overall reduction quality, Figures 11(b)-11(e) present the result after reduction by 90%, 98% and 99.5% respectively. With 90% reduction, there are only small changes in the image, most notably the shadow cast by a table seen in the wall mirror. With higher reduction rates, artefacts become more apparent: the small figurines in the image corners lose their detailed rills along their bodies and the reflected shadow of the buddha statue becomes more coarse, exposing that the table it is resting on consists of two separate parts. Multiple reduction passes do not remedy the over-reduction as showcased by Figure 12: since the shadow area reduces, the respective mesh is attributed even less importance which exacerbates the issue. Figure 11(f) displays a wireframe rendering of the scene at 99.5% reduction. Notably, the buddha statue to the right of the bunny retains a higher polygon count than its counterpart due to the difference in visible shadow size. The figurines which are neither directly visible nor cast a visible shadow are maximally reduced, becoming tetrahedrons.

Weighting importance sources
To assess the influence of the importance weights δ and γ from Equations (3) and (6), Figure 13 depicts the scene Hairy Yeahright reduced by 95%. Figure 13(a) shows the unreduced scene, while Figure 13(b) shows the scene after reduction with error quadrics only. The decimation is clearly visible on both the visible hair and its shadow. Figure 13(c) shows the same scene after importance reduction with weights γ = δ = 1, leaving the shadow largely intact but overly reducing parts of the head and tail of the statue. The hairball receives ∼40% of the illumination and view importance as well as ∼97% of the shadow importance, resulting in a vertex distribution of roughly 85% to 15% between the hairball and the statue. The same settings were used to reduce the scene in Figure 13(d), however here we did not weight the importance with error quadrics to prioritize collapses. It is apparent that the occluding hairs which are not part of its silhouette collapse too much, leaving visible gaps in the shadow. The statue also suffers from ill-suited collapses especially at sharp edges, which may be partially mitigated by tuning the normal-flip prevention used by Reich et al. In Figure 13(e) we put higher emphasis on directly visible geometry, using γ = 100 and obtaining a vertex distribution of 46% to 54%. This visibly improves the statue and hair geometries, while simultaneously worsening the shadow outline in some places. To contrast this, we used δ = 100 in Figure 13(f), placing higher emphasis both locally on the shadow silhouettes and also attributing a higher vertex budget to the hairball. While the shadow silhouette improves slightly, the statue clearly worsens and noticeably disturbs the image impression as a result of the vertex budget distribution of 97% to 3%. Leaving the weighting equal for all importance parts resulted in balanced reductions for all tested scenes; increasing the weight for one part generally means worsening another aspect of the image.

Performance
To evaluate the overhead of our method, Table 1 shows the execution times of our reduction steps when reducing scenes by 90%, 95% and 98% of their vertices, respectively; for a general performance overview of the illumination-driven mesh reduction see [RGG15]. The third column shows the render time of 100 samples per pixel for a path tracer on the original scene; it should be noted that 100 path tracing iterations are not nearly enough to produce converged renderings. The fourth column contains the execution times of the importance gathering with 100 iterations for the pre-reduced scenes. Unlike in [RGG15], importance iterations may incur significant overhead dependent on the amount of visible shadows and the complexity of occluding geometry, peaking for Hairy Yeahright with its many small hairs. The majority of the overhead stems from additional intersection tests and BVH traversals necessary for silhouette detection; for this reason, Sponza and Lucy features the lowest ratio-its spotlights reduce the amount of shadow tests necessary. Overall there is no clear trend when comparing the overhead for different reduction levels. The fluctuations in run-time between them are likely caused by BVH split decisions. The fifth and sixth columns specify the absolute time necessary to decimate the scene initially and with importance. The additional cost for incorporating importance lies between 11% and 30%, depending again on the geometric complexity of the scene instead of its size. Here, local validity criteria may prevent collapses, as observed with the hairs in Hairy Yeahright; this causes longer collapse chains of single vertices, reducing the impact of the importance overhead.

Interaction with illumination-driven reduction and failure cases
Since we amended the original reduction pipeline, it is reasonable to discuss the possible effects on the reduction result in the context of caustic preservation. Figure 14 shows a comparison between the reduction pipeline with and without shadow silhouette preservation with equal importance weighting. Note that we used a relatively large area light source to get somewhat converged results. Both versions keep the caustics mostly intact, but do not fully preserve them. This is due to the poor convergence of caustics in path tracing and thus the poor importance convergence. However, the shadow silhouette of the dragon's head is visibly disfigured in Figure 14(c). Generally, the preservation of caustics will suffer when preserving shadow silhouettes at the same time if the allotted vertex budget does not allow both to remain intact. It is difficult to predict which feature is deemed less important and depends on the brightness of both the shadow and caustics.
Another factor to consider is the influence of error quadrics. In certain edge cases they may hinder optimal reduction: most notably when only a very small part of a mesh has an observable effect on the image, for example, a small light source right in front of a diamond attached to a necklace with a rough surface. Our error will preserve the overall structure of the necklace as well, which may impact the quality of caustics if not a sufficiently high vertex budget has been allotted. Note that this particular case may be avoided by splitting necklace and diamond into two meshes. In all other cases where reduction occurs despite high importance, a low image error can no longer be guaranteed anyway. Table 1: Performance comparison of our approach between different scenes rendered at a resolution of 800×600 with 100 importance iterations/samples per pixel. Initial decimation is equal to total reduction. All timings are given as process time. Concluding the evaluation, we draw attention to scenarios our contributions do not cover. We cannot detect or preserve indirect shadows caused by brightly lit patches or caustics, as Figure 15 demonstrates. This is a fundamental limitation of our approach, which may be solved by exploring bidirectional rendering techniques such as shadow photons.

Conclusion and Future Work
We extended the illumination-driven mesh reduction [RGG15] to preserve shadows by detecting visible shadow parts and their silhouettes. We transitioned the original approach to path tracing and combined it with error quadrics to minimize geometric errors in uniformly important areas of a mesh. We have shown that this combination does not affect the quality of the original method.
As demonstrated in Figure 7, it remains a challenge to reliably detect the entire silhouette we wish to retain. Possible avenues for improvement include an extended intersection test to find close-by faces as well as spreading importance to neighbouring faces when encountering a silhouette, although neighbourhood information is not readily available in index buffer-based renderers. An issue especially for caustic-heavy scenes is the lack of indirect shadow preservation, which makes it less suited for bidirectional renderers. Photon-based algorithms may explore the option of shadow photons as introduced by Jensen [JC96] as an alternative means to detect silhouettes capable of detecting indirect shadows as well, but would inherit the weaknesses of photon maps. Our estimation of penumbra size is also not applicable to environment maps, for which a classification into distinct area lights similarly to the approach by Annen et al. [ADM*08] may be used. Generally, perceptionbased features such as shadow transitions are influenced by postprocessing as well; tone-mapping in particular has a large say in whether parts of a scene with little illumination contain noticeable details or not and should influence the error metric. To conserve memory in large scenes, objects that occur multiple times are often instanced, meaning that the geometric data reside in memory only once; during rendering, a transformation matrix is then applied for each instance. The current approach reduces the mesh equally for all instances, leading to wasted reduction potential. In a similar vein, removing meshes or instances below a certain importance could prove beneficial for scenes with many objects. To render animated sequences, the reduction should be made temporally coherent. An issue for reduction algorithms in general are non-manifold meshes.