KR100935886B1 - A method for terrain rendering based on a quadtree using graphics processing unit - Google Patents

Abstract

PURPOSE: A terrain rendering method based on a quadtree using a graphic processing unit is provided to render a geographical model based on a quadtree using only a graphic processing unit by using a quadtree for terrain rendering in the rendering pipeline of graphics hardware. CONSTITUTION: A normal map for a quadtree texture which includes a surface roughness value and shading is generated. Nodes composed of topography are searched. Visible vertices are generated(S100). A patch for removing a crack is generated(S200). Geographical image rendering is performed by performing shading on the normal map(S300).

Description

Photo-based terrain rendering method using graphics processing unit {A METHOD FOR TERRAIN RENDERING BASED ON A QUADTREE USING GRAPHICS PROCESSING UNIT}

The present invention relates to a terrain rendering method, and more particularly, to a phototree-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 that is widely used in terrain rendering. The photo tree enables the generation of high quality terrain images in real time, but since the rendering pipeline of the graphics hardware can process only sequential data such as vertex arrays and textures, 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.

The present invention has been proposed to solve the above problems of the conventionally proposed methods, by making the photo tree required for the terrain rendering available in the rendering pipeline of the graphics hardware, using a GPU only the photo tree-based terrain model Its purpose is to provide a way to render.

Photo-tree-based terrain rendering method using a GPU according to a feature of the present invention for achieving the above object,

(1) generating a quadtree texture including a surface roughness value for adjusting the LOD and a normal map for shading;

(2) Searching for nodes that will make up the terrain included in each block through LOD selection, multiplying vertices for each node into the photo tree, and creating a plurality of visible vertices Making;

(3) generating a triangular mesh from the generated plurality of visible vertices, generating a patch for crack removal by inspecting neighbor nodes between the generated meshes, and converting the mesh into a patched block mesh; And

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

Preferably, the photo tree texture includes a level, a height value, and a surface roughness value σ of each block constituting the photo tree.

The surface roughness value σ satisfies the following equation,

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. Respectively, the geometric error value δ may satisfy the following equation.

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

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

The step (2) 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) selecting a detailed step (LOD) to determine whether the single vertex received by the GS satisfies a search condition according to a flag value f for determining whether to search for each node to a higher level;

(c) As a result of the LOD selection, if the single vertex does not satisfy the search condition, a vertex of child nodes is generated at a midpoint of four subblocks divided based on the single vertex, and the single vertex itself is Deleting;

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

