KR20160068204A - Data processing method for mesh geometry and computer readable storage medium of recording the same - Google Patents

Abstract

According to an embodiment of the present invention, a data processing method for a mesh geometry comprises: a first step of generating first and second render target textures and first and second vertex lists; a second step of rendering original mesh geometry; a third step of setting the first render target texture as the current render target, and setting the second render target texture as the current render target to be sampled; a fourth step of performing rendering using the first vertex, a first pixel shader, and the first vertex list, a fifth step of restoring a default render target, and setting the first render target texture as the current texture; and a sixth step of performing rendering using the second vertex, a second pixel shader, and the second vertex list. Thus, information on the selection and selection cancellation of a triangle or a polygon for a mesh geometry can be provided in real time.

Description

Technical Field [0001] The present invention relates to a data processing method for a mesh geometry and a computer readable storage medium storing the same. More particularly,

The present application relates to a data processing method for a mesh geometry and a computer-readable storage medium storing the method.

Stereo Lithography (STL) files consist of a set of triangles to represent a mesh (e.g., a two-dimensional or a three-dimensional object), for example multimedia and graphics applications such as CAM Dimensional or three-dimensional modeling. Some applications use lines to represent CAM data, in which case these lines may also be tessellated (triangulated) into sets of triangles using some tessellation algorithms.

The set of triangles in the mesh can be used to represent sub-objects or parts of the mesh, and each of these sets of triangles in the mesh can be named polygons. Grouping triangles into polygons is done by the geometry designer, creating a mesh geometry by considering a set of connected triangles as polygons, or by using some other customized algorithm that considers the set of unconnected triangles as polygons. .

The user needs to select (highlight) a plurality of two- or three-dimensional triangles or polygons by defining a two-dimensional rectangle aligned along the XY axis using a mouse drag while viewing the mesh geometry of the triangular shape. In addition, the information of the selected triangle or polygon is preferably provided to the user as soon as possible so that the user can easily interact with the mesh geometry. Furthermore, if the user simply clicks at a particular point with the mouse, the point needs to be considered a two-dimensional rectangle for performing triangular or polygonal selection.

For example, in the following cases, it is necessary to give a highlight to the selected polygon or triangle and provide information about the selection.

1) Verifying the accuracy of triangulation of mesh geometry in detail.

2) Delete selected triangles or polygons from existing geometry.

3) Save the selected triangle or polygon as a separate mesh file.

4) Redesign the existing mesh shape using the selected triangle or polygon.

In this connection, Patent Document 1 described in the following prior art documents discloses a rendering data processing apparatus and method.

Patent Publication No. 2014-0005388 (published on January 15, 2014).

There is a need in the art for providing information in real time about selection and deselection of triangles or polygons for mesh geometry.

In order to solve the above problems, an embodiment of the present invention provides a data processing method for a mesh geometry.

A method of processing data for a mesh geometry according to an embodiment of the present invention includes a first step of generating first and second render target textures and first and second vertex lists, A third step of setting a first render target texture as a current render target and a second render target texture as a current texture to be sampled, a third step of setting a first render target texture as a current render target and a first vertex and a first pixel shader, and a first vertex list, and restoring a default render target, and then setting a first render target texture as a current texture; a fifth step of restoring a second render target texture to a second vertex and a second vertex list; And a sixth step of rendering using a second vertex and second pixel shader and a second vertex list.

Here, the first and second render target textures are n x n pixel blocks for indicating whether a polygon is selected by dragging a mouse, and n may be an odd number.

Also, the vertices of the first vertex list are generated for each of a plurality of triangles present in the mesh geometry, and the vertices may include three vertex positions and two-dimensional screen positions forming a triangle in the three-dimensional model coordinates.

Also, a vertex of the second vertex list is generated for each of a plurality of triangles existing in the mesh geometry, and the vertex may include one vertex position and a two-dimensional texture coordinate in the three-dimensional model coordinate.

