View-dependent Refinement of Multiresolution Meshes Using Programmable Graphics Hardware <CGI special issue>

Transcription

1 The Visual Computer manuscript No. 642 (will be inserted by the editor) JUNFENG JI 1,3,4, ENHUA WU 1,2, SHENG LI 1,5, XUEHUI LIU 1 View-dependent Refinement of Multiresolution Meshes Using Programmable Graphics Hardware <CGI special issue> 1 State Key Lab. of Computer Science, Institute of Software, Chinese Academy of Sciences, Beijing, China 2 Department of Computer and Information Science, Faculty of Science and Technology, University of Macau, Macao, China 3 Graduate University of Chinese Academy of Sciences, Beijing, China 4 State Information Center, Beijing, China 5 School of Electronics Engineering and Computer Science, Peking University, Beijing, China jijfn@cei.gov.cn, ehwu@umac.mo, lisheng@graphics.pku.edu.cn, lxh@ios.ac.cn, vertex texturing, and then the node culling and Abstract View-dependent multiresolution rendering triangulation can be performed in the vertex shaders. Our demands a heavy load on CPU. This paper presents a new approach can generate adaptive meshes in real time, and method on view-dependent refinement of multiresolution can be fully implemented on GPU. The method improves meshes by using the computation power of modern the efficiency of mesh simplification, and significantly programmable graphics hardware (GPU). By the method, alleviates the computing load on CPU. two rendering passes are included. During the first pass, the level of detail selection is performed in the fragment Keywords: View-dependent multiresolution rendering, shaders. And the resultant buffer from the first pass is Level of Detail (LOD), Quadtree, Texture atlas, Graphics taken as the input texture to the second rendering pass by Processing Unit (GPU). 1 Introduction Multiresolution rendering is an efficient approach to accelerating the rendering of large models in real-time applications. To perform the multiresolution rendering, we need to build a hierarchical structure, implemented by mesh simplification [15, 21]) or level of detail (LOD) methods [8, 9]. View-dependent multiresolution rendering needs to perform LOD selection dynamically, and requires intensive computation for the on-the-fly tree traversal and re-triangulations, which induces a heavy load on CPU. It becomes desirable that if a part or large part of the load in this processing could be migrated from CPU to the programmable graphics hardware. Programmable graphics hardware, or GPU (Graphics Processing Unit), is a flexible programmable processor for graphics rendering, and has powerful computational ability from its parallel processing architecture. The vertex shaders in conventional GPU operate on each vertex independently, and the fragment shaders gather data from texture read operation, and process data on each fragment. With the support of float-point types for the rasterization pipeline, the geometry itself is allowed to flow through the GPU as a texture signal. The fragment shaders