(e) providing the stored result back to the rendering pipeline in order to generate vertices specifying the level of each block in the place where each block is to be located, by the depth of the photo tree to be generated for each vertex of each child node. It may include repeating the process of (a) to (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.

Advantageously, said rendering pipeline 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 cracks have occurred by using a flag value f that satisfies the following equation for the neighboring vertices whose position is calculated, and generating a patch according to the determination result to patch the visible vertices. Converting to a block mesh; And

(h) feeding back the transformed block mesh to the rendering pipeline through 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.

More preferably, in the step (g), generating a patch and converting it to a patched block mesh,

(i) As a result of performing neighbor node inspection by receiving triangles corresponding to the neighboring vertices whose position is calculated, when the crack occurs, the triangle is divided into two pieces based on the position where the T-vertex is found. Splitting step; And

(j) repeating step (i) to generate a patch by repeating the maximum level (L _max ) _-one time of the photo tree,

The patch,

As a result of the determination in step (g), if a crack does not occur, the block mesh is composed of two triangles generated using the neighboring nodes, and if a crack occurs, the block is composed of four triangles generated using the neighboring nodes. It may consist of a mesh.

According to the photo-tree-based terrain rendering method using the GPU proposed in the present invention, by rendering the photo tree required for the terrain rendering in the rendering pipeline of the graphics hardware, rendering the photo tree-based terrain model using only the GPU can do.

Hereinafter, with reference to the accompanying drawings, it will be described in detail with respect to the embodiment according to the present invention.

1 is a flowchart of 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 photo tree-based terrain rendering method using a GPU according to an embodiment of the present invention includes a method for adjusting a detailed level (LOD) in a terrain rendering method in a rendering pipeline of graphics hardware. Generating a terrain included in each block by selecting a quadtree texture including surface roughness values and a normal map for shading (S100) and selecting a detailed level (LOD) Searching for nodes to be performed, multiplying vertices for each node into a photo tree, and generating a plurality of visible vertices (S200), generating a triangular mesh from the generated plurality of visible vertices, Generating a patch for crack removal by inspecting neighbor nodes between the generated meshes and converting the vertices into a patched block mesh (S300), and a triangular mesh composed of the patched blocks. Also apply the height value from the field, and a step (S400) that the shading to the normal map rendering the topography image. The GPU's rendering pipeline does not support the recursion and pointers needed to use hierarchical data structures. Accordingly, the present invention proposes a method of rendering a photo tree based terrain on a GPU in order to overcome the limitation of the photo tree.

Step S100 is a preprocessing step for rendering the terrain image, and generates a quadtree texture including a surface roughness value for shaping the detail and a normal map for shading. do. 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. Information including the 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 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 step S100, which is a 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 view showing vertices and geometric error values included in blocks in a photo-tree-based terrain rendering method using GPUs according to an embodiment of the present invention, and FIG. 4 is a view showing weights according to block sizes. The figure shown. 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 value, the difference is relatively larger in the smaller block than the large 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 an altitude value of the upper stage vertex for each block in the photo tree, vn 'represents an altitude value of the midpoint of the lower stage edge, and w represents a 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.

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

Step S200 searches for nodes constituting the terrain included in each block through LOD selection, multiplies vertices for each node into a photo tree, and selects a plurality of visible vertices. Create 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 means using a more simplified representation when an object is small or does not contribute much to the rendered image. Long-distance models are less visually significant, even if they are less precise, and this is a technique that improves rendering performance by reducing the number of polygons that go into the graphics pipeline. Among them, the continuous detail level (CLOD) is one of 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. . Representation of terrain using the Phototree-based Continuous Detail Level (CLOD) has the advantage that the real-time terrain image can be obtained by actively determining the detail level of the terrain according to the distance between the terrain and the viewpoint and the viewing direction. 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.

5 is a view showing an image of a wireframe of the detailed step (LOD) having a viewpoint distance in the photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention, Figure 6 is a continuous surface roughness value applied It is a figure which shows the image in the detailed step CLOD. As shown in FIG. 5, in the photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention, a view dependent LOD may be expressed in detail near and far in detail from a viewer. As a technique of doing this, a flag value (f) for determining whether to search for a higher level is obtained 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 method considering surface roughness in the continuous detail step (CLOD) method uses a value stored in the photo tree texture generated in step S100, which is a preprocessing step. In this method, when the surface roughness value of the block is small, as shown in FIG. 6, the viewer shows less detail even if the observer is close, and when the distance is far from the observer, the problem occurs in detail. Therefore, in the present invention, the method considering the surface roughness in the continuous detail step (CLOD), as shown in the view dependent LOD, the part closer to the observer in detail, the far part less in detail to the following equation (3) It is modified as in Equation 4. 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 used 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 S200, the nodes included in each block are searched through the LOD inspection, the vertices of the nodes are propagated into the photo tree, and a plurality of visible vertices are generated. 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. GS can receive primitives that make up an image, such as points, line segments, or triangles, which can be used to modify geometry or create or delete vertices that make up one or more primitives. Due to the nature of the rendering pipeline, each primitive in GS is processed in parallel. The subset containing the newly created or modified vertex information through the GS is sequentially output to the 1D output buffer through the SO. Using these GS and SO functions and the (x, y) coordinates of each vertex, we can solve the problem of recursion and pointers, which was a problem in the existing photo tree. The process of generating a plurality of visible vertices is performed by the flow as shown in FIG. 7.

7 is a flowchart illustrating a method of generating visible vertices in a photo tree-based terrain rendering method using a GPU according to an embodiment of the present invention. As shown in FIG. 7, in operation S200 of generating a plurality of visible vertices according to an embodiment of the present invention, a single vertex corresponding to a root node of a photo tree is input as an initial value of a rendering pipeline. (S210), step S220 of selecting whether a single vertex received from GS satisfies a search condition according to a flag value f for determining whether to search for each node to a higher level (S220), As a result of the LOD selection, when a single vertex does not satisfy the search condition, a vertex of child nodes is generated at a midpoint of four subblocks divided based on a single vertex, and the single vertex is deleted itself (S230). Storing the result generated and deleted in the step S230 in the one-dimensional buffer through the SO (S240); Providing a ring pipeline includes the step (S250) to repeat the deep processing of step S210 to step S240 as long as the photo-tree needs to be generated for each vertex of each of the child nodes.

Step S210 is a step 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.

In step S220, a detailed step (LOD) is selected to determine whether a single vertex inputted from GS satisfies a search condition according to a flag value f for determining whether to search for each node to a higher level. 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 S220, the search continues. Otherwise, the search is performed to the maximum level of the tree, and thus the first regression is performed.

In step S230, as a result of the LOD selection in step S220, if the single vertex does not satisfy the search condition, the vertex of the child nodes is generated at the midpoints of the four subblocks divided based on the single vertex, and the single vertex itself is generated. Delete it. At this time, the node that does not satisfy the search condition returns itself.

In step S240, the result generated and deleted in step S230 is stored in the one-dimensional buffer through the SO.

Step S250 provides the stored results back 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, so that the depth of the picture tree that should be generated for each vertex of each child node is the step S210 to the step. Repeat the process of S240. The result stored in step S240 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.

In operation S300, a triangular mesh is generated from the plurality of visible vertices generated in operation S200, and a patch for crack removal is generated by checking neighboring nodes between the generated meshes, and the generated mesh is converted 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. 8.

FIG. 8 is a diagram illustrating a crack occurring due to a level difference between nodes during mesh generation in a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention. Neighbor vertices should be inspected 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. 9 to 12.

9 is a flowchart illustrating a process of converting a block by generating a patch for removing a crack in a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention, and FIG. 10 is a view illustrating whether cracks are generated. It is a figure which shows the patch which is created. FIG. 11 is a diagram illustrating a T-vertex found by a neighbor check, and FIG. 12 is a flowchart and a diagram illustrating a process of generating a patch. As shown in FIG. 9, 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 S200. Computing the positions of the four neighboring vertices having the block of (S310), using the flag value (f) that satisfies the equation d for the neighboring vertices whose position is calculated, it is determined whether the crack has occurred, the determination result Generating a patch to convert the visible vertices into the patched block mesh (S330), and feeding back the transformed block mesh to the rendering pipeline through the SO (S350).

In operation S310, 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 S200 are calculated. Each vertex may calculate 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 S330, it is determined whether a crack has occurred using the flag value f that satisfies Equation 4 with respect to the neighboring vertices whose position is 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 S330 will be described with reference to FIG. 12.

As shown in FIG. 12, in operation S330 of generating a patch and converting the patch into a patched block mesh in the photo-tree-based terrain rendering method using the GPU, the position is calculated in neighboring vertices. As a result of performing neighbor node inspection by receiving the corresponding triangles, if a crack occurs, the triangle is divided into two pieces based on the location where the T-vertex is found (S332), and step S332 is performed in the photo tree. Maximum level (L _max ) of-repeats 1 time to generate a patch (S334).

In step S332, when the triangles corresponding to the computed neighboring vertices are input and neighbor node inspection is performed, when the crack occurs, the triangle is divided into two pieces based on the location where the T-vertex is found. . Step S332 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 S310. 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 the T-vertex is generated on one side of the lower level block as shown in FIG. 11. In FIG. 11, T is a T-peak and N is a neighbor. In this case, as shown in the upper part of FIG. The transformed mesh is fed back to the rendering pipeline through the SO. In this case, a crack is generated as a result of neighbor inspection, so a patch must be generated in a block formed of four triangles.

Step S334 is a process of generating a patch by repeating step S332 at the maximum level L _max of the photo tree-one time, wherein the generated patch uses neighboring nodes if no crack occurs as a result of the determination in step S330. It is a block mesh composed of two triangles, and when a crack occurs, it is a block mesh composed of four triangles created using neighboring nodes. 12 shows how to create a patch. In 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 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. 13 is a diagram illustrating a state in which a crack is removed in a photo tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

In operation S400, a height value stored in a height field is applied to a mesh composed of blocks fetched in operation S300, and shaded with a normal map to render a terrain image.

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

Table 1 below shows the change in the frame, the number of triangles, and the frequency of use of the CPU according to a threshold 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. 14 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 ). 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 geometry popping applied 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%