The method of processing data for a mesh geometry according to an embodiment of the present invention may further include clearing each pixel of the first and second render target textures to a predetermined value after the first step , And the second to sixth steps may be repeatedly performed when the mouse drag is in progress.

The fourth step further includes passing the first vertex list to the first vertex shader for re-rendering, performing a triangle-rectangle intersection test in the two-dimensional space, and performing a triangle- Outputting a two-dimensional screen position representing a polygon to which the vertex belongs; and generating a solid color for each pixel constituting the rectangle in the first pixel shader, wherein the first vertex shader and the second vertex shader The one pixel shader may be a polygon selected vertex shader and a polygon selected pixel shader, respectively.

The sixth step further includes transmitting and re-rendering the second vertex list to the second vertex shader, and in the second pixel shader, using the two-dimensional texture coordinates output by the second vertex shader, And sampling the texture.

According to another aspect of the present invention, there is provided a method of processing data for a mesh geometry, the method comprising: copying a content of a first render target texture to a second render target texture upon completion of a mouse drag; And providing information on polygon selection or deselection based on the contents.

In addition, the means for solving the above-mentioned problems are not all enumerating the features of the present invention. The various features of the present invention and the advantages and effects thereof will be more fully understood by reference to the following specific embodiments.

According to one embodiment of the present invention, the selection or deselection of a triangle or polygon during a mouse drag allows the user to easily interact with the mesh geometry, thereby obtaining a list of selected triangles or polygons after the mouse drag is over Thereby saving the user time and effort to make a decision to modify or store the mesh geometry.

1 is a diagram illustrating an example of a render target texture including a 3 x 3 pixel block having polygonal selection results in accordance with an embodiment of the present invention.
2 is a diagram showing an example of points in a rectangular test according to an embodiment of the present invention.
FIG. 3 is a diagram illustrating an example of performing a triangle-rectangular edge intersection test according to an embodiment of the present invention.
4 is a diagram illustrating an example of intersection of lines in accordance with one embodiment of the present invention.
5 is a diagram illustrating an example of points in a triangle test according to an embodiment of the present invention.
6 is a diagram showing the center of mass coordinates for testing a point in a triangle according to an embodiment of the present invention.
7 is a flowchart of a data processing method according to an embodiment of the present invention.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings, in order that those skilled in the art can easily carry out the present invention. In the following detailed description of the preferred embodiments of the present invention, a detailed description of known functions and configurations incorporated herein will be omitted when it may make the subject matter of the present invention rather unclear. In the drawings, like reference numerals are used throughout the drawings.

In addition, in the entire specification, when a part is referred to as being 'connected' to another part, it may be referred to as 'indirectly connected' not only with 'directly connected' . Also, to "include" an element means that it may include other elements, rather than excluding other elements, unless specifically stated otherwise.

Some existing applications allow the user to draw a two-dimensional rectangle with the mouse, and then use the CPU to perform tests for successively triangular-square intersections. However, these applications do not perform in real time, even if hyper-threading through a multicore CPU is used as the number of triangles in mesh geometry increases.

Some existing applications use ray tracing with CPUs, but these applications only allow triangles to be selected by projecting light from the current mouse position onto the screen, or only rectangles intersecting this light can be selected , But can not select a triangle or polygon located within a two-dimensional rectangle indicating selection by the user.

In one embodiment of the invention described below, programmable vertex and pixel shaders are used on a graphics processing unit (GPU) to select and deselect two-dimensional or three-dimensional triangles or polygons for mesh geometry in real- Will be described.

GPUs can use the concept of SIMD (Single Instruction Multiple Data) processing to process multiple data in parallel processing, for example, a single instruction. According to one embodiment of the present invention, when processing many triangles in parallel using a programmable vertex and pixel shader using a GPU, the highlighting of the two-dimensional or three-dimensional triangle or polygon selection and selected triangles allows the user to drag the mouse And the information on the selected triangle or polygon can be displayed to the user when the mouse drag is completed.

