Fast Texture Based Form Factor Calculations for Radiosity using Graphics Hardware

Transcription

1 Fast Texture Based Form Factor Calculations for Radiosity using Graphics Hardware Kasper Høy Nielsen Niels Jørgen Christensen Informatics and Mathematical Modelling The Technical University of Denmark Abstract. This paper describes a method that speeds-up hemicube rendering by using texture maps to discretize a scene instead of geometric meshing. The method avoids subdivision of input surfaces and takes advantage of hardware texture mapping in order to accelerate form factor calculations. By using the method, we are able to compute finite element progressive radiosity significantly faster than when using traditional meshing. 1 Introduction Radiosity 1 is a popular method for calculating illumination for use in interactive walkthroughs. Because diffuse illumination is view-independent, realistically illuminated static environments can be rendered in real-time once a radiosity solution has been found. Traditional finite element radiosity meshes the scene into patches and elements. This scene description is used during radiosity sampling, where form factors are calculated and energy is propagated through the scene until a suitable solution is obtained. The result is an illuminated, but meshed scene. This paper describes a method that speeds-up hemicube-style form factor calculations by using texture maps to discretize the scene instead of geometric meshing. The method is a fast and simple alternative to traditional meshing since it avoids subdivision of input surfaces. In addition, it takes advantage of hardware texture mapping for hemicube rendering. Combined with radiosity textures it allows for closely connected sampling and reconstruction of radiosity scenes. 2 Background Information and Motivation The radiosity process generally consists of three different stages: Meshing, sampling and reconstruction. Previous work has focused primarily on using a texture representation for fast radiosity reconstruction. For rapid display of a radiosity solution, texture maps can be used to represent illumination [Myszkowski & Kunii 94, Möller 96, Bastos et al. 97, Zhukov et al. 98]. Such texture maps are referred to as radiosity textures, illumination maps or simply light maps. Because this reduces scene complexity, it can significantly improve rendering performance. However, it does not improve the performance of radiosity sampling. Hence, radiosity textures are primarily used for fast reconstruction of static environments. Previous work has used the texture parameterization during radiosity sampling to speed-up ray traced form factor computations [Arvo 86, Heckbert 90, Möller 96], where 1 The reader is expected to be familiar with radiosity. For a good introduction see [Cohen & Wallace 93]. 1

2 texture maps are used to represent scene discretization instead of meshing. Textures have also been used inside the radiosity computation by creating hierarchical convolution links instead of mesh refinement [Soler & Sillion 00]. Traditional radiosity works on a meshed scene description, making dynamic scene changes cumbersome. In addition, dynamic updates are computationally expensive due to the recalculation of form factors. The use of textures decouples shading and geometry and makes radiosity more suitable for dynamic scenes. It also reduces the number of required form factors in highly tessellated scenes, thus reducing computational cost. In order to make radiosity computations faster and more suitable for dynamic scenes, our goal is to create a simple method that uses textures to discretize the scene. Unlike previous work, we wish to use a non ray traced form factor method for faster form factor determination [Nielsen 00]. We choose to use the hemicube, since it is easy to accelerate using graphics hardware. While the hemicube suffers from aliasing artifacts, methods have been proposed that reduce aliasing [Baum et al. 89, Pietrek 93]. Graphics hardware has previously been used to speed-up ray traced visibility queries in hierarchical radiosity [Holzschuch & Alonso 00]. Our method differs, since it accelerates (non ray traced) hemicube visibility by using texture mapping, in progressive refinement radiosity. 3 Using Textures Instead of Meshing Traditional radiosity normally subdivides a scene into patches and elements. Patches are groups of elements that shoot energy, while elements receive energy. The main idea of our method is to use texture maps to represent this subdivision rather than subdividing surfaces geometrically (i.e., similar to [Arvo 86, Heckbert 90, Möller 96]). Hence, each texel in a texture map corresponds to an element or part of an element on a surface 2, and the discretization of the scene is reduced to a calculation of texture coordinates into these textures (as in [Myszkowski & Kunii 94, Möller 96, Bastos et al. 97, Zhukov et al. 98]). Thus, instead of geometric meshing, we pre-calculate the texture coordinates for each surface in a scene and the area of each texel when mapped onto its surface. For sampling we employ a standard progressive refinement procedure. Since patch geometry is not explicitly stored, we calculate patch centers on-the-fly based on the texture coordinates and the selected substructuring. To determine form factors we use a slightly modified version of the hemicube method, which we describe in section 3.1. Implementation details for taking advantage of graphics hardware are described in section 3.2. After convergence, the calculated solution is copied into radiosity textures for fast reconstruction. This is described in section Our Modified Hemicube Method Traditional radiosity draws geometric elements into the hemicube to determine element visibility and calculate form factors. To solve this task when using textures instead of meshing, we apply specially formatted index maps to each surface using the precalculated texture coordinates. We then render these surfaces into the hemicube. An index map is a pre-calculated texture map, in which each texel contains a form factor index from p to p + t 1, where p is the index of the first element in a surface, and t is the number of elements contained in the surface. See Figure 1. The index map 2 Here, the word surface is used to describe a collection of polygons that share the same texture. 2