FIG. 15 is a diagram illustrating a resultant image according to an LOD method in a 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. According to the method of visualizing a photo tree-based terrain using only the rendering pipeline of graphics hardware according to the present invention, the tree can be rendered parallel using GS and SO of Shader Model 4.0 to render a photo tree-based terrain model using only a GPU. Could confirm.

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 photo-tree based terrain rendering method using a graphics processing unit (GPU) according to an embodiment of the present invention.

2 is a diagram illustrating a photo tree texture generated in 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 blocks in a photo-tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

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

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

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

7 is a flowchart illustrating a method of generating visible vertices in a photo tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

8 is a view showing that a crack occurs due to a level difference between nodes when generating a mesh in a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention.

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

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

FIG. 11 is a diagram illustrating a T-vertex searched by a neighbor check in a phototree-based terrain rendering method using a GPU according to an embodiment of the present invention.

12 is a flowchart and a diagram illustrating a process of generating a patch in a photo tree-based terrain rendering method using a GPU according to an embodiment of the present invention.

FIG. 13 is a view illustrating a state in which cracks are removed in a photo tree-based terrain rendering method using a GPU according to an embodiment of the present invention. FIG.

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

15 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.

<Explanation of symbols for main parts of the drawings>

S100: step of generating a normal map for quadtree texture and shading