Example  One : GPU  Two-dimensional or three-dimensional polygon selection algorithm

Step 1 - Count the number of polygons in the mesh geometry. In the GPU memory, a render target texture (hereinafter, referred to as 'RT0') is created, namely a color buffer having 16 bits of floating point format format with a value of 1.0 or 0.0 per pixel in the R channel. The size of this render target can be determined by taking into account the maximum possible render target size supported by the GPU on which rendering is to be performed. For example, the render target may be an nxn pixel block that must be retained to indicate whether a polygon is selected. Where n is an odd number and may be one.

Thus, the render target width must have a minimum height, n, to hold n x n pixel blocks, depending on the number of polygons, and should be a multiple of n. If the number of polygons does not fit within the first column of the n x n pixel block, then more columns can be added to hold n x n pixel blocks.

For example, as shown in Fig. 1, if there are eight polygons, the maximum possible render target size is 10 x 10 pixels, n = 3, and the first and second columns of the 3 x 3 pixel block are the first 6 The last column of the 3 x 3 pixel block may have the result of the selection for the last two polygons. Thus, the render target size can be 9 x 9. Render targets can have 1 mipmap level. The render target texture can be cleared by filling each pixel of this render target texture with a value of zero.

The following C ++ pseudo code illustrates the process of calculating the render target width and height (renderTargetWidth and renderTargetHeight).

unsigned int colCount = std :: min (polygonsCount, maxRenderTargetWidth / n);

unsigned int rowCount = static_cast <unsigned int> (std :: ceil (

static_cast <float> (polygonsCount) / colCount));

unsigned int renderTargetWidth = colCount * n;

unsigned int renderTargetHeight = rowCount * n;

The definition of the variable used in the above pseudo code is as follows.

polygonsCount: number of polygons in mesh geometry

maxRenderTargetWidth: Maximum render target width supported by the GPU

maxRenderTargetHeight: Maximum render target height supported by the GPU

n: the above-described pixel block size

colCount: the number of rows in the render target

rowCount: number of columns in the render target

If the render target height calculated in the above pseudo code exceeds maxRenderTargetHeight, the number of polygons exceeds the render target size, in which case the selection algorithm according to an embodiment of the present invention can not be applied. However, this possibility is extremely low because most GPUs available on the market support a maximum render target size of at least 8192 x 8192.

Step 2 - Create a vertex list (hereinafter referred to as 'V0') on the CPU. Here, the vertex can be generated one for each triangle present in the mesh geometry. The data for each vertex can be composed of three vertex positions forming a triangle in the three-dimensional model coordinates and a two-dimensional position in the screen coordinates being the output vertex position. Each vertex may represent a point sprite of size n described in step 1 above.

The two-dimensional screen position of the vertex may correspond to the center of the center pixel within the nxn pixel block held in the render target RT0 to uniquely represent each polygon. In other words, each triangle must have information about the polygon to which it belongs (for example, a zero-based polygon index), and this information can be used to calculate the two-dimensional output screen position.

Thus, to represent the first polygon, the center pixel of the first nxn block in the first column of the nxn pixel block of the render target texture may be used. That is, in the above example where the render target size is 9 x 9 and n is 3, the center pixel may be represented by a zero-based pixel position (1, 1), i.e. the second row of the second column in the texture. This pixel position can be converted to screen space coordinates between -1.0 and 1.0. Thus, each triangle belonging to a polygon may have a common two-dimensional screen location held for the polygon on the render target.

The following C ++ pseudocode illustrates the process of creating a two-dimensional screen location for each polygon after the width and height for the render target texture RTO have been determined.

unsigned int renderTargetWidth = decided based on Step (1) ;

unsigned int renderTargetHeight = decided based on Step (1) ;

// half pixel offset must be used for texture coordinates in order to sample

// exact center of pixel

float texelOffsetU = 0.5f / renderTargetWidth;

