A Survey of Nonlinear Prefiltering Methods for Efficient and Accurate Surface Shading <s> Silhouettes and Curvature <s> This paper introduces an algorithm that, given the geometry and surface characteristics of an object (the Phong highlight model is assumed), detects when specular or highlight aliasing is expected and indicates the correct sampling rate to eliminate it. This is accomplished by noting the geometric properties of the surface, the direction and distances to the eye and light sources, and the specular shading parameters. Also, an auxiliary algorithm is presented that eliminates the specular aliasing without increasing the sampling rate. It accomplishes this by clamping the specular function parameters to values that will not introduce significant high frequency components. <s> BIB001 </s> A Survey of Nonlinear Prefiltering Methods for Efficient and Accurate Surface Shading <s> Silhouettes and Curvature <s> Approximating detailed with coarse, texture-mapped meshes results in polygonal silhouettes. To eliminate this artifact, we introduce silhouette clipping, a framework for efficiently clipping the rendering of coarse geometry to the exact silhouette of the original model. The coarse mesh is obtained using progressive hulls, a novel representation with the nesting property required for proper clipping. We describe an improved technique for constructing texture and normal maps over this coarse mesh. Given a perspective view, silhouettes are efficiently extracted from the original mesh using a precomputed search tree. Within the tree, hierarchical culling is achieved using pairs of anchored cones. The extracted silhouette edges are used to set the hardware stencil buffer and alpha buffer, which in turn clip and antialias the rendered coarse geometry. Results demonstrate that silhouette clipping can produce renderings of similar quality to high-resolution meshes in less rendering time. <s> BIB002 </s> A Survey of Nonlinear Prefiltering Methods for Efficient and Accurate Surface Shading <s> Silhouettes and Curvature <s> Many researchers have been arguing that geometry, bump maps, and BRDFs present a hierarchy of detail that should be exploited for efficient rendering purposes. In practice however, this is often not possible due to inconsistencies in the illumination for these different levels of detail. For example, while bump map rendering often only considers direct illumination and no shadows, geometry-based rendering and BRDFs will mostly also respect shadowing effects, and in many cases even indirect illumination caused by scattered light. In this paper, we present an approach for overcoming these inconsistencies. We introduce an inexpensive method for consistently illuminating height fields and bump maps, as well as simulating BRDFs based on precomputed visibility information. With this information we can achieve a consistent illumination across the levels of detail. The method we propose offers significant performance benefits over existing algorithms for computing the light scattering in height fields and for computing a sampled BRDF representation using a virtual gonioreflectometer. The performance can be further improved by utilizing graphics hardware, which then also allows for interactive display. Finally, our method also approximates the changes in illumination when the height field, bump map, or BRDF is applied to a surface with a different curvature. <s> BIB003 </s> A Survey of Nonlinear Prefiltering Methods for Efficient and Accurate Surface Shading <s> Silhouettes and Curvature <s> Significant visual effects arise from surface mesostructure, such as fine-scale shadowing, occlusion and silhouettes. To efficiently render its detailed appearance, we introduce a technique called view-dependent displacement mapping (VDM) that models surface displacements along the viewing direction. Unlike traditional displacement mapping, VDM allows for efficient rendering of self-shadows, occlusions and silhouettes without increasing the complexity of the underlying surface mesh. VDM is based on per-pixel processing, and with hardware acceleration it can render mesostructure with rich visual appearance in real time. <s> BIB004 </s> A Survey of Nonlinear Prefiltering Methods for Efficient and Accurate Surface Shading <s> Silhouettes and Curvature <s> Shell mapping is a technique to represent three-dimensional surface details. This is achieved by extruding the triangles of an existing mesh along their normals, and mapping a 3D function (e.g., a 3D texture) into the resulting prisms. Unfortunately, such a mapping is nonlinear. Previous approaches perform a piece-wise linear approximation by subdividing the prisms into tetrahedrons. However, such an approximation often leads to severe artifacts. In this paper we present a correct (i.e., smooth) mapping that does not rely on a decomposition into tetrahedrons. We present an efficient GPU ray casting algorithm which provides correct parallax, self-occlusion, and silhouettes, at the cost of longer rendering times. The new formulation also allows modeling shells with smooth curvatures using Coons patches within the prisms. Tangent continuity between adjacent prisms is guaranteed, while the mapping itself remains local, i.e. every curved prism content is modeled at runtime in the GPU without the need for any precomputation. This allows instantly replacing animated triangular meshes with prism-based shells. <s> BIB005 </s> A Survey of Nonlinear Prefiltering Methods for Efficient and Accurate Surface Shading <s> Silhouettes and Curvature <s> We introduce Linear Efficient Antialiased Normal (LEAN) Mapping, a method for real-time filtering of specular highlights in bump and normal maps. The method evaluates bumps as part of a shading computation in the tangent space of the polygonal surface rather than in the tangent space of the individual bumps. By operating in a common tangent space, we are able to store information on the distribution of bump normals in a linearly-filterable form compatible with standard MIP and anisotropic filtering hardware. The necessary textures can be computed in a preprocess or generated in real-time on the GPU for time-varying normal maps. The method effectively captures the bloom in highlight shape as bumps become too small to see, and will even transform bump ridges into anisotropic shading. Unlike even more expensive methods, several layers can be combined cheaply during surface rendering, with per-pixel blending. Though the method is based on a modified Ward shading model, we show how to map between its parameters and those of a standard Blinn-Phong model for compatibility with existing art assets and pipelines, and demonstrate that both models produce equivalent results at the largest MIP levels. <s> BIB006
Silhouettes correspond, by definition, to grazing view angles. As already seen, this case is problematic for the surface map prefiltering methods, because many correlations cannot be neglected in this situation. But the very first problem is that the coarse mesh plus surface map representation somehow breaks down in this situation, because the coarse mesh resolution becomes clearly visible at silhouettes. There are however some solutions to this problem, like Displacement Mapping  , Silhouette Clipping BIB002 , or Shell Mapping BIB005 . The curvature of the coarse mesh on which the surface maps are defined can also be a problem. For instance, a normal map with only vertical normals, once prefiltered in texture space, will still have only vertical normals. This is clearly false for a prefiltered area covering a curved part of the underlying coarse mesh: the normals distribution should reflect this curvature BIB001 . A solution is to express the normals in a global frame, instead of in the tangent space to the surface (this is possible with most normal map prefiltering methods, except those explicitly using this Fig. 7 . Parallax offset and Jacobian. Top: for a correct rendering, the surface maps must not be evaluated in A 0 , the pixel footprint on the coarse mesh (dotted blue line), but in the orthogonal projection A of the pixel footprint S on the complex surface (here, using A 0 would give a green color, instead of brown, the correct result). Bottom: the parallax Jacobian nv ng has important effects with near vertical facets. Here, without it we find the green part as dominant, in A, while in fact, orthogonally to v, this is the brown part. tangent space, like BIB006 ). But then, the normal map cannot be a pattern mapped in a repetitive way on an object. It must also be specific for each object, and the objects cannot be deformed. Curvature is also a problem for horizon maps: the horizon angles depend on the curvature of the underlying surface. Heidrich et al. BIB003 precompute five horizon maps for five predefined curvatures, and then interpolate between them at runtime. However, they do not address the prefiltering of these maps. Note that Bidirectional Texture Functions also suffer from the silhouette and curvature problems. Wang et al. BIB004 solve the curvature problem in the case of a 4D "semi-BTF" where the light direction is fixed, by introducing an additional curvature parameter, yielding a 5D table. Using the same approach for a full BTF would give a 7D table, which is clearly too much (a normal BTF is already quite difficult to manage in terms of memory).