KR100959349B1 - A method for accelerating terrain rendering based on quadtree using graphics processing unit - Google Patents

Abstract

PURPOSE: A method for accelerating terrain rendering based on a quad-tree using a graphic processing unit is provided to prevent the decrease of the speed caused by the creation of lots of vertices. CONSTITUTION: Through the selection of an LOD(Level Of Detail), nodes of each block are searched. By a hierarchical VFC(View Frustum Culling), the inner vertices among the vertices of searched nodes are proliferated in a quad-tree. Plural visible vertices are created(S100), and the patch for removal of a crack is created through a neighbor node inspection between the created meshes(S200).

Description

A METHOD FOR ACCELERATING TERRAIN RENDERING BASED ON QUADTREE USING GRAPHICS PROCESSING UNIT}

The present invention relates to a method for accelerating a terrain rendering method, and more particularly, to a method for accelerating a photo tree-based terrain rendering method using a graphics processing unit (GPU).

Terrain rendering is often used to represent realistic outdoor scenes in computer games and flight simulation. Because terrain rendering handles huge input data, creating meshes of the same resolution can be difficult to handle, even on modern graphics hardware with large amounts of video memory. Therefore, we need to apply the mesh simplification techniques to properly maintain the quality of the resulting image.

A quadtree is a hierarchical data structure that efficiently represents a two-dimensional space. Photo tree is effective for continuous level of detail technique and visual frustum screening technique, which is a mesh simplification technique used in terrain rendering. Photo trees allow the generation of high-quality terrain images in real time, but in the rendering pipeline of graphics hardware, only sequential data such as vertex arrays and textures can be processed, so hierarchical data structures such as photo trees cannot be used. none. Therefore, the methods using the photo tree are performed in the CPU, which causes a problem of deterioration or speed of the image. Therefore, there is a need to devise a technique for rendering a photo tree-based terrain model using only the GPU by making the photo tree necessary for the terrain rendering available in the rendering pipeline of the graphics hardware.

However, rendering a photo tree-based terrain model using only the GPU may cause a slowdown due to unnecessary computation and generation of too many vertices. Therefore, a method of accelerating a photo tree-based terrain rendering method using a GPU may be devised. There is also a need.

The present invention has been proposed to solve the above problems of the conventionally proposed methods, by performing visual frustum screening in the node search process, and also by using unused coordinate values among the coordinate values of the vertex as a buffer. An object of the present invention is to provide a method for accelerating a phototree-based terrain rendering method using a GPU.

According to an aspect of the present invention for achieving the above object, a method for accelerating a photo-tree-based terrain rendering method using a graphics processing unit (GPU),

(1) Search for nodes that will make up the terrain included in each block by selecting the detailed level (LOD), and in the Hierarchical View Frustum Culling (VFC) among the vertices of the searched nodes. Multiplying the vertices inside the field of view into the picture tree to generate a plurality of visible vertices;

(2) generating a triangular mesh from the generated plurality of visible vertices, generating a patch for crack removal through neighbor node inspection between the generated meshes, and converting the mesh into a patched block mesh; And

(3) applying the height value from the altitude field to the triangular mesh composed of the patched blocks, shading to a normal map and rendering the terrain image.

Advantageously, said rendering pipeline comprises a Geometry Shader stage (GS) and a Stream Output stage (SO),

The step (1) of generating a plurality of visible vertices,

(a) receiving a single vertex corresponding to a root node of the photo tree as an initial value of the rendering pipeline;

(b) In the geometric shading step (GS), whether the input single vertex satisfies the search condition according to the flag value (f) for determining whether to search for each node to a higher level. Making;

(c) if the single vertex does not satisfy the search condition as a result of the detailed step (LOD) selection, a vertex of child nodes is generated at a midpoint of four subblocks divided based on the single vertex, wherein the respective child nodes If the boundary (p) of is located outside of the visual frustum, the corresponding child node does not create a vertex, and if all four child nodes are outside of the visual frustum, the single as well as the vertices for the child nodes Performing a visual frustum screening (VFC) operation that also deletes the vertex itself;

(d) storing the result of step (c) in a one-dimensional buffer through a stream output step (SO); And

(e) providing the stored result to the rendering pipeline in order to generate the vertices specifying the level of each block in the place where each block is to be located, and the depth of the photo tree to be generated for each vertex of each child node (a) ) To may repeat the process of step (d).