float texelOffsetV = 0.5f / renderTargetHeight;

unsigned int pointSpriteSize = 1;

unsigned int pointSpriteSizeHalf = pointSpriteSize / 2;

unsigned int colCount = renderTargetWidth / pointSpriteSize;

unsigned int rowIndex = polygonIndex / colCount;

unsigned int colIndex = polygonIndex% colCount;

// calculation for texture coordinates

float texCoordU = (static_cast <float> ((colIndex * pointSpriteSize)

+ pointSpriteSizeHalf) / renderTargetWidth) + texelOffsetU;

float texCoordV = (static_cast <float> ( (rowIndex * pointSpriteSize)

+ pointSpriteSizeHalf) / renderTargetHeight) + texelOffsetV;

// calculation for XY screen position

float posX = (texCoordU * 2.0f) - 1.0f;

float posY = - ((texCoordV * 2.0f) - 1.0f);

Step 3 - Create another vertex list (hereinafter referred to as 'V1') on the CPU. Here, vertices are generated for each triangle in the mesh geometry. The data for each vertex may consist of one vertex position and two-dimensional texture coordinates within the three-dimensional model coordinates. This two-dimensional screen position can be converted to a texture coordinate between 0.0 and 1.0, such as a list of vertices V0 for point sprites contained in a two-dimensional screen position between -1.0 and 1.0 to represent the polygon to which the triangle belongs (See the variables texCoordU and texCoordV in the pseudocode described in step 2 above). In addition, the two-dimensional screen position can be used as the two-dimensional texture coordinates of the vertex to sample the render target texture including nxn pixel blocks representing the selected polygon.

Step 4 - Render mesh geometry with user specified transformations (eg, scaling, rotating, moving) using original vertex data. Any solid color or texture can be used while rendering the mesh geometry. Now, as described below, you can prepare to render the same geometry again.

Step 5 - Set the render target texture RTO mentioned in step 1 as the current render target to be rendered.

Step 6 - The mesh geometry is re-rendered by passing the vertex V0 described in step 2 above to a vertex shader (hereinafter referred to as a polygon selected vertex shader) in the form of a point list. Here, the vertex shader can be executed once for each vertex of each triangle.

In a vertex shader, three vertex positions that make up a triangle can be transformed using real-world objects, views, and projection matrices to obtain three 4-dimensional output positions. The XY coordinates of these three output vertex locations can be divided by the absolute value of the corresponding W coordinate to obtain the three vertex positions of the triangle in the two-dimensional screen space (i.e., -1.0 to 1.0).

Step 7 - Make sure that the triangle is not culled, that is, it is removed during rendering by checking the vertices of the triangle clockwise or counterclockwise. This can prevent, for example, triangles that do not face the user, such as triangles included in the back of a three-dimensional object such as a sphere, to pass through a triangle-rectangle intersection test. Then, a triangle-rectangle intersection test is performed in the two-dimensional space.

When triangles and rectangles exist in a two-dimensional space, if any of the three intersection tests described below are successful, they intersect.

i) If any one of the three vertices of a triangle (hereinafter referred to as 'T') is within a bounding box of a rectangle (hereinafter referred to as 'R') as shown in FIG.

(T.vertex.x > = R.left) and

(T.vertex.x <= R.right) and

(T.vertex.y > = R.top) and

(T.vertex.y <= R.bottom)

ii) As shown in Fig. 3 and Fig. 4, if the intersection of one of the three edges of the triangle and one of the four edges of the rectangle is on two lines, i.e., ua and ub calculated according to the following If it is between 0 and 1, this test is performed.

For example, each line shown in FIG. 4 can be expressed by the following equation (1).

Here, in order to obtain a point of Pa = Pb, the following expression (2) can be solved.

Solving equation (2) yields the following results.

iii) Any one of the four vertices of the rectangle exists in the triangle. This test can be performed using a barycentric coordinate, as shown in Figs. 5 and 6. Fig.