2 gather data through texture accesses, where texture elements (texels) are organized into regular grids. Surface geometry is traditionally represented using irregular triangle meshes, but processing the irregular meshes is a daunting task for a fragment shader program. To perform geometry processing on GPU, the representation of the 3D surfaces needs to be converted into the regular form. The geometry images introduced by Gu et al [6] represent an arbitrary surface using a regular 2D grid sampling, which allows geometry to flow more naturally as a signal through the current GPU architecture. To permit this sampling, the surface is parameterized onto a square using a network of cuts. The cuts can result in complicated continuity constraints along the boundary of the square domain. Poly-cube maps [20], an extension of the cube map, can generate smooth atlas for arbitrary meshes. In this paper, we present an efficient multiresolution rendering framework for view-dependent LOD generation and rendering of large triangle meshes by using the programmable graphics hardware. The key point in our approach is to use a quadtree-based LOD structure, which is constructed from the geometry images, and then all the nodes in the quadtree are packed into a mipmap-like texture atlas, called LOD atlas textures. Since the multiresolution structure of the models is available to GPU in our approach, view-dependent refinement of multiresolution meshes can be done on GPU fully. The presented algorithm performs view-dependent level of detail on fragment shaders, and the adaptive meshes can be generated on vertex shaders dynamically. Because several fragment shaders in the GPU operate in parallel, there is significant opportunity for speed-up over a sequential CPU computation. Meanwhile, it substantially reduces the workload of CPU. Another advantage of our approach is that the data transmission through graphic bus would be reduced greatly, and thus higher efficiency could be achieved. 2 Previous Work Multiresolution rendering techniques have been investigated for many years. Various mesh simplification and LOD approaches have been proposed, such as progressive meshes [8, 9], hierarchical dynamic simplification [15]. These approaches consume much CPU resources at run-time, and it is difficult to transfer them onto GPU due to their complex data structure. Irregular meshes can be converted into those with (semi-) regular connectivity by surface parameterization and re-meshing, and multiresolution representation can be constructed from regular meshes by subdivision. Eck et al [4] and Lee et al [12] built regular triangular subdivision mesh from arbitrary meshes. The simplicity of regular meshes is amiable to the pipeline of graphics hardware. Terrain data sets in Digital Elevation Models (DEM) have a regular grid structure, and quadtree based hierarchical multi-resolution triangulations were studied for adaptive triangulation of DEM models [13, 16]. It is proved that quadtree based LOD methods are very efficient in terms of LOD selection, triangulation and rendering performance. DEM is similar to the texture in structure, and fits the GPU processing well. Several GPU-accelerated approaches to multiresolution rendering for terrain models have been proposed [3]. Gu and Hoppe et al [6] proposed the geometry image (GIM), a completely regular representation of 3D models. By the scheme, surfaces are converted into a topological disk using a network of cuts, and the surface geometry is mapped and sampled regularly in square or rectangle on parameter plane. The GIM s regular structure is similar to DEM, and thus the quadtree based LOD structure could be used naturally.

3 To alleviate the limitation on shape modelling, Sander et al [19] cut the surface as a series of topologically disk-like patches, or charts, and construct a multi-chart geometry image (MCGIM). However, the adjacent charts must be zippered or stitched together by a processing algorithm. To tackle this problem, Losasso et al [14] and Hoppe et al [10] created the smooth geometry images by spherical parameterization. Tarini et al [20] extended the cube-maps to poly-cube maps to deal with high-genus meshes [1, 3]. Point representations completely lack topological information [17, 18], so level of detail can be adapted easily by adding or removing single point. QSplat [18] uses a hierarchy of bounding spheres for LOD control and points-based rendering. In order to select the level of detail on the graphics processor, the hierarchical structure of QSplat is converted into a sequential data structure, called sequential point tree (SPT) [2]. SPT allows adaptive rendering of point clouds completely on the vertex processor. Although it can be extended to hybrid point-polygon rendering, it is still hard to process the adaptive mesh with topological connections. Recently introduced GPUs by Matrox and nvidia allow texture fetch within the vertex shaders, called vertex texturing [5]. The feature can be used to implement displacement mapping in hardware. Our algorithm employs vertex texturing to perform LOD culling and triangulation in the vertex shaders. 3 Conceptual Overview The goal of the presented approach is to utilize the parallel computation ability of modern programmable graphics hardware. However, GPU is a stream processor, and has distinct difference from CPU in programming architecture. The hierarchical representation and recursive traversal algorithm for multiresolution rendering implemented on CPU could not be transferred onto GPU directly. Therefore the data structure and algorithm for LOD selection on GPU must be designed dedicatedly [11]. 3.1 Geometry Images The presented algorithm would process the surface geometry on fragment processor, whose input data structure is texture. Geometry image (GIM) [6] is a texture-like representation of surfaces using a network of cuts and surfaces parameterizations. A pixel in the geometry image maps the 3D coordinates of a vertex of the meshes in object space, and four neighbouring pixels correspond to a quadrilateral on the surface in the object space. The GIM could fit well for the fragment shaders, and thus the geometry signal of a surface model can be sent to GPU by the float-point texture. The boundary pixels on GIM correspond to the cut on the surface. This results in complicated continuity and makes the LOD selection to be uncontrollable in the fragment shaders. To cut down extra work on the boundary stitching, we convert the arbitrary meshes into smooth multi-chart geometry images, which combine the features of smooth geometry images [14, 10] and multi-chart geometry images [19]. The creation of smooth multi-chart geometry images can be done by using poly-cube maps [20], a generic extension of cube maps. A poly-cube is a shape composed of axis-aligned unit cubes that are attached face to face. Its shape roughly resembles the given mesh, and then the meshes can be projected on its faces. Fig 1(b) is the poly-cube model of Fig. 1(a). The faces of a poly-cube can be cut and mapped onto the 2D parameter space, as shown in Fig. 1 (c). Since the boundary of the neighbouring charts are sampled in the same density and direction, the boundary could be stitched exactly (see Fig. 1 (d)), and thus a smooth geometry image atlas can be obtained.