3 (0,0) Element p+0 Surface p+1 p+2 p+3 (1,0) 2. Surface is rendered into the Hemicube. Patch Hemicube Item-buffer 1. Index Map is applied to surface p+4 p+5 p+6 p+7 and offset by p. p+10 p+11 p+9 Index Map p+8 (1,1) p+14 p+15 p+13 p Form factor indices are used to index the (0,1) Form Factor Table form factor table Index Form factor p+0 p+1 p p Surface id id id id.... id Element index Figure 1. Illustration of our modified hemicube method: (1.) A small index map is applied onto a square surface, and (2.) rendered into the hemicube. (3.) A form factor index (p +0) is then used to access the form factor table. is used to discretize the rendered surfaces into elements and is applied without filtering (i.e., nearest neighbor). In this way each element is given a unique form factor index, which is used to index the form factor table. The indices in the index map do, in theory, not have to be ordered in any specific way, but it must be possible to use a texel index to find its corresponding patch and element in the data structure. Several texels can also share an index to represent arbitrarily shaped elements. While it is possible to assign unique index maps to each surface, this is memory intensive in scenes with many surfaces. Instead, we use a single index map (containing element indices from 0 to t 1) which is first offset by p when drawing into the hemicube. In order to send energy to the correct elements we also store the id of each surface and its element indices in the form factor table (as shown in Figure 1). For actual implementations this information does not have to be coupled with the form factors and can be stored in a more efficient data-structure. After drawing all the surfaces in the scene, the result is an item-buffer where each surface is discretized into elements. The drawn result in the hemicube is similar to a regular subdivision. An example scene is shown in Figure 2. Non-discretized surfaces are drawn into the hemicube in a standard manner, assigning only one index per surface. The form factors are finally calculated by traversing the item-buffer as usual. It is important to observe that the use of textures to discretize the scene does not affect the geometric complexity of the scene. Because of this, fewer polygons travel through the rendering pipeline while drawing into the hemicube and therefore the method speeds-up the calculation of form factors. For comparison of the scene complexity between our method and regular meshing, refer to Figure 2 (d) and (e). Here, it is assumed that a system will become transform-limited by the large number of elements, which is normally the case. If a system is fill-limited, the decreased complexity will not result in a speed-up, since the number of filled pixels remains the same regardless of the complexity. Still, the use of textures decouples form factor computations from the level of discretization, and makes it possible to use the same scene description for solutions of different discretization levels. This has several advantages, e.g., textures can be used to discretize complex curved surfaces and objects with different levels of detail (as in [Möller 96]). It may also be possible to reduce aliasing artifacts by dynamically switching to coarser index maps. 3