For example, in the case shown in FIG. 6, the following C ++ pseudo code for performing the test is as follows.

Step 8- Generate an output 4-dimensional position, where the Z component has a value of zero and the W component can have a value of one.

If the triangle-rectangle intersection test is successful in step 7 above, the 2D screen position representing the polygon to which the vertex belongs is used as the output XY position, otherwise, to represent the point outside screen (-2.0 , 2.0) to prevent output from being generated by the pixel shader. During generation of the output vertex position, the point sprite may be deactivated and the point sprite size may be set to n such that each point is represented by a rectangle of n x n pixels.

A single pixel, i.e., a 1 x 1 pixel block, can be used to represent a polygon, and even after performing the algorithm described above, if the polygon selection is incorrect due to hardware limitations such as GPU driver execution, To prevent loss of accuracy, n = 3 may be used.

Step 9 - For the point sprite in the corresponding pixel shader (hereafter referred to as the polygon selected pixel shader), for each pixel that constitutes the rectangular shape of the point sprite, have RGBA values (1.0, 0.0, 0.0, 1.0) Create a solid color.

Step 10 - Whenever a triangle belonging to a polygon passes a triangle-rectangle intersection test, the render target texture RT0 is filled with solid color within the nxn pixel block. Restores the render target to the default render target and sets RT0 to the current texture (including the nxn block of solid color representing the point sprite) to be sampled in the pixel shader using point filtering with deactivated texture mipmap .

The mesh geometry is re-rendered in the form of a triangle list by passing the vertex V1 described in steps 11 and 3 to a vertex shader (hereinafter referred to as a polygon highlight vertex shader) in the form of a triangle list. Here, the vertex shader can be executed once for each vertex of each triangle. In a vertex shader, a vertex position is transformed using a real-world object, view, and projection matrix to obtain a four-dimensional output location. Use input 2D texture coordinates as output 2D texture coordinates.

Step 12 - In the corresponding pixel shader (hereinafter referred to as a 'polygon highlight pixel shader'), the center of the center pixel in the nxn pixel block is sampled in the render target texture RT0 using the 2D texture coordinates output by the vertex shader (In this case, point filtering with deactivated mipmap is used) and the value of the R channel of the obtained color is used as the alpha value of the color output by the pixel shader. The output RGB color value can be used to represent the selected (highlighted) polygon.

Step 13-Repeat the above-described steps 4 to 12 so that the user can perform polygon selection and highlighting while performing mouse dragging. To release a previously selected polygon, a user action (e. G., Double click) may be used to zero the value for each pixel of the render target RTO.

Example  2 : GPU  Two-dimensional or three-dimensional triangular selection algorithm

Considering each triangle as a separate polygon, the polygon selection algorithm of the first embodiment described above can also be used for triangle selection.

Example  3: GPU  Two-dimensional or three-dimensional triangle or polygon deselection algorithm

While selecting a triangle or polygon using a two-dimensional rectangle while performing a mouse drag, the user may desire to deselect a particular selected triangle or polygon. To do this, the user can simply drag the mouse over the selected triangle or polygon to draw a two-dimensional rectangle, or simply click on the selected shape to deselect the previously selected shape. For this operation, the algorithm described in the first embodiment can be modified as follows.

Step A - In GPU memory, another render target texture, similar to the render target texture RT0 described in step 1 of embodiment 1 above, is used to represent the triangle or polygon selection performed by the user before the start of a new mouse session (Hereinafter referred to as &quot; RT1 &quot;).

Step B - During execution of step 5 of the first embodiment described above, RT1 is set to the current texture to be sampled in the pixel shader using point filtering with a disabled texture mipmap.

Step C - While generating the output position for the vertex described in step 8 of the first embodiment described above, the output vertex position of the screen space (-1.0 to 1.0) is converted into the texture space (0.0 to 1.0) Pass texture coordinates to the pixel shader.