4 (a) The original model (b) The poly-cube (c) The smooth GIM Fig. 1: Smooth geometry images (d) Remeshed model 3.2 GPU-based Multiresolution Representation To perform multiresolution rendering on GPU, we construct a quadtree-based multiresolution representation from geometry images, called P-Quadtree. The traversal of the quadtree can be implemented simply on CPU. However, it is difficult to be implemented on GPU. Although implementation could be done by a multi-pass rendering approach [1], the cost in render setting, and a large amount of data transmission over the graphics bus would be a heavy penalty. Our strategy to solve the problem is to stack each level of quadtree into a flat texture, called LOD atlas texture, as shown in Fig. 2. Each pixel in the atlas texture maps a unique node in the quadtree, so that the LOD selection can be implemented in a single rendering pass, and then the parallel computation power of the GPU can be utilized. LOD atlas texture is a new multiresolution representation of the geometric model. There are four textures for a model, including the normal map, the geometry map, the LOD parameter map and the index map. The geometry map and the normal map store the centre position and the normal of the nodes, which can be generated by the geometry image and the normal map of the vertices. These two maps are utilized to perform backface culling in view-dependent LOD selection. The LOD parameter map is used to store the node s LOD error, the normal cone and the radius of the bounding sphere of the node. The normal cone and the radius of the bounding sphere are also used for backface culling. The node s error is the metric for LOD selection. Because each node is performed independently in the fragment shaders, it may induce a new problem. If a node with its error below the LOD threshold is selected, all its children (or its sub-tree) would also be selected, and results in many redundant nodes selected. To combat this problem, the parent node must have been tested before the node itself is tested. If the parent node were selected, current node would be redundant, and must be discarded. The index map keeps the index of the parent node s parent, and facilitates addressing the hierarchical structure in the fragment processor. Fig. 2: The LOD atlas texture (GIM atlas) Beside LOD atlas texture, the triangle meshes need to feed GPU in the final rendering pass. Therefore, the nodes in the quadtrees should be converted into sequential form, called sequential nodes trees, whose structure is similar to that of Sequential Points Trees [2]. Each element in the sequential nodes trees is a quadtree node, whose shape is a triangle fan.