More preferably, the flag value f may satisfy the following equation.

Here, v denotes a view point, p denotes a boundary sphere of a region, λ denotes a predetermined threshold value, ℓ denotes a level of a block, and e denotes a surface roughness value.

More preferably, the vertices have four coordinate values of (x, y, z, w), and among the four coordinate values, unused coordinate values are used as a buffer.

In selecting the detailed step of step (b) and performing visual frustum screening (VFC) of step (c) for each vertex,

Among the coordinate values of the vertices,

The radius value of the boundary (p) calculated using the position of the vertex is stored in the z coordinate value,

The w coordinate value may store a flag value f for determining whether to search for a higher level than the level of the vertex when the detail step is selected.

Even more preferably, the vertices have four coordinate values of (x, y, z, w), and among the four coordinate values, unused coordinate values are used as a buffer.

For the three vertices that make up the triangular mesh,

Among the (x, y, z, w) coordinate values of the vertices that share both hypotenuses of the triangle in the triangular mesh, the z coordinate value is the distance between the T-vertex (T) and the neighboring vertex (N), and the w coordinate value. Stores a flag value (f) that determines whether a patch is created in

The direction of the neighboring vertex N may be stored in the z coordinate value among the (x, y, z, w) coordinate values of one of two vertices adjacent to the hypotenuse.

According to the method for accelerating the photo-tree-based terrain rendering method using the GPU proposed in the present invention, by performing visual frustum screening during node search, performance is improved by preventing the slowdown caused by generating too many vertices. You can. In addition, by using unused coordinate values among the coordinate values of the vertex as a buffer, it is possible to accelerate the photo-tree-based terrain rendering method using the GPU.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a flowchart of a method of accelerating a photo-tree based terrain rendering method using a graphics processing unit (GPU) according to an embodiment of the present invention. As shown in FIG. 1, a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention includes a photo using a rendering pipeline of a graphics processing unit (GPU). In the tree-based terrain rendering method, the nodes that make up the terrain included in each block are selected through detailed level (LOD) selection, and hierarchical view frustum culling among the vertices of the discovered nodes. By multiplying the vertices inside the field of view by the VFC into the photo tree and generating a plurality of visible vertices (S100), a triangular mesh is generated from the generated plurality of visible vertices. Generating a patch for removing a crack through neighbor node inspection between the meshes and converting the mesh into a patched block mesh (S200), and consisting of the patched blocks Apply the height value from the altitude field of each message, and by shading the normal map and a step (S300) for rendering the topography image.

Since the present invention requires a preprocessing process for rendering the terrain image prior to the generation of the visible vertex in step S100, this will be described first. In the preprocessing process, a quadtree texture including a surface roughness value for adjusting a detail level (LOD) and a normal map for shading are generated. The photo tree is a hierarchical data structure in which each node has four child nodes, and the two-dimensional space is recursively divided into four quadrants to efficiently represent the space. The picture tree contains pointer information of parent node, child node, and neighbor node, level of partitioned block, height value, and surface for each node. Surface roughness information including a roughness value σ. The photo tree texture refers to a transformation of the photo tree into a two-dimensional texture for use in the rendering pipeline. The configuration of the photo tree texture is shown in FIG. 2.

2 is a diagram illustrating a photo tree texture generated in a method of accelerating a photo tree-based terrain rendering method using a GPU according to an embodiment of the present invention. The photo tree texture according to the embodiment of the present invention shown in FIG. 2 is generated in the preprocessing step and has the same resolution as the input height field. In this texture, as shown in FIG. 2, a root node is stored at the center, and child nodes are stored at the center of the square sub blocks divided into four around the node. This recursively repeats the tree's maximum level value (L _max ). In the present invention, a photo tree texture having a surface roughness value σ is generated. The calculation of the surface roughness value σ is described with reference to FIGS. 3 and 4.

FIG. 3 is a diagram illustrating vertex and geometric error values included in a block in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention, and FIG. It is a figure which shows the state given. As shown in FIG. 3, in the photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention, the surface roughness value σ is a vertex vn of an upper level and an edge of a lower level. It is calculated using the geometry error value δ, which is the height difference for the edge vn '. If the geometric error value δ is the same, the difference seems relatively larger in the smaller block than the larger block. Accordingly, in order to solve this problem, as shown in FIG. 4, a weight (w) is given according to the level of a block, and a weight value has a larger value as a higher level. The geometric error value δ given the weight w value can be obtained through Equation 1 below.