Step D - In the pixel shader described in the ninth step of the first embodiment, the texture coordinates output by the vertex shader described in step 3 are used as the input texture coordinates, and the texture RT1 is sampled using the texture coordinates . If the R component of the sampled color is 1.0, this means that the corresponding triangle or polygon has previously been selected, in which case the RGBA color output by the pixel shader may be used to allow triangle or polygon deselection (0.0, 0.0, 0.0, 1.0), otherwise the color output should be (1.0, 0.0, 0.0, 1.0) to allow triangular or polygonal selection.

Step E - During the mouse dragging, steps B to D may be repeatedly performed to allow the user to perform the removal or deselection of the triangle or polygon. When the mouse drag is complete, the result of the triangle or polygon selection can be stored in RT0. Prepare the next mouse drag by copying the entire contents of RTO to RT1.

Step F - If the user wants to clear the existing triangle or polygon selection, RT1 can be cleared with RTO.

Thereafter, the render target texture RTO containing the result of the polygon selection may be copied to another texture assigned to the system memory, which can be read in such a manner that each pixel value is read one by one on the CPU in sequence. If the value of the pixel is 1.0, it means that the corresponding triangle or polygon has been selected, and the corresponding pixel index indicating the selected triangle or polygon index can be displayed to the user.

Since the process of copying a texture from GPU memory to system memory is relatively slow compared to selecting a triangle or polygon during mouse dragging, this process can be performed after the mouse drag ends.

FIG. 7 is a flowchart of a data processing method according to an embodiment of the present invention, illustrating a process of processing data during a mouse drag of a user based on any one of the first and second embodiments.

Referring to FIG. 7, first, render target textures RT0 and RT1 and vertex buffers VT0 and VT1 are generated (S11), and RT0 and RT1 are cleared to 0 (S12) for each pixel. Here, the vertex buffers VT0 and VT1 may include generated vertex lists V0 and V1. S11 and S12 correspond to steps 1 to 3 in the above-described first embodiment.

Thereafter, it is determined whether or not the mouse dragging by the user is in progress for selecting the rectangle (S13). If the dragging of the mouse is in progress, steps S14 to S18 to be described later are repeated.

Specifically, the original mesh geometry is rendered as a transformation (S14). S14 corresponds to the fourth step in the first embodiment.

Thereafter, RT0 is set as the current render target, and RT1 is set to the current texture to be sampled using point filtering with the deactivated texture mipmap (S15). S15 corresponds to the fifth step in the first embodiment described above.

Then, a point sprite representing the selected polygon is rendered using the vertex list V0 and the polygon selection vertex and pixel shader (S16). S16 corresponds to steps 6 to 9 in the first embodiment described above.

Thereafter, the default render target is restored and RT0 is used as the current texture to be sampled using point filtering with the deactivated texture mipmap (S17). S17 corresponds to step 10 in the first embodiment.

Then, a triangle representing the selected polygon is rendered using the vertex list V1 and polygon highlight vertex and pixel shader (S18). S18 corresponds to steps 11 and 12 in the first embodiment described above.

Then, when the mouse drag is completed, the entire contents of RT0 are copied to RT1 (S19), the entire contents of RT0 are copied to the texture in the system memory, the texture is read and the user is informed about the polygon selection (S20 ).

The data processing method according to the embodiment of the present invention may be implemented in a computer program code (for example, C ++, JAVA, etc.) for performing the data processing and recorded in a computer-readable storage medium. Here, the computer-readable storage medium may include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical media storage, and the like.

The results of executing the above-described embodiment of the present invention in the following hardware environment are as follows.

1) Intel i5-3470 CPU

2) 4 GB RAM

3) Intel HD 4000 GPU with 1760 MB memory (128 MB dedicated GPU memory included).

The following Table 1 performs triangular selection based on a two-dimensional rectangle drawn by the user in an application for a mesh composed of 349448 triangles and provides information about the selection to the user (by storing selected triangle indices in the vector) It represents the time required.