5 3.3 Algorithm Overview The whole process of our approach includes two stages: the preprocessing stage, an off-line stage to construct data structure, and the run-time stage to perform the LOD selection and render the models on GPU (see Fig. 3). Setting up the LOD atlas textures from a poly-cube model is in the preprocessing stage. It is composed of four steps: poly-cube creation, regular re-sampling to build smooth GIM atlas, P-Quadtree construction and LOD atlas texture conversion. This process is as shown in Fig. 3(a), and we will explain these steps in section 4. Multiresolution rendering is performed on GPU in runtime stage. It includes two passes. The first pass is used to perform the LOD selection, and all nodes are checked by a series of LOD tests with a fragment program in this pass. The triangulation and the final rendering are done in the second pass (see Fig. 3(b)). In this pass, the resultant buffer of the first pass is mapped to the vertices of the nodes using vertex texturing, and then the vertex program performs nodes culling and triangulation. Then the adaptive mesh is generated and rendered. Section 5 will examine this stage in detail. 3D Model Projection & Parameterization Poly-Cube Maps Mapping & Re-sampling Smooth GIM Atlas P-Quadtree Stacking LOD Atlas (a) The process to create LOD atlas textures LOD Atlas Textures Drawing a Rectangle & Mapping the Textures LOD Selection in the Fragment Shaders Pass 1 LOD Buffer Nodes of P-Quadtree Mapping Rendering Nodes Culling & Triangulation in the vertex Shaders Pass 2 Final Image (b) The pipeline for LOD selection and rendering Fig. 3: Diagram overview of our approach 4 Preprocessing The purpose of preprocessing is to convert the arbitrary meshes into the GPU-based multiresolution representation, including LOD atlas texture and the sequential nodes trees. 4.1 Smooth GIM Atlas Creation Firstly, the arbitrary meshes need to be converted into the smooth multi-chart geometry images, and then the poly-cube map is constructed. The poly-cube can be obtained by the semi-automatic technique introduced in [20]. In order to map the mesh to 2D parameter space, the faces of the poly-cube must be cut into planar faces, i.e. the charts. Tarini et al [20] subdivide the 3D texture space into cubic cells, and each cell is cut to be several face-lets. However, it is not suited well for LOD selection. We cut the ploy-cube along its edges and produce larger charts (see Fig. 4 (b)). After the poly-cube faces are cut into the charts, which may be square or rectangle in shape, the charts can be packed into a square or a rectangle on the parameter plane. Although the rectangle charts could result in a fewer number of charts, it is not a trivial work to pack the charts

6 into a 2D texture efficiently. Both schemes can be used in our approach. Though chart packing is a NP-hard problem, regular squares can be packed by the heuristic approximation. We first sort the charts by their size in descending order, and the charts with the same level are organized in one group. The charts in groups are packed into a bounding box one by one (see Fig. 4 (b)). Once the charts are packed into a square or a rectangle, the 2D grid sampling is performed to generate the geometry images. The sampling density of the edges must be matched with the corresponding edges in the neighbour charts. The sampled dimension of the chart in GIM pixels should be 2 m +1 to improve efficiency of quadtree traversal, where m is an integer. of the node, and r is the radius of its bounding sphere. According to the states of edge vertices (activated or not), the node can be efficiently triangulated, and its rendering can be accelerated in hardware by using a triangle fan. So the node is chosen as the basic rendering primitive in our approach. We construct quadtree top-down. The node attributes, such as radius of the bounding sphere, normal and the angle of normal cone (see Fig. 5(c)), are computed during the quadtree construction. These attributes will be utilized in the following step towards LOD tests n SW n NW C n C n NE n SE n C α r (a) Parameter space; (b) Object space; (c) Normal cone (a) The cutting scheme Fig. 4: The faces cutting of the poly-cube (b) The packing result 4.2 P-Quadtree Construction P-Quadtree can be constructed from the geometry images directly. Construction of quadtree requires the size of square in sampling to be (2 m +1) (2 m +1). The dimension of the square charts must meet this requirement. We construct the quadtree for each chart separately. A node in the presented algorithm is a 3 3 pixels block in geometry images, whose structure in parameter space is shown in Fig. 5(a). It contains 9 vertices, including 1 centre vertex (0), 4 corner vertices (2, 4, 6, 8) and 4 edge vertices (1, 3, 5, 7). Fig. 5(b) shows the quadrilateral in object space of the node, where n is the normal vector Fig. 5: The structure of a node Since the presented algorithm generates adaptive meshes dynamically, T-junction may appear when states of the edge vertex on both sides of the adjacent squares are not at the same level. A mesh containing T-junction tends to produces cracks in rendering. To overcome the artifacts, the restricted quadtree triangulation (RQT), an adaptive triangulation introduced in [7] to tessellate parametric surfaces, is used in our algorithm. RQT subdivision is constrained such that the levels of adjacent quadtree nodes differ by at most one, as shown in Fig. 6. To ensure the quadtree is restricted in our LOD algorithm, we construct the quadtree by pre-computing the error of the nodes. The error of a node is not only greater than that of its own children, but also greater than that of its adjacent nephew nodes 1. For example, the error of node C 1 The nephew nodes of a node are its adjacent siblings children.