Here, vn represents the altitude value of the upper stage vertex for each block in the photo tree, vn 'represents the altitude value of the midpoint of the lower stage edge, and w represents the weight according to the level of the block. Where l is the level of the block and k is the level level of the photo tree.

Through this process, four geometric error values are calculated for each block. The surface roughness value to be stored in each node is the maximum geometric error value of the node itself and subordinate nodes. The reason for including the lower level values is that when the level of detail (LOD) is applied, the search may be stopped at a higher level even though the error value of the specific level is larger. Because. If the surface roughness value σ is displayed using the geometric error value obtained through Equation 1, it may be expressed as Equation 2 below.

Here, δ is a geometric error value representing an altitude difference between the vertex of the upper stage (vn) and the midpoint (vn ') of the lower stage of the photo tree, l is the level of the block, k is the level level of the photo tree. Indicates.

In the preprocessing step, in order to express the terrain in detail when the terrain is rendered, a photo tree texture including surface roughness values and a normal map representing the terrain to be rendered are generated.

In step S100, the nodes constituting the terrain included in each block are selected through detailed step (LOD) selection, and the hierarchical view frustum culling (VFC) among the vertices of the searched nodes is performed. By multiplying the vertices on the inside of the field of view into a photo tree, a plurality of visible vertices are generated. In the present invention, visual frustum screening is performed along with node search. In general, the photo tree is a hierarchical data structure that efficiently represents two-dimensional space, and is effective for continuous level of detail (CLOD) and visual frustum screening techniques, which are frequently used in terrain rendering. In this case, LOD is to use a more simplified representation when an object is small or does not contribute much to the rendered image. This technique is to improve rendering performance by reducing the number of polygons. The continuous detail step (CLOD) is one of the techniques for visualizing the terrain data, and dynamically adjusts the detail level of the model according to the position and distance of the viewpoint. In the case of terrain data represented as a height field, it is possible to dynamically generate a set of triangles at runtime, so that the detail level can be dynamically adjusted by dividing or combining the vertices of the terrain as the distance changes. . The representation of the terrain using the photo tree-based continuous detail level (CLOD) has the advantage of actively determining the detailed level of the terrain according to the distance between the terrain and the viewpoint and the viewing direction to obtain a real-time terrain image. Two criteria are applied to the CLOD method proposed in the present invention, the first of which is the distance from the observer and the second of which is the surface roughness. The method considering the expression roughness will be described with reference to FIGS. 5 and 6.

FIG. 5 is a view showing an image of a wireframe of a detailed step (LOD) having a viewpoint distance in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention, and FIG. A diagram showing an image in a continuous detail step (CLOD) to which a value is applied. As shown in FIG. 5, in the method for accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention, a view dependent LOD is a detail near and far from a viewer. Is a technique of expressing less detail, and obtains a flag value (f) for determining whether to search to a higher level by the following equation (3).

Where v is a view point, p is a boundary sphere of a region, λ is a predefined threshold, and l is the block's level.

The surface roughness method in the continuous detail step (CLOD) method uses the values stored in the photo tree texture generated in the preprocessing step. In this method, as shown in FIG. 6, when the surface roughness value of the block is small, the observer is shown in less detail even when the observer is close, and when the distance is far from the observer, the problem is shown in detail. Therefore, in the present invention, the method considering the surface roughness in the continuous detail step (CLOD) is represented by Equation 3 in order to express the details closer to the observer and less detailed parts such as the view dependent LOD. Transform as In Equation 4, a flag value (f) obtained by dividing a flag value (f) for determining whether to search to a higher level obtained by Equation 3 by the surface roughness value (e) obtained in the preprocessing step S100 is determined as a flag (f) value. .

Where v is the view point, p is the boundary sphere of a region, λ is the predefined threshold, ℓ is the block's level, and e is the surface roughness. Indicates a value.

In step S100, Hierarchical View Frustum Culling (VFC) is one of the screening techniques, which means that the screening techniques (Culling Techniques) means eliminating the parts of the entire scene that you want to render in computer graphics that do not appear to contribute to the final image. do. Of course, the rest that contributes to the final image of the scene is sent to the rendering pipeline. Among them, visual frustum screening (VFC) is an optimization method for determining visibility that can reduce the number of triangular meshes generated through the detail level selection process. Polygons outside the field of view area around the viewpoint ), And render only the geometric elements included in the visual frustum. Visual frustration screening speeds up rendering because it reduces unnecessary computation and reduces the number of polygons that need to be sent to the GPU, which means data.