S200: generating a plurality of visible vertices

S300: transforming a block composed of visible vertices

S400: applying a height value to the constructed mesh and rendering the terrain image

Claims (5)

A phototree based terrain rendering method using a graphics processing unit (GPU), (1) generating a quadtree texture including a surface roughness value for adjusting the LOD and a normal map for shading; (2) Searching for nodes that will make up the terrain included in each block through LOD selection, multiplying vertices for each node into the photo tree, and creating a plurality of visible vertices Making; (3) generating a triangular mesh from the generated plurality of visible vertices, generating a patch for crack removal by inspecting neighbor nodes between the generated meshes, and converting the generated mesh into a patched block mesh ; And (4) 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; Photo-tree-based terrain rendering method using a GPU comprising a. The photographic tree texture of claim 1, wherein the phototree texture comprises a level, a height value, and a surface roughness value σ of each node constituting the phototree. The surface roughness value (σ) satisfies the following equation, wherein the terrain rendering method based on a photo tree using a GPU.

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. Respectively, the geometric error value δ satisfies the following equation.

Here, vn represents the height value of the upper stage vertex for each block in the photo tree, vn 'represents the height value of the midpoint of the edge of the lower stage, w represents the weight according to the level of the block. Where l represents the level of the block and k represents the level of the photo tree. The method of claim 1, wherein the rendering pipeline comprises a geometry shader stage (GS) and a stream output stage (SO), The step (2) 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) selecting a detailed step (LOD) to determine whether the single vertex received by the GS satisfies a search condition according to a flag value f for determining whether to search for each node to a higher level; (c) As a result of the LOD selection, if the single vertex does not satisfy the search condition, a vertex of child nodes is generated at a midpoint of four subblocks divided based on the single vertex, and the single vertex itself is Deleting; (d) storing the result of step (c) in a one-dimensional buffer through a stream output stage (SO); And (e) providing the stored result back to the rendering pipeline in order to generate vertices specifying the level of each block in the place where each block is to be located, by the depth of the photo tree to be generated for each vertex of each child node. Photo-based terrain rendering method using a GPU comprising the steps of (a) to (d) to repeat the process. The method of claim 1, wherein the rendering pipeline includes 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 through 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 4, wherein the generating of the patch in step (g) and converting the patch into a patched block mesh comprises: (i) As a result of performing neighbor node inspection by receiving triangles corresponding to the neighboring vertices whose position is calculated, when the crack occurs, the triangle is divided into two pieces based on the position where the T-vertex is found. Splitting step; And (j) repeating step (i) to generate a patch by repeating the maximum level (L _max ) _-one time of the photo tree, The patch, As a result of the determination in step (g), if a crack does not occur, the block mesh is composed of two triangles generated using the neighboring nodes, and if a crack occurs, the block is composed of four triangles generated using the neighboring nodes. Photo-tree-based terrain rendering method using GPU, characterized in that the mesh.

Images