7 must be greater than the node A and B, which are southern nephew nodes of C in south edge (see Fig. 6). Whether an edge vertex is activated can be determined by the state of its nephew nodes, which can be obtained by two texture-lookup instructions. Because of the smooth geometry images, the nephew of the boundary nodes in the quadtree can be found in the adjacent chart, and then the boundary nodes can be processed in the same way to the interior nodes. Thus the adaptive mesh can be obtained. Bad B C A Level n Level 1 Level 0 Fig. 7: P-Quadtree Stacking Level 0 5 GPU Implementation Level 1 This Section is the core of our approach. Section 5.1 gives the details in performing view-dependent LOD on the fragment shaders, and Section 5.2 explains how to cull the nodes and triangulate the meshes on the vertex shaders. Fig. 6: Restricted Quadtree Triangulation 4.3 P-Quadtree Stacking In order to implement the LOD selection on the fragment shaders efficiently, all nodes in the quadtree are packed into a LOD atlas. The hierarchical structure of P-Quadtree needs to be converted into flat textures to fit the architecture of the fragment shaders. Since the geometry image atlas is a square or a rectangle, we can stack all levels of quadtree side by side, as shown in Fig. 7. A quadtree node, or a 3 3 pixels block in GIM, is mapped onto one pixel in the LOD atlas. The bottom level of quadtree in the LOD atlas (level 0) is half of GIM atlas, and the size of level 1 is the half size of level 0, and so on, until the root s size is 1. All of the nodes can be stacked in a rectangle with ratio in 1: 1.5 (See Fig. 7). Sequential nodes trees can be constructed by a top-down traversal of P-Quadtree. This process is similar to the conversion of the hierarchical QSplat trees [18] into sequential point trees [2]. 5.1 LOD Selection The LOD atlas textures flow to the fragment shaders by drawing a square or a rectangle, whose pixels are 1-1 mapping to the texels of LOD atlas textures. The error threshold for LOD test is computed from the viewpoint on CPU, and is passed to fragment program through a parameter register. We perform the LOD selection using a fragment program, which includes a series of LOD tests. The test result is stored in a buffer, called the LOD buffer. Although the result of a node selection is a Boolean data, the LOD buffer should be in float-point data format for vertex texturing. The fragment program tests each fragment. Firstly, we discard the null texels by conditionally killing the corresponding fragment. To skip the null texels in the test, it requires to assign a special value to the parent s index of the null texels. Since we stacked the level 0 of P-Quiadtree at the coordinate origin of the texture (see Fig 7), (0, 0) can be employed as the special value. For all of the valid nodes, the LOD test would be performed. The error threshold for LOD test is