When using CPU without OpenMP (A) When using CPU with OpenMP (B) When using CPU with vertex and pixel shader (C) Time (ms) 368 ms 103 ms 9 ms
(1 ms to select triangle during mouse drag, 8 ms to provide information about triangle selection after mouse drag completion) Improvement in calculation speed (%) - (A) and 357% (A)
(B)

According to one embodiment of the present invention, the selection or deselection of a triangle or polygon during a mouse drag allows the user to easily interact with the mesh geometry, thereby obtaining a list of selected triangles or polygons after the mouse drag is over Thereby saving the user time and effort to make a decision to modify or store the mesh geometry.

Also, according to an embodiment of the present invention, most of the data processing is performed in the GPU, so that the CPU can perform other tasks such as the progress of the mouse drag.

Also, according to one embodiment of the present invention, since it uses programmable vertex and pixel shader, it can be performed using shader model 2.0 or 3.0 supported by most graphics cards (GPUs) on the market.

In addition, when an embodiment of the present invention is executed using the DirectX 9.0c API, it can be executed in a higher version of Windows XP or later Windows. Likewise, one embodiment of the invention may be implemented on a variety of platforms using OpenGL.

The present invention is not limited to the above-described embodiments and the accompanying drawings. It will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the spirit and scope of the invention as defined by the appended claims. In addition, all or a part of each of the above-described embodiments of the present invention may be selectively combined with each other.

Claims (11)

A first step of generating first and second render target textures and first and second vertex lists;
A second step of rendering original mesh geometry;
A third step of setting the first render target texture as a current render target and the second render target texture as a current texture to be sampled;
A fourth step of rendering the first vertex and the first pixel shader and the first vertex list using the first vertex and the first pixel shader;
A fifth step of restoring the default render target and setting the first render target texture to the current texture; And
A second vertex and a second pixel shader; and a sixth step of rendering using the second vertex and second pixel shader and the second vertex list.
The method according to claim 1,
Wherein the first and second render target textures are nxn pixel blocks for indicating whether a polygon is selected by dragging a mouse and n is an odd number.
The method according to claim 1,
Wherein the vertex of the first vertex list is generated for each of a plurality of triangles present in the mesh geometry and wherein the vertices are generated for a mesh geometry comprising three vertex positions and a two dimensional screen position forming a triangle in three- Data processing method.
The method according to claim 1,
Wherein a vertex of the second vertex list is generated for each of a plurality of triangles present in the mesh geometry, the vertex comprising a vertex position and a two-dimensional texture coordinate within the three-dimensional model coordinate, Way.
2. The method of claim 1, wherein after the first step,
And clearing each pixel of the first and second render target textures to a preset value.
The method according to claim 1,
Wherein the second to sixth steps are repeatedly performed when a mouse drag is in progress.
The method as claimed in claim 1,
Transferring the first vertex list to the first vertex shader and re-rendering the first vertex list;
Performing a triangle-rectangle intersection test in a two-dimensional space;
If the result of the triangle-rectangle intersection test is successful, outputting a two-dimensional screen position indicating a polygon to which the vertex belongs; And
And generating a solid color for each pixel of the rectangle in the first pixel shader.
8. The method of claim 7,
Wherein the first vertex shader and the first pixel shader are polygon selection vertex shaders and polygon selection pixel shaders, respectively.
The method as claimed in claim 1,
Transferring the second vertex list to the second vertex shader and re-rendering the second vertex shader; And
And in the second pixel shader, sampling the first render target texture using the 2D texture coordinates output by the second vertex shader.
The method according to claim 1,
Copying the contents of the first render target texture to the second render target texture when the mouse drag ends; And
Further comprising providing information on polygon selection or deselection based on the content of the first render target texture.
11. A computer program code for performing a method of processing data for a mesh geometry according to any one of claims 1 to 10.

Images