4 (a) (b) (c) (d) (e) (f) Figure 2. Coarse uniform discretization of a scene using texture maps: (a) The scene shown with index maps applied. (b) The scene shown with surface offsets. (c) The textured scene shown with form factor indices used for hemicube rendering. This is essentially image a + b. (d) The complexity of the scene, shown in wireframe (13 quads). (e) For comparison, the complexity of the scene when using regular meshing (439 quads). (f) The index map (8 8 texels) used for all the surfaces. All images are shown in black and white (the actual indices are encoded as colors) and the levels have been scaled to make intensity differences between elements clearer. 3.2 Taking Advantage of Hardware Texture Mapping In order to use graphics hardware to draw surfaces into the hemicube we take advantage of a hardware texture blend operation to add the offset to the indices. However, because this functionality is normally intended for blending colors, it is generally not capable of adding arbitrarily sized words. Instead, color components are added individually and clamped to their maximum value, meaning that carry bits are discarded on overflow. Assuming that a pixel is represented by an m bit word, we solve this problem by storing the surface id and element index in separate groups of bits: The k least significant bits (the lower part) of the word represent the element index (where t =2 k 1 is the maximum number of texel elements) and the m k most significant bits (the upper part) of the word represent the surface id. This aligns the offset to 2 k elements and ensures that an overflow will not occur. Furthermore, this eases the decoding process, as the surface id and the element index of a textured surface can be extracted by simple bit shifting and masking operations and do not have to be explicitly stored in a datastructure. However, this alignment is unnecessary on a (hypothetical) system capable of performing unsigned integer (e.g., 32 bit) additions as a texture blend operation, or if unique index maps are assigned to the surfaces. Some surfaces may not use all the elements present in the index map. The encoding of form factor indices can introduce gaps in the form factor index sequence that result in phantom form factors that are never used. This can waste unnecessary memory, but the problem can be solved by using an efficient data-structure for storing form factors, such as a hash-table. Still, it is desirable to minimize the number of phantom form factors due to the limited dynamic range of the pixel representation. A system should generally 4

5 use different resolution index maps for differently discretized surfaces, and avoid the offset alignment of the form factor indices. For non-rectangular surfaces, unique index maps can be used, or to further reduce phantom form factors and reduce texture memory usage, illumination can be packed into larger radiosity textures [Zhukov et al. 98]. The encoding of form factor indices limits the maximum number of surfaces in the scene: e.g., when using a index map (12 bits) the maximum scene complexity will be 4096 textured surfaces on a 24 bit display. Of course, this is very limiting, but on a 32 bit display the maximum scene complexity will be approximately 1 million textured surfaces. In scenes with many small non-discretized surfaces, the number of surfaces can be even higher, since such surfaces only require a single index. Still, this may cause problems in scenes with many textured surfaces or when using very large index maps. If the hardware permits, it can be solved by increasing the dynamic range of the pixel representation. 3.3 Generation of Radiosity Textures Energy values are calculated for all elements during sampling. If the radiosity solution is uniformly discretized, these values can be used directly to create radiosity textures using a one-to-one mapping [Bastos 99], i.e., where sampled texels are mapped directly to texels in the radiosity textures. Pre-filtering and higher order reconstruction schemes can also be used [Bastos et al. 97]. The radiosity textures are finally used to render the illuminated surfaces using texture mapping with bilinear filtering. For non-discretized surfaces, Gouraud shading is used instead. For non-uniform discretization, the generation of radiosity textures is not as simple. The use of unique index maps, in which several texels share indices, works well for sampling, but makes reconstruction more difficult. To generate radiosity textures without discontinuities it is necessary to interpolate the sampled values, but bilinear filtering cannot be used because each texel does not correspond to an element. A quadtree type discretization can be flattened into radiosity textures (as described in [Bastos et al. 97]), and more complex meshing schemes (e.g., discontinuity meshing) can generate radiosity textures by hardware rendering elements as Gouraud shaded triangles. Yet, these methods are not as fast and simple as a one-to-one mapping. 4 Results The described method has been incorporated into a radiosity system. To simplify reconstruction, the implementation was restricted to uniform discretization. Radiosity solutions were calculated for different scenes and compared to regular uniform meshing. For the initial tests we used a single resolution index map to discretize the scene in Figure 2. Each solution was found using progressive refinement, terminated after 100 shots. Graphics hardware was used for hemicube rendering, and two different hemicube resolutions were used to test how our method responds to changes in sampling resolution compared to regular meshing. The tests were performed both with and without hardware vertex processing. All tests were conducted on an Intel Pentium III 450 MHz PC, with 256 MB RAM, running Windows, and equipped with an NVIDIA GeForce 3 graphics accelerator. The test system was written in C++ and used DirectX 8.0. The results are shown in Table 1. The results show a factor of up to 2.2 ( 8.1/3.6) times speed improvement over regular meshing with software vertex processing, and up to 1.2 ( 4.4/3.6) with hardware vertex processing. Only a small speed-up is achieved, since hemicube rendering does 5

6 Vertex processing: Software Hardware Regular meshing: Coarse Medium Fine Coarse Medium Fine hemicube 4.8 (4.6) 5.9 (5.6) 8.1 (7.7) 3.6 (3.6) 4.0 (3.8) 4.4 (4.0) hemicube 9.1 (8.9) 11.4 (11.2) 21.1 (20.4) 8.4 (8.3) 8.6 (8.4) 14.8 (14.0) Using textures: Coarse Medium Fine Coarse Medium Fine hemicube 3.4 (3.2) 3.5 (3.2) 3.6 (3.2) 3.2 (3.2) 3.4 (3.2) 3.6 (3.2) hemicube 8.5 (8.4) 8.7 (8.5) 9.4 (8.6) 8.4 (8.3) 8.6 (8.4) 9.3 (8.5) Table 1. The table shows the measured runtimes in seconds. The solutions were found at three different discretization levels: coarse (241 elements), medium (961 elements) and fine (3841 elements), using a patch size of 2 2, 4 4 and 8 8 elements. The total time used for hemicube rendering, item-buffer readback and form factor calculations is shown in parenthesis. not become noticeably transform-limited on such a simple scene. After sampling, the spectral energy was converted to colors and stored in radiosity textures. The textures were generated by using a one-to-one mapping, and pre-filtered using a 3 3 triangle-filter. Example scenes are shown in Figure 3. The method was tested on a more complex scene, consisting of 8088 triangles. See Figure 4. A single index map was used to discretize the scene, and surfaces were allowed to share textures in order to pack illumination into larger radiosity textures. The results are shown in Table 2. Vertex processing: Software Hardware Regular meshing: Coarse Medium Fine Coarse Medium Fine hemicube 21.3 (18.9) 61.4 (59.5) (186) 6.7 (5.7) 13.4 (12.3) (108) hemicube 31.9 (30.4) (102) (294) 20.8 (18.8) 26.3 (23.9) (141) Using textures: Coarse Medium Fine Coarse Medium Fine hemicube 9.0 (6.6) 9.7 (7.8) 14.5 (7.8) 4.9 (3.9) 5.2 (4.1) 9.9 (4.1) hemicube 20.9 (19.4) 21.5 (19.4) 26.1 (19.4) 16.8 (14.8) 17.2 (14.8) 21.9 (14.8) Table 2. The table shows the measured runtimes in seconds for the complex scene. The scene was discretized into a total of elements, elements and elements for the coarse medium and fine solutions respectively. When using textures, this was done using a 64 64, and resolution index map. The results show a speed-up of 2.4 to 13 ( 193/14.5) with software vertex processing, and 1.4 to 8 ( 114/9.9) with hardware vertex processing. Thus, we achieve a significant speed-up, even with hardware vertex processing. The speed-up is largest for fine discretization levels. When using textures instead of meshing, the form factor performance is practically independent of the discretization level, since the measured runtimes only differ slightly between the coarse, medium and fine solutions. This is due to the low scene complexity of the non-subdivided scene. When using textures, the number of rendered primitives is not affected by increasing the level of discretization. The change in hemicube resolution has a similar effect on the runtime compared to regular meshing. This is not surprising, as the number of filled pixels is exactly the same in the two methods. The increase in runtime is due to the readback of the item-buffer to system memory and the subsequent software traversal of the form factor indices. 6

7 5 Discussion From the results we see three important advantages of the method: First, the speed of radiosity sampling becomes almost independent of the discretization level. This is a significant property, since it means that we can expect roughly the same computational cost for determining form factors in a scene discretized into say 100 elements and the same scene discretized into elements. Second, the method avoids subdivision of input surfaces. This makes it advantageous for discretizing complex scenes that would otherwise become very transform-limited with traditional meshing. Furthermore, sampling is performed directly on the non-subdivided scene description, making it suitable for dynamic scenes. Third, the use of texture mapping makes it well suited for hardware acceleration and results in a faster calculation of form factors. The method was found to be up to 2 times faster than regular meshing for calculating radiosity in a simple scene, and up to 13 times faster in a more complex scene. This is due to a faster visibility determination. The results show that the method is most advantageous for fine discretization levels. Greater speed-ups can be expected for even finer discretization levels, and the speed-up also scales to more complex scenes as long as these contain surfaces that need to be discretized. However, for scenes containing objects with many small disconnected surfaces (e.g., a plant) the method will not provide a speed-up. We have described ways to reduce phantom form factors introduced by the method. To summarize, two things need to be resolved to eliminate this problem: First, the mapping of spare elements outside surface boundaries should be avoided by using unique index maps, or by packing illumination into larger radiosity textures. Second, to avoid the offset alignment, the graphics hardware should have a texture blend operation for performing unsigned integer additions. Another drawback is that the dynamic range of the pixel representation can limit the complexity of the scene. However, this was not a problem for any of the tested scenes. The complex scene used 8 different offsets. This is only a fraction of the available offsets, which was the worst-case limit for the fine discretization level. Our implementation was restricted to uniform discretization, but it would be fairly straightforward to extend the method to non-uniform discretization. However, a more efficient way to generate radiosity textures is needed to make completely arbitrary discretizations more attractive. Finally, although we use graphics hardware for hemicube rendering, the described method can also be advantageous in transform-limited software implementations. It could also be adapted to other hemicube-like methods, e.g., the single plane method or the cubic tetrahedral method. 6 Acknowledgements The authors would like to thank Tomas Akenine-Möller for his encouragement and helpful comments. Thanks also to Mads Nyholm-Larsen, Bent Dalgaard Larsen and Andreas Bærentzen for additional input. Finally, thanks to the anonymous reviewers for their constructive criticism. This work was supported in part by the STVF project DMM and the Nordunit2 project NETGL. 7

8 (a) (b) (c) Figure 3. Radiosity textured scenes, rendered without filtering as they appear after a one-to-one mapping. (a) The scene from Figure 2 (medium solution). (b) A scene using non-rectangular surfaces for the pyramid. (c) A scene containing a curved surface consisting of 5000 triangles. (a) (b) (c) (d) (e) (f) Figure 4. The complex scene (medium solution): (a) Shown without filtering. (b) The scene discretized using textures (shown with index maps and offsets). (c,d,e) Close-ups from the complex scene. (f) The illumination packed into eight radiosity textures ( ). 8

9 References [Arvo 86] J. Arvo. Backward Ray Tracing, In Developments in Ray Tracing, SIG- GRAPH 86 Course Notes, Volume 12, New York: ACM SIGGRAPH, [Bastos et al. 97] R. Bastos, M. Goslin, H. Zhang. Efficient Radiosity Rendering using Textures and Bicubic Reconstruction., In Symposium on Interactive 3D Graphics, pp , [Bastos 99] R. Bastos. Superposition Rendering: Increased Realism for Interactive Walkthroughs. PhD thesis, University of North Carolina, [Baum et al. 89] D. R. Baum, H. E. Rushmeier, J. M. Winget. Improving radiosity solutions through the use of analytically determined form-factors, Computer Graphics (Proc. SIGGRAPH 89). 23(3): pp , [Cohen & Wallace 93] M. F. Cohen, J. R. Wallace. Radiosity and Realistic Image Synthesis, Boston: Academic Press, [Heckbert 90] P. S. Heckbert. Adaptive Radiosity Textures for Bidirectional Ray Tracing. Computer Graphics (Proc. SIGGRAPH 90). 24(4): pp , [Holzschuch & Alonso 00] N. Holzschuch, L. Alonso. Using Graphics Hardware to Speed-up your Visibility Queries. journal of graphics tools. 5(2):33-47, [Myszkowski & Kunii 94] K. Myszkowski, T. L. Kunii. Texture mapping as an alternative for meshing during walkthrough animation. In Photorealistic Rendering Techniques. pp , Berlin: Springer-Verlag, [Möller 96] T. Möller. Radiosity Techniques for Virtual Reality Faster Reconstruction and Support for Levels of Detail. In Computer Graphics and Visualization 96 (WSCG 96), [Nielsen 00] K. H. Nielsen. Real-Time Hardware-Based Photorealistic Rendering. Master s Thesis, Informatics and Mathematical Modelling, The Technical University of Denmark, [Pietrek 93] G. Pietrek. Fast Calculation of Accurate Form Factors. In Proc. 4th Eurographics Workshop on Rendering, pp , [Soler & Sillion 00] C. Soler, F. Sillion. Texture-Based Visibility for Efficient Lighting Simulation. ACM Transactions on Graphics. 19(4): , [Zhukov et al. 98] S. Zhukov, A.Iones, G. Kronin. Using Light Maps to create realistic lighting in real-time applications. In Proceedings of WSCG 98 - Central European conference on Computer Graphics and Visualization 98, pp ,