8 read from the parameter register. If the error of a node exceeds the threshold, the node is discarded; otherwise the node is tested in the following tests. As each node is tested independently in parallel, it induces a new problem. If a node with its error below the LOD threshold is selected, all its children (or its sub-tree) would also be selected, and results in many redundant nodes selected. This problem can be solved by performing two LOD tests for each node. One is used to test its parent, and the other to test itself. If the parent of a node is passed the test, the node should be a redundant node, and must be discarded; otherwise we perform the LOD test for the node itself. We use the index map to address the parent node in the fragment program. Once a node passed the LOD selection, the visibility culling would be performed. We perform backface culling using the normal and the normal cone. The backface can be determined by using the following criterion proposed in [15]: α + β + θ < π /2 (1) where α and β are the angles of normal cone and viewing cone separately, and θ is the angle between the center vectors of normal cone and viewing cone (see Fig.8). These angles can be estimated in the fragment program using an approximate approach. If a node passes all the tests above, it is a selected node. The test result is output to the LOD buffer. In our implementation, P-Buffer is served as the LOD buffer, and so the render-to-texture techniques can be employed to send the output to the next rendering pass. Bounding sphere β Fig. 8: Backface culling [15] Viewing cone Normal cone θ 5.2 Nodes Culling and Triangulation The LOD buffer generated from the first pass is applied to the rendering nodes in the final rendering pass to cull the discarded nodes and triangulate the selected ones in the vertex shaders. During this pass, Sequential nodes trees are sent to GPU one by one. The nodes are drawn in object space by using triangle fans. To apply the LOD selection result to the nodes, the LOD buffer is required to be accessible to the nodes. However, reading the buffer back into host memory and sending the result back to the graphics card would be prohibitively expensive. We use the render-to-texture technique to send the LOD buffer to the second pass, and then map LOD buffer to vertices of the nodes by using vertex texturing in the vertex shaders to cull the nodes that fail to be selected. Nodes culling. We perform nodes culling by processing their vertices. A pixel in the LOD buffer corresponds to the LOD selection result of a node, and maps to all vertices of the node. Each vertex is tested by the pixel s (or texel s) value mapped from the LOD buffer. Vertices that passed the test would keep intact, but those failed in the test are culled by moving them to infinity. A node would be culled when all of its vertices have failed the test. Mesh triangulation. The presented algorithm requires generating adaptive meshes view-dependently. This may cause T-junction between the adjacent nodes with different levels. We must triangulate the node after the node culling. The vertex shaders process each vertex independently, and thus each node must be triangulated based on its local information. As the restricted quadtree triangulation in our approach is in constraint that the levels of adjacent quadtree nodes differ by at most one, only the 4 edge vertices (the white dot 1, 3, 5 and 7 in Fig. 5(a)), located in the middle of the

9 node s edge, need to be checked. The other vertices can skip over this test stage Fig. 9: Triangulation in the vertex shader Since it is hard to delete or add a vertex in the vertex shaders, we send all the 9 vertices of the node to GPU, which can be implemented by drawing a triangle fan. The 4 edge vertices have two different position attributes: one is for itself, and the other is for a corner. If the edge vertex is not activated, we move it to the position of that corner, and thus the vertex seems to disappear. For example, the vertex 1 could be moved to corner vertex 2, and 3 to 4, etc (see Fig 9). That corner s position can be sent to the vertex shaders by a generic attribute input register. To test whether an edge vertex is activated, we check the state of its nephew nodes adjacent to the vertex (see section 4.2). As we use the restricted quadtree, only 1 level below the current level needs to be tested, so there are only two adjacent nodes need to be tested. Their states can also be looked up from the LOD buffer, and can be determined by two sets of coordinates for the edge vertex. The result of the vertex program is fed to the rasterization pipeline. The lighting can be computed in the vertex shaders or in the fragment shaders, and the final image of the model is generated. windows 2000 operating system. The GPU program described above are implemented by NVIDIA s OpenGL extension. All the test cases run on a PC with a 2.8GHz Pentium 4 processor with 2G DRAM having an NVIDIA GeforceFX 5950 GPU supported by 256MB of DDR RAM. Fig. 10 shows the different stages of our approach. The image of the LOD buffer in the first pass is shown in (a), where the red pixels are the selected nodes and the others are discarded or invalid. It shows that most of the nodes are culled. After culling and triangulation of the nodes, the resultant mesh s structure in the parameter space is as shown in (b). The red dots are the centre of the nodes, and the blue lines draw the structure of the selected nodes. The discontinuity of the mesh is due to the backface culling. To demonstrate clearly, we use lower resolution GIM (54,465 GIM atlas pixels) and medium error threshold. It also shows that the restricted quadtree triangulation generated. The final rendered result in the object space is shown in (c) and (d). Our algorithm is able to generate the adaptive meshes dynamically according to the viewpoint. Fig. 11 shows the rendering result of Bunny at different viewing distances. As the model recedes further, more decimated level of the hierarchy is chosen and the number of the selected nodes is reduced with a higher frame rate. The rendering result of the model with high genus is shown in Fig. 12. Multiple models can be packed into a single LOD atlas, and can be processed by our approach (see Fig. 13). 6 Results and Discussions We have implemented the data processing pipeline by using VC++ and OpenGL under

10 (a) The image of the LOD buffer after the first pass. Each pixel is a node (the red pixels are the selected nodes, in 1,445 among the total number of 18,083 nodes) (b) The adaptive meshes in the image domain generated by the selected nodes Fig. 11: Bunny at different viewing distances. Left: Close range (11,521 nodes). Middle: At a distance (2,968 nodes). Right: Even further away (1,337 nodes). (c) The generated mesh (d) The rendering result Fig. 10: The results at different stages The performance of our algorithm is summarized in Table 1. It shows that the GPU implementation is about one order of magnitude more efficient than the corresponding CPU implementation, and it is also more efficient than the tree traversal approach on CPU. Moreover, the CPU load is also reduced. For the large datasets, CPU load of our approach is increased due to the limitation of the video memory. By using NVIDIA's SLI (Scalable Link Interface) multiple-gpu technique, the performance of our algorithm may be doubled due to its highly parallel computing feature. Fig. 12: Rendering results of model with high genus. The left image is rendered using 1,436 nodes, and the right one is rendered by using 500 nodes. The total number of the nodes is 34,108 Since the multiresolution representation of the geometric model is fully available on GPU, most of the work can be done on GPU, and CPU just need to send rendering functions and a few parameters. So the data transmission would be minimal through graphics bus. The memory usage of our algorithm is very low, as shown in Table 1.

11 Table 1: Performance of our LOD selection algorithm Models Laurana Bunny Laurana & Armadillo # Charts Valid GIM Pixels 54, , ,496 Total nodes 18,083 96,210 93,116 Our GPU implementation Time (ms) CPU load 4-8 % 10 17% 14-26% Fig. 13: The multiple models rendering results. Laurana and Armadillo are packed into a single atlas. The left image is rendered by using 24,950 nodes, and the right one is rendered by using 7380 nodes In our current implementation, we fetch the LOD buffer from GPU, and assign the result to the nodes and their vertices. This process is expensive (about 0.7 to several ms). For the latest GPU, such as NVIDIA GeforceFX 6xxx (NV40 GPU), the result can be mapped onto the vertices of the nodes directly in the vertex shaders, so the performance could be expected to have further improvement greatly. Our LOD approach also has limits in the scope of the applicability. If the topology of a mesh is too complex or has features at very different scales, it is not efficient to represent by poly-cube maps. Another limit is the size of video memory and the data-transmission rate of graphics bus. Larger memory and PCI Express interface would be expected to deal with larger datasets more efficiently. 7 Conclusion and Future Work We have brought forward a new method to refine multiresolution meshes view-dependently by Our CPU implementation Tree traversing on CPU Time (ms) CPU load ~43% ~70% ~75% Time (ms) CPU load 25 33% 50 75% % using modern programmable graphics hardware. The results have proved that the method is robust and efficient, and the computing load of CPU is also alleviated. The presented algorithm can produce the adaptive tessellation for the detailed surfaces dynamically, and could be fully implemented on GPU. Due to the quadrilateral structure, one of our future works may be to extend our approach to complex scenes, so that adaptive tessellation for radiosity computation may be implemented on GPU. Because of the limits of the vertex shaders, we merge vertices to suppress the T-junction. This could cause the generation of degenerated triangles. Although we have not seen apparent popping or aliasing effects in our current implementation, there might be the problem in the photo-realistic rendering. We use only one channel of LOD buffer to save the result (a Boolean data type). Therefore,

12 it is possible to do more complex operation in the fragment program for LOD selection. Acknowledgements The work is supported by the National Fundamental Research Grant of Science and Technology (973 Project: 2002CB312102), NSFC ( , , ), and the Research Grant of University of Macau. References 1. Bogomjakov A, Gotsman C (2004) GPU-Assisted Z-Field Simplification. 3D Data Processing, Visualization and Transmission 2004: Dachsbacher C, Vogelgsang C, Stamminger M (2003). Sequential Point Trees. Proceedings of SIGGRAPH 2003, pp , Dachsbacher C, Stamminger M. Rendering Procedural Terrain by Geometry Image Warping. Eurographics Symposium on Rendering Eck M, DeRose T, Duchamp T, Hoppes H, Lounsbery M and Stuetzle W (1995) Multiresolution Analysis of Arbitrary Meshes. Proceedings of SIGGRAPH 1995, pp Gerasimov P, Fernando R, Green S (2003) Shader Model 3.0 Using Vertex Textures. Technical White Paper, NVIDIA Corporation. 6. Gu X, Gortler S, Hoppe H (2002) Geometry Images. Proceedings of SIGGRAPH 2002, pp Herzen B, Barr A. Accurate (1987) Triangulations of Deformed, Intersecting Surfaces. Proceedings SIGGRAPH 1987, pp Hoppe H (1996) Progressive Meshes. Proceedings of SIGGRAPH 1996, pp Hoppe H (1997) View-dependent Refinement of Progressive Meshes. Proceedings of SIGGRAPH 1997, pp Hoppe H, Praun E (2005) Shape Compression Using Spherical Geometry Images. Advances in Multiresolution for Geometric Modelling. Springer, pp Ji J, Wu E, Li S and Liu X (2005). Dynamic LOD on GPU. Proceedings of CGI 2005, June 2005, Stony Brook, New York, USA, pp Lee A, Sweldens W, Schroder P, Cowsar L, Dobkin D (1998) MAPS: Multiresolution Adaptive Parametrization of Surfaces. SIGGRAPH 1998, pp Lindstrom P, Koller D, Ribarsky W, Hodges L, Faust N, Turner G (1996) Real-time, Continuous Level of Detail Rendering of Height Fields. Proceedings. of ACM SIGGRAPH 1996, pp Losasso F, Hoppe H, Schaefer S, Warren J (2003) Smooth Geometry Images, Proceedings of the Eurographics/ACM SIGGRAPH symposium on Geometry processing. 15. Luebke D, Erikson C (1997) View-Dependent Simplification of Arbitrary Polygonal Environments, Proceedings of SIGGRAPH 1997,pp Pajarola P (1998) Large Scale Terrain Visualization Using the Restricted Quadtree Triangulation. Proceedings IEEE Visualization 98, pp Pfister H, Zwicker M, Baar J, Gross M (2000) Surfels: Surface Elements as Rendering Primitives, Proceedings of SIGGRAPH 2000, pp Rusinkiewicz S, Levoy M (2000) QSplat: A Multiresolution Point Rendering System for Large Meshes, Proceedings of SIGGRAPH 2000, pp Sander P, Wood Z, Gortler S, Snyder J, Hoppe H (2003) Multi-Chart Geometry Images. Eurographics Symposium on Geometry Processing 2003, pp Tarini M, Hormann K, Cignoni P, Montani C (2004) PolyCube-Maps. Proceedings of SIGGRAPH 2004, pp Xia J, Varshney A (1996) Dynamic View-dependent Simplification for Polygonal Models. Proceedings of IEEE Visualization 1996, pp