In step S100, the nodes constituting the terrain included in each block are selected through detailed level (LOD) selection, and among the vertices of the searched nodes, the vertices inside the field of view are selected by visual frustum screening (VFC). Multiply to create a plurality of visible vertices. To this end, in the present invention, a method for searching for nodes to form terrain in parallel using a geometry shader stage (GS) and a stream output stage (SO) in a rendering pipeline of graphics hardware. Suggest. This method traverses nodes in a top-down fashion to effectively render the terrain. The geometric shading step GS may receive primitives constituting an image, such as a point, a line segment, or a triangle composed of vertices, to modify geometric information or to generate or delete vertices constituting one or more primitives. Due to the nature of the rendering pipeline, each primitive is processed in parallel during the geometric shading phase (GS). The subset containing the newly generated or modified vertex information through the geometric shading step GS is sequentially output to the 1D output buffer through the stream output step SO. Using the functions of the geometric shading stage (GS) and the stream output stage (SO) and the (x, y) coordinate values of each vertex, it is possible to solve the problem of recursion and pointers, which have been a problem in the existing photo tree. The process of generating a plurality of visible vertices by visual frustum screening (VFC) is performed by the flow as shown in FIG. 7.

7 is a flowchart illustrating a process of generating a plurality of visible vertices by visual frustum screening (VFC) in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention. As shown in FIG. 7, the rendering pipeline in the generation of a plurality of visible vertices by visual frustum screening (VFC) according to an embodiment of the present invention includes a geometric shading step (GS) and a stream output step (SO). Receiving a single vertex corresponding to the root node of the photo tree as an initial value of the rendering pipeline (S110) and whether the single vertex received in the geometric shading step (GS) is searched to a higher level for each node; In the step S120 of selecting whether the search condition is satisfied according to the flag value f to determine the step S120, and as a result of the selection of the detail step LOD, if the single vertex does not satisfy the search condition, Create the vertices of the child nodes at the midpoints of the four subblocks that are split.If the boundary (p) of each child node is outside the visual frustum, the child nodes do not generate vertices. When all of the child nodes are located outside the visual frustum, a step of performing a visual frustum screening (VFC) operation that deletes not only the vertices for the child nodes but also a single vertex itself (S130), and outputs the result of step S130 to the stream output step ( And storing the result in the one-dimensional buffer (S140), and generating the vertices in which each block is located at the location where each block is to be provided to the rendering pipeline for each vertex of each child node. And repeating the process of steps S110 to S140 by the depth of the picture tree to be generated (S150).

Step S110 is a process of receiving a single vertex corresponding to the root node of the photo tree as an initial value of the rendering pipeline. The rendering pipeline receives a single vertex corresponding to the root node of the photo tree as an initial value. This vertex is located at the center point of the block that the node implies, as in the phototree texture.

Step S120 is a step of determining whether the input single vertex satisfies the search condition according to the flag value f for determining whether to search for a higher level for each node of the geometric shading step GS. The vertex corresponding to the root node is searched according to the flag value (f) of the preceding Equations 3 and 4, i.e., the flag value (f) that determines whether to navigate to a higher level for each node in GS. Determine if the condition is met. If there is a higher level in the next step according to the search result in step S120, the search is continued, otherwise, the search is performed to the maximum level of the tree, and thus the first regression is performed.

In step S130, as a result of the LOD selection in step S120, if a single vertex does not satisfy the search condition, the vertex of the child nodes is generated at the midpoints of the four subblocks that are divided based on the single vertex. If the node's boundary (P) is located outside of the visual frustum, its child nodes do not create vertices. If all four child nodes are located outside of the visual frustum, then the vertices for the child nodes, as well as the vertices for the child nodes, Perform a Visual Frustum Screening (VFC) operation that also deletes the vertex itself. A method of performing visual frustum screening in the node search process of the present invention will be described with reference to FIG. 8.

8 is a view showing a visual frustum screening (VFC) method in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention. As described above, the visual frustum screening (VFC) shown in FIG. 8 is a method of not selecting and rendering vertices outside the field of view, and the boundary of each child node when searching for four child nodes when searching for nodes. If the sphere (P) is outside the visual frustum, the node does not create a vertex. If all four child nodes are outside the visual frustum, then no vertices are created and the self is deleted. Applying visual frustum screening in the process of searching for nodes can block operations on unnecessary visible vertices in advance.

In step S140, the result generated and deleted in step S130 is stored in a one-dimensional buffer through a stream output stage (SO).

In step S150, the process of steps S110 to S140 is provided by the depth of the photo tree to be generated for each child vertex by providing the stored result to the rendering pipeline in order to generate the vertices that specify the level of each block in the place where each block is to be located. Repeat this. The result stored in step S140 is fed back to the rendering pipeline and the same thing is repeated as much as the depth of the photo tree to be generated for each vertex. As a result, the vertices that designate the level of the block are generated in the place where each block which divided the terrain data is located. The GS feature is faster than traversing a tree on the CPU because a parallel algorithm is processed for each vertex.

Step S200 generates a triangular mesh from the generated plurality of visible vertices, generates a patch for crack removal through neighbor node inspection between the generated meshes, and converts the vertices into a patched block mesh. The plurality of visible vertices generated in operation S200 are converted into patched blocks after comparing block levels with neighbor nodes. In this process, a crack occurs due to the level difference between the nodes, which can be seen from FIG. 9.

FIG. 9 is a diagram illustrating a crack occurring due to a level difference between nodes during mesh generation in a method of accelerating a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention. Neighbor vertices should be examined to eliminate the occurrence of cracks as shown in FIG. Existing methods performed visibility propagation to eliminate cracks, which were only done on the CPU. Therefore, the present invention proposes a method for removing cracks in the GPU, which will be described with reference to FIGS. 10 to 14.

FIG. 10 is a flowchart illustrating a process of converting a block by generating a patch for removing a crack in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention, and FIG. It is a figure which shows the patch which generate | occur | produces each according to the presence or absence. 12 is a diagram illustrating a T-vertex found by a neighbor check, FIG. 13 is a diagram illustrating a process of generating a patch, and FIG. 14 is a diagram illustrating a state in which a crack is removed. As shown in FIG. 10, the process of transforming a block by generating a patch for crack removal according to an embodiment of the present invention includes the same level located on the top, bottom, left, and right sides of the block represented by the plurality of visible vertices generated in step S100. Computing the position of the four neighboring vertices having the block of (S210), for the neighboring vertices whose position is calculated by using a flag value (f) that satisfies the above equation (4), it is determined whether or not a crack occurs; Generating a patch according to the determination result and converting the visible vertices into the patched block mesh (S230); and feeding back the converted block mesh to the rendering pipeline through the SO (S250).

In step S210, the positions of four neighboring vertices having blocks of the same level located on the top, bottom, left, and right sides of the block represented by the plurality of visible vertices generated in step S100 are calculated. Each vertex may calculate the positions of four neighboring nodes having blocks of the same level located on the top, bottom, left, and right sides of the block as shown in FIG.

In step S230, it is determined whether a crack has occurred using the flag value f that satisfies the above Equation 4 with respect to the neighboring vertices whose positions are calculated, and generates a patch according to the determination result to generate a mesh composed of visible vertices. Convert to a patched block mesh. Operation S230 will be described with reference to FIG. 13.

As shown in FIG. 13, step S230 of generating a patch and converting the patch into a patched block mesh in the photo-tree-based terrain rendering method using the GPU according to an embodiment of the present invention is performed to neighboring vertices whose positions are calculated. As a result of performing neighbor node inspection by receiving the corresponding triangles, if a crack occurs, dividing the triangle into two pieces based on the location where the T-vertex is found (S232), and step S232 of the photo tree. Maximum level (L _max )-repeating 1 time to generate a patch (S234).

In step S232, as a result of performing the neighbor node inspection by receiving the triangles corresponding to the neighboring vertices whose positions are calculated, when the crack occurs, the triangle is divided into two pieces based on the position where the T-vertex is found. . Step S232 determines whether further searching is possible when the equation obtained in the detailed step LOD is applied to the positions of neighboring nodes calculated in step S210. If the whole is impossible to search, T-vertex does not occur because neighboring blocks are lower level than themselves. In this case, the vertices are converted into a block mesh of two triangles as shown in the lower part of FIG. If further search is possible, a crack may occur because a T-vertex is generated on one side of the lower level block as shown in FIG. 12. In FIG. 12, T is a T-peak and N is a neighbor. In this case, the block mesh is converted into a block mesh composed of four triangles as shown in the upper part of FIG. The transformed mesh is fed back to the rendering pipeline through the stream output step SO. In this case, a crack is generated as a result of neighboring inspection, so a patch must be generated in a block formed of four triangles.

Step S234 is a process of generating a patch by repeating step S232 at the maximum level (L _max )-1 time of the photo tree, wherein the generated patch uses neighboring nodes if no crack occurs as a result of the determination in step S230. It is a block mesh composed of two triangles generated, and when a crack occurs, it is a block mesh composed of four triangles created using neighboring nodes. 13 shows how to create a patch. In the geometric shading phase (GS), each triangle is input and the neighbor test is performed only once. Neighbors are computed as vertices perpendicular to AB by the length of AT or BT at the midpoint of AB in FIG. If this neighbor can be further explored, the triangle is split into two pieces based on the location where the T-vertex is found. Repeat this result L _max -1 time in the tree to create a patch for every crack that will occur. However, if only the distance from the observer is taken into account, the level of detail difference from the neighbor is not more than one. Therefore, if only the distance from the observer is taken into account, it is executed only once to reduce the amount of computation. FIG. 14 is a diagram illustrating a state in which a crack is removed in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

In operation S300, a height value is applied from a height field to a triangular mesh composed of patched blocks, and is shaded with a normal map to render a terrain image.

However, the method described above requires much computation for each vertex or triangle as compared to the CPU, which allows hierarchical data structures such as photo trees to be used. In the case of vertices, detailed step selection (LOD) and visual frustum screening (VFC) are performed, and in the case of triangles, neighbor node inspection is performed and patches are generated. Therefore, in the present invention, in order to reduce such operations, unused coordinate values among (x, y, z, w) values of vertices are used as a buffer to block operations on unnecessary visible vertices in advance.

Each vertex has four coordinate values of (x, y, z, w) in the detailed step selection performed for each vertex in step S120 and the visual frustum screening (VFC) operation in step S130. Among the coordinate values, the unused coordinate value (z, w) is used as a buffer.

Detailed step selection (LOD) and visual frustum screening (VFC) by vertex use the radius of the boundary sphere (P in Equation 3 or 4) most frequently during the calculation process. Calculate using location. In order to reduce this inefficient calculation, the radius value of the boundary P calculated by using the position of the vertex is stored in the z coordinate value among four coordinate values of one vertex. This method is efficient because the upper level radius needs to be 1/2 of the lower level. In addition, the w coordinate value stores a flag value f for determining whether to search for a level higher than the level of the current vertex when selecting the detail step. This eliminates the need to apply unnecessary detailed step selection (LOD) and visual frustum screening (VFC) discrimination formulas to nodes that have completed the detailed step selection (LOD).

In addition, the use of the unused coordinates as a buffer is applicable to the triangular mesh. When the neighbor node is inspected, the triangle is divided to generate a patch. In this case, the position of the neighbor node should be calculated as in step S210. In this case, T-vertexes are set to z coordinate values among (x, y, z, w) coordinate values of vertices C that share both hypotenuses of the triangles in the triangular mesh with respect to the three vertices constituting the triangular mesh in FIG. 12. Storing the distance between (T) and the neighboring vertex (N), and storing the direction of the neighboring vertex (N) in the z coordinate value of one of the two vertices (A, B) neighboring the hypotenuse. You can reduce the operation. After dividing the triangle, each vertex (C) can store 1/2 of the existing vertex (C) value.

The patch generation performed in step S120 is repeated through the stream output step SO. In this case, the conventional method had to check whether or not there were T vertices for every triangle. To reduce these unnecessary operations, you must distinguish between triangles that do not generate patches or triangles that cause cracks. Therefore, by storing a flag value for determining whether a patch is generated in the w coordinate value of the vertex C, which is one vertex of the triangle, the same effect can be obtained without performing a complicated repetitive process.

The present invention was performed in a system with 4GB main memory in the Intel Core2Duo E8400 CPU. The graphics hardware used nVidia 9800GTX (+) with 1GB of video memory, DirectX 10 library and Shader4.0 model. The size of the viewport is 1024768. Puget Sound (20492049) and Grand Canyon (20492049) data were used.

Table 1 below shows the change of the frame, the number of triangles, and the frequency of use of the CPU according to the threshold value when rendering the Puget Sound (20492049). These values change as the camera moves, so we checked the view from the same point of view.

Throshold FPS Triangle  CPU utilization 20000 236 24k 2% 30000 139 46k One% 40000 101 65k One% 50000 74 78k 0% 60000 60 102k 0% 70000 45 130k 0%

FIG. 15 is a diagram illustrating a screen shot of Threshold = 5000 showing 74 frames in a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention. Increasing the Threshold value increases the detail level spacing to render fine terrain, and decreasing the value narrows the detail level spacing to produce relatively less detailed terrain. Since the CPU generates the camera matrix and the view plane every frame, increasing the frame rate by reducing the operation performed by the GPU increases the frequency of CPU usage.

VS is only used for geometry morphing of the generated vertices, and PS is used only for shading using normal-maps. That is, VS and PS are used only in the last one of a total of four passes, so the utilization is low. On the other hand, GS is the most utilized since it is used in a total of three passes and there are many iterations through SO.

Table 2 and Table 3 compare the performance differences according to the LOD method. The threshold value in Table 3 is the number obtained by dividing the threshold value in Table 2 by the surface roughness ( e ) value. Since the average of the surface roughness values stored in the photo tree texture is 0.00231, the comparison was made with a value of approximately 400 times. When the surface roughness was applied, the number of triangles and the variation of FPS were more stable than the thresholds. Much less is how geometry popping applies surface roughness during rendering. However, since the process of accessing the photo tree texture has been added to take into account the surface roughness, the rendering speed is lower than the method considering only the distance to the observer when rendering the same triangle number.

Throshold Triangle FPS  CPU utilization 100 10k 327 3% 200 65k 143 One% 300 85k 76 0% 400 130k 55 0% 500 200k 34 0% 600 260k 24 0%

Throshold Triangle FPS  CPU utilization 40000 45k 102 One% 50000 56k 78 0% 60000 70k 65 0% 70000 85k 52 0% 80000 110k 46 0% 90000 125k 36 0%

16 is a view showing a resultant image according to the LOD method in the photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention. Where (a) is the (2049 x 2049) puget sound with only visually dependent LOD applied, and (b) is the (2049 x 2049) puget sound with surface roughness considered. The upper (a) image is the result when the threshold is small, and the lower (b) image is the result when the threshold is increased.

17 is a view showing visual frustum screening (VFC) results in a rendering pipeline in a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention. In FIG. 17, (a) shows the result from another point of view, and (b) shows the image from the original point of view.

Table 4 below shows the results of rendering the culled terrain through visual frustum screening (VFC). As a result of the application of visual frustum screening (VFC), the number of generated triangles was reduced and FPS was increased as compared with Table 1 above.

Throshold Triangle FPS  CPU utilization 40000 100k 39 0% 50000 135k 26 0% 60000 155k 20 0% 70000 180k 16 0% 80000 205k 13 0% 90000 230k 11 0%

In the present invention, a method of visualizing a photo tree-based terrain using only a rendering pipeline of graphics hardware is introduced. Through GS and SO of Shader Model 4.0, tree search can be performed in parallel and VFC can be performed to show that the overall rendering performance is improved compared to the existing photo tree-based rendering methods.

The present invention described above may be variously modified or applied by those skilled in the art, and the scope of the technical idea according to the present invention should be defined by the following claims.

1 is a flowchart of a method for accelerating a photo-tree based terrain rendering method using a graphics processing unit (GPU) according to an embodiment of the present invention.

2 is a view showing a photo tree texture generated in a method for accelerating a photo tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

3 is a view showing vertices and geometric error values included in a block in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

4 is a view showing a weighted value according to a block size in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

FIG. 5 is a view showing an image of a wireframe of a detailed step (LOD) having a viewpoint distance in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention. FIG.

FIG. 6 is a view showing an image in a continuous detail step (CLOD) to which surface roughness values of a method of accelerating a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention are applied. FIG.

7 is a flowchart illustrating a process of generating a plurality of visible vertices by visual frustum screening (VFC) in a method of accelerating a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention.

8 is a view showing a view frustum screening (VFC) method in a method for accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

9 is a view showing that a crack occurs due to a level difference between nodes during mesh generation in a method of accelerating a photo-tree based terrain rendering method using a GPU according to an embodiment of the present invention.

10 is a flowchart illustrating a process of converting a block by generating a patch for crack removal in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

FIG. 11 is a view illustrating patches generated according to whether cracks are generated in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention. FIG.

12 is a diagram illustrating a T-vertex found by a neighbor check in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

FIG. 13 illustrates a process of generating a patch in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention. FIG.

14 is a view showing a state in which a crack is removed in a method of accelerating a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

 FIG. 15 is a diagram illustrating a screen shot of Threshold = 5000 showing 74 frames in a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention. FIG.

16 is a view showing a resultant image according to the LOD method in the photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

FIG. 17 is a view showing visual frustum screening (VFC) results in a rendering pipeline in a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention. FIG.

<Explanation of symbols for main parts of the drawings>

S100: Searching for nodes by selecting the detailed level (LOD) and generating visible vertices by visual frustum screening (VFC)

S200: step of generating a patch for neighbor node inspection and crack removal

S300: applying height value and rendering to terrain image

Claims (5)

As a method for accelerating a phototree-based terrain rendering method using a graphics processing unit (GPU), (1) Search for nodes that will make up the terrain included in each block by selecting the detailed level (LOD), and in the Hierarchical View Frustum Culling (VFC) among the vertices of the searched nodes. Multiplying the vertices inside the field of view into the picture tree to generate a plurality of visible vertices; (2) generating a triangular mesh from the generated plurality of visible vertices, generating a patch for crack removal through neighbor node inspection between the generated meshes, and converting the mesh into a patched block mesh; And (3) applying a height value from an altitude field to the triangular mesh composed of the patched blocks, shading as a normal map and rendering the terrain image; Method for accelerating the photo-tree-based terrain rendering method using a GPU comprising a. The rendering pipeline of claim 1, wherein the rendering pipeline of the GPU comprises a geometry shader stage (GS) and a stream output stage (SO), The step (1) of generating a plurality of visible vertices, (a) receiving a single vertex corresponding to a root node of the photo tree as an initial value of the rendering pipeline; (b) In the geometric shading step (GS), whether the input single vertex satisfies the search condition according to the flag value (f) for determining whether to search for each node to a higher level. Making; (c) if the single vertex does not satisfy the search condition as a result of the detailed step (LOD) selection, a vertex of child nodes is generated at a midpoint of four subblocks divided based on the single vertex, wherein the respective child nodes If the boundary (p) of is located outside of the visual frustum, the corresponding child node does not create a vertex, and if all four child nodes are outside of the visual frustum, the single as well as the vertices for the child nodes Performing a visual frustum screening (VFC) operation that also deletes the vertex itself; (d) storing the result of step (c) in a one-dimensional buffer through a stream output step (SO); And (e) providing the stored result to the rendering pipeline in order to generate the vertices specifying the level of each block in the place where each block is to be located, and the depth of the photo tree to be generated for each vertex of each child node (a) And repeating the steps of (d) to). 3. The method of claim 2, wherein the flag value f satisfies the following equation. 4.

Here, v denotes a view point, p denotes a boundary sphere of a region, λ denotes a predetermined threshold value, ℓ denotes a level of a block, and e denotes a surface roughness value. The rendering pipeline of claim 1, wherein the rendering pipeline of the GPU comprises a geometry shader stage (GS) and a stream output stage (SO), Step (3), (f) calculating positions of four neighboring vertices having blocks of the same level located above, below, left and right of the block represented by the generated plurality of visible vertices; (g) Determining whether or not a crack has occurred by using a flag value f that satisfies the following equation for neighboring vertices whose position is calculated, and generating a patch according to the determination result to patch the visible vertices. Converting to a mesh; And and (h) feeding back the transformed block mesh back to the rendering pipeline via the SO.

Here, v denotes a view point, p denotes a boundary sphere of a region, λ denotes a predetermined threshold value, ℓ denotes a level of a block, and e denotes a surface roughness value. The method of claim 1, wherein the vertices have four coordinate values of (x, y, z, w), and among the four coordinate values, unused coordinate values are used as a buffer. For the three vertices that make up the triangular mesh, Among the (x, y, z, w) coordinate values of the vertices that share both hypotenuses of the triangle in the triangular mesh, the z coordinate value is the distance between the T-vertex (T) and the neighboring vertex (N), and the w coordinate value. Stores a flag value (f) that determines whether a patch is created in Photo-tree-based terrain using a GPU, which stores a direction of a neighboring vertex N in a z coordinate value among (x, y, z, w) coordinate values of one of two vertices neighboring the hypotenuse. How to accelerate the rendering method.

Images