JP4887419B2 - Multi-resolution geometrical arrangement - Google Patents

Description

  The present invention relates to the field of generating three-dimensional graphics, and more particularly to the field of generating multi-resolution objects in a three-dimensional environment.

Realistic 3D object rendering for use in games and other software applications has long been the goal of software and hardware manufacturers in the computer industry. However, there are numerous problems that hinder the achievement of realistic 3D object rendering on a typical user's home computer.
Three-dimensional graphics use polygons to create objects that are to be rendered. Such polygons are generated and manipulated to draw the curvature and details of the object. The more polygons used to create an object, the more detailed and realistic the object. However, as the number of polygons used to create one object increases, the calculation required for rendering the object increases, and therefore the speed of rendering the object decreases. For this reason, from a developer's perspective, there is a trade-off between speed and realism.

  Solving this problem is not easy. Most users do not have a modern high-performance personal computer, so if a developer wants to target a product to the largest number of potential users, he / she will have an object for the lowest common denominator. Must design. For this reason, the developer must assume that the user's processor is slow and only capable of rendering a few triangles per second. For this reason, developers will support the speed side of the equation (speed vs. realism) when making the above trade-off, and will have fewer triangles than if a faster machine is used by all users. Must be used to design the object. However, this solution does not satisfy both users with low-end computers and users with high-end computers. Users who have low-end computers are still likely to get slow and choppy images, and users with high-end computers will not be able to completely sacrifice realism. Because the application is not designed to take advantage of the greater processing power of high-end machines, you will get an unnatural and robot-like image. In fact, depending on the high-end system, the number of polygons is so small that the processing of the application is too fast to play or interact with.

  Another problem faced by developers is the fact that even for the same object, the details it needs are more when it is close to the screen than when it is in the background. As the object approaches the screen, the corners and straight edges of the polygons that make up the object can be seen more clearly. At this time, more polygons are required to smooth the corners of the object and continue realistic rendering of the object. However, rendering the object using the most detailed version of the object is not always possible. This is because the application requires too much computing power to render the image on the screen quickly and smoothly. In order to achieve smooth 3D animation, the processor must render 3D objects at 20-60 frames / second. If too many polygons are used for each object, and the object provides the necessary realism as the object approaches the screen, the processor is required to do the above for smooth rendering. The minimum frame rate cannot be achieved.

  One solution that allows realistic rendering of 3D objects and limits the number of polygons on the screen is the use of Level of Detail mapping. Detail level mapping provides different resolution levels of an object based on the distance of the object to the screen. In order to generate different levels of detail, the developer must generate different versions (ie variants) of objects for each level required. Typically only 3 or 4 levels are used. This is because the storage of each of the multiple versions of the object to be rendered can consume too much of the user's system resources.

  The level of detail method has several drawbacks. First, this method has a significant impact on system resources, as described above. For the method, each object requires three or four times more storage space than previously required to store each version of the object. Each level requires a separate vertex list as well as a separate data structure. Second, an effect known as object popping occurs when transitioning from one level to another. As the object moves toward the screen, a higher detail version of the object is suddenly rendered and “pops out” (ie, suddenly expands) at the viewer, thereby resulting in the 3D sink quality of the application. (Immersive qualities) are destroyed. The level of detail method also requires extra generation of each version of the object, which requires more time for the developer. The level of detail method also does not address the above-mentioned least common denominator problem. The highest level of detail for each object must be created to account for users with inefficient computers that will use the application. For this reason, the highest level of detail cannot contain a large amount of polygons, otherwise the image that appears on the user's low-end computer will be slow and uneven. Further, such an image cannot appear to use the greater processing capability of the high-end computer, and thus appears as a square robot on the user's high-end computer.

    In accordance with the present invention, an apparatus, system, and method for generating realistic rendering of 3D objects while minimizing user system resource usage and maximizing fidelity without sacrificing speed Is disclosed.

  The present invention uses a vertex merging process depending on the position of the object on the screen and other factors to generate a continuous level of detail of the object, thereby eliminating the popping effect of the object. When an object moves toward the background and therefore needs to reduce polygons to provide realistic rendering, the vertices of the object are brought together in a way designed to produce minimal visual distortion. Merged (ie, merged). When the vertices are merged, some polygons in the object are removed. Therefore, the number of polygons of the object continuously decreases as the object moves away from the screen. When the object moves toward the screen, a vertex is added to the object, and a polygon is added to the object. This provides a more realistic depiction of the object as it approaches the user and requires elaborate details (ie, details). Thus, at any given moment, every object on the screen has only the number of polygons needed to provide a realistic rendering of the object. Unnecessary polygons are never drawn, and the user's system is used in an optimal state. Based on the movement of the object in the 3D environment, polygons are continuously added to or removed from the object, so no object popping effect is generated.

  Furthermore, the present invention only requires that one version of the object be created and stored on the user's system, thus minimizing the impact on system resources. In order to use a single vertex list (which preferably specifies the highest level of detail), the system according to the present invention generates a continuous level of detail of the object for display on the screen. Can do. The system can also advantageously increase or decrease the resolution of the object on the fly. Also, since only the current level of detail being displayed is stored, the required memory usage is minimized. By storing certain minimum information that is determined prior to execution to induce a resolution change, the resolution change is made at run time at an optimal rate. Another advantage of the present invention resides in the ability to allow developers to tweak the vertex merging process according to their preferences. Finally, the present invention automatically adjusts the number of polygons in the screen according to the capabilities of the user's system, thereby providing an optimal image for every user. In one embodiment, the present invention monitors the system to determine the frame rate at which frames are rendered and adjusts the total number of polygons allowed on the screen at a time accordingly.

  In addition, a target frame rate can be set, which allows the user to specify the speed at which the scene should be rendered. The present invention dynamically adjusts the total number of polygons to ensure that the frame rate is maintained. Alternatively, the present invention allows the number of polygons to be specified and ensures that there is always a certain amount of polygons on the screen regardless of the frame rate.

  In the preferred embodiment, the generation of a three-dimensional visual representation of an object having multiple resolutions is performed as follows. Reading a vertex list for an object, determining a collapse order with respect to the vertices identified in the vertex list, and reordering the vertices identified in the vertex list according to the determined collapse order; A vertex collapse list is created according to the collapse order. Here, the vertex collapse list specifies, for a target vertex (hereinafter referred to as a target vertex), an adjacent vertex that is to be collapsed. The vertex list can be constructed from the 3D coordinates of the vertices without reference to other vertex attributes, and in an alternative embodiment, the vertex list is a vertex such as color or normal. It is also possible to refer to other attributes.

  More specifically, in the preferred embodiment, the determination of the collapse order of objects is performed as follows. That is, determine an optimal collapse path from a set of collapse paths, calculate a visual distortion factor for the selected collapse path, determine a collapse value for the selected collapse path, and The comparison of values is repeated for each path in the set of collapse paths to determine the collapse path that produces the least visual distortion to the object, and the next vertex to be collapsed is selected and selected Collapse the object along the collapse path and repeat this until the minimum resolution level is achieved.

1 is a block diagram illustrating a preferred embodiment of a computer system according to the present invention. 1 is a block diagram illustrating a preferred embodiment of a computer system with a modular distributed architecture according to the present invention. FIG. FIG. 3 is a schematic diagram illustrating a preferred embodiment for creating a collapse order list according to the present invention. It is explanatory drawing which shows the 1st example of the object before a vertex is collapsed. 2B is an illustration showing the object of FIG. 2B after the vertices have been collapsed according to the present invention. FIG. It is explanatory drawing which shows the object of a lower resolution. It is explanatory drawing which shows the object of FIG. 2D to which the vertex was added. FIG. 4 is a diagram illustrating in detail a preferred embodiment of determining the collapse order according to the present invention. FIG. 4 is an illustration showing in detail a preferred embodiment of determining a set of collapse paths according to the present invention. FIG. 5 is a diagram illustrating in detail a preferred embodiment for selecting a collapse path according to the present invention. FIG. 5 is a diagram illustrating in detail a preferred embodiment of the visual distortion factor calculation according to the present invention. FIG. 5 is an explanatory diagram detailing a preferred embodiment of determining collapse values for selected collapse paths according to the present invention. FIG. 6 is an illustration showing an alternative preferred embodiment of determining the collapse order according to the present invention. FIG. 6 is an illustration showing an alternative embodiment of determining a set of collapse paths according to the present invention. 6 is a flowchart illustrating a preferred embodiment of runtime management means according to the present invention. 6 is a flowchart illustrating an alternative embodiment of the runtime management means according to the present invention. It is explanatory drawing which shows the Example of the analysis of the optimal collapse level of the object by this invention. It is explanatory drawing which shows one Example of this invention for using it by remote transmission of data.

  FIG. 1A illustrates a preferred embodiment of a computer system 100 according to the present invention. The computer system 100 is typically implemented in a computer system 100 such as a personal computer having a Pentium ™ processor made by Intel and running a Windows95 ™ operating system made by Microsoft. The ROM 112 is a read-only memory that stores data having an invariant function. The disk 124 stores data that does not require immediate access, such as operating system modules, databases, and other modules. In one embodiment, when used by developer 166, disk 124 stores vertex list generation module 138, collapse path determination module 142, collapse value analysis module 146, collapse path selection module 150, vertex list 158, and collapse list 154. To do. In one embodiment, when used by user 170, disk 124 stores applications, runtime management means 162, and collapse list 154. When access to the stored module is requested, the module is moved to the RAM. The RAM 108 stores data that requires further immediate access. Display 120 and input device 116 are connected to processor 104 via bus 118 and allow user 170 or developer 166 to interact with the modules stored on disk 124.

  FIG. 1B illustrates a distributed architecture implementing the preferred embodiment of the present invention. The vertex list generating unit 180 includes an application specific integrated circuit (ASIC) connected to a memory, and generates a vertex list 158. The vertex list 158 is sent to the collapse path determination means 184, and the collapse path determination means 184 determines a collapse path from the received vertex list 158. The collapse path data is sent to the collapse value analysis means 188, which analyzes the collapse path data and determines a collapse value for each collapse path. The collapse value is sent to the collapse path selection means 192 together with the collapse path itself, and the collapse path selection means 192 is an observer who sees the collapse when the object is collapsed along the selected collapse path. Select a collapse path from the vertex list that will produce the least visual distortion for. The selected collapse path is stored in the collapse list memory 194, and a new set of vertices is generated by the vertex list generation means 138 in accordance with the selected collapse path. The system continues to generate and select collapse paths until the vertex list generation means does not have the remaining vertices from which the list is generated, and then the processing of the system is completed. The final collapse list is transmitted from the collapse list memory to the processor 104 of the developer computer 100.

  The data source 196 stores the original vertex list to be processed. The data sources include applications that require modeling of objects, i.e. secondary sources that store objects that require modeling according to the present invention. In one embodiment, modules 138, 142, 146, 150 are implemented as a set of Field Programmable Gate Arrays and programmed to perform the separate functions described above. By partitioning separate functions in a distributed architecture, faster and more robust processing is achieved.

  FIG. 2A illustrates the process of a preferred embodiment of the present invention for generating a collapse order. First, the vertex list 158 is acquired (200). Typically, vertex list 158 is provided by developer 166 for each object that developer 166 wishes to model. Vertex list 158 can include an index to a 3D coordinate map, or vertex list 158 can be indexed to another map, such as a texture map, or a regular map. Vertex list 158 is normally “cleaned” before it is processed. Typically, the vertex list 158 can specify triangles having edges that are close to each other but do not actually overlap. If the cleaning operation is not performed, the triangle of which the adjacent edges are part will be considered as two separate polygons, which will cause holes or cracks at the lower resolution of the model. Become. For this reason, the system looks for redundant vertex data in the vertex list and eliminates the redundancy.

  Vertex list 158 may specify a maximum set of vertices to use for the object, or a maximum set of vertices and a minimum set of vertices to use for the object. The minimum number of sets of vertices is specified by developer 166 to define a minimum quality level beyond which the object cannot be collapsed. The more vertices that collapse in an object, the more realistic the object will appear when examined nearby. Thus, for some objects, the developer 166 can determine that a point exists. This point is the point beyond which the object is no longer perceived as its true shape (the object at that point is very small on the screen and therefore has sufficient detail) Even if you don't need a lot of polygons to specify). For such objects, developer 166 specifies a minimum set of vertices. An object can collapse to the minimum number of vertices. The system identifies those vertices during the process and does not collapse those vertices in the object. The vertex list 158 can also specify a nested set of vertices that represent the progressively decreasing resolution of the object. In this case, the system generates a collapse list that interpolates between the set of nested vertices.

  After obtaining the vertex list, the system proceeds to determine collapse order (204). The collapse order of objects specifies the order in which individual vertices are merged with other vertices. The vertices are collapsed along the collapse path in order to cause the object to have the smallest possible visual distortion. For example, as shown in FIG. 2B, the object has a number of vertices, three of which are specified as V1, V2, V3. If the system according to the invention determines that the first collapse path is V1 → V2, the object will be as shown in FIG. 2C. The object of FIG. 2C has fewer polygons to render than the object of FIG. 2B. Thus, the object of FIG. 2C has a lower resolution than the object of FIG. 2B, and if the object is placed closer to the background or due to other factors detailed below, Alternatively, it should be displayed when there is a high possibility that the user 170 will not notice it even if the resolution is increased. Displaying a version of the object that contains fewer polygons as it approaches the background allows the processor to spend more time processing objects that are closer to the foreground. As a result, the foreground object can have a greater number of polygons without affecting the frame rate.

  After determining the collapse order for the object, the vertex list 158 is reordered to the order specified by the collapse order (208). The vertices to be collapsed first are identified, and the other vertices are ordered based on the collapse priority of those vertices. The system advantageously minimizes its footprint in its memory by using the existing vertex list 158 instead of using another configuration to store this information. The system then generates a vertex collapse list 154 (212). The vertex collapse list specifies vertices to be targeted when the target vertex is collapsed. Alternatively, the list specifies vertices to which the added vertex is connected. When collapsing an object's vertices to achieve a lower resolution, the system can simply delete the vertices as ordered in the vertex list until the desired resolution is obtained. However, more information is required to increase the resolution of an object by adding vertices. In any case, the correct triangle list must be generated by the system at the desired resolution. The list of triangles specifies the connection information for all of the triangles that must be rendered to achieve the desired resolution.

  For example, as shown in FIG. 2D, the object is initially in a low resolution state. In FIG. 2E, vertices are added to the object to increase the number of polygons, thereby increasing the resolution of the object. However, as shown, if there is no further information, the system cannot know which vertex should be connected to the new vertex. Therefore, more information is stored in the vertex collapse list 154. The vertex collapse list 154 stores connection information about adjacent vertices to which each vertex is connected. In the example of FIGS. 2D and 2E, the vertex to which V1 is connected is also specified in the vertex collapse list 154, so that the system can know the correct edge to draw. By using the connection information, a correct triangle list is generated for each resolution. In the preferred embodiment, information about the two lists 154, 158 is stored in the same location to optimize processing. Since arrays and other data structures are preferably used to store collapse information, term (ie relation) lists are used descriptively.

  FIG. 3 is an illustration showing in more detail a preferred embodiment of the determination of the collapse order according to the present invention. Initially, a set of collapse paths is determined (300). This set of collapse paths identifies every possible collapse path between each vertex and every other vertex to which it is connected at the current resolution of the object. Accordingly, the object of FIG. 2B has eleven vertices (V1 to V11). For V2, it is possible to identify four potential decay paths (C1, C2, C3, C4).

  A collapse path is then selected from the set of collapse paths (304). A visual distortion factor is calculated for the selected decay path (308). The visual distortion factor is the magnitude of the effect of a given collapse on the object. Some collapse paths have a much greater visual impact on the user than other collapse paths. For example, if V1 collapses to V2, the object will appear to shrink its width significantly. However, if V8 collapses to V11, the user will not appear to distort the object. The system captures the above differences by calculating several visual distortion factors, including area changes, angular changes, and local volume changes, as detailed below.

  Each decay path is given one decay value as a function of the visual distortion factor calculated for that decay path (312). The collapse value is preferably a weighted combination of visual distortion factors of the collapse path. By weighting different factors, the developer 166 can specify the importance of the factors applied in the specific application to be developed.

  The system determines 316 whether there are more collapse paths. If there are more collapse paths, the next collapse path is selected (304) and the above process is repeated. Also, if there are no more collapse paths, the system compares the collapse path collapse values to determine the collapse path that produces the least visual distortion to the object (320).

  Vertices to be collapsed are identified according to the determined collapse path (324), collapse priority is assigned to the vertex (326), and the collapse priority reorders the vertex list. used. The object is collapsed along the collapse path (328). The system determines whether two or more vertices remain other than the vertex set consisting of the minimum number of vertices (332). If there are no more than two such vertices, then the system proceeds to reorder the vertex list 158. When two or more such vertices remain, the system treats the collapsed object as an object to be newly processed and repeats the above-described processing. The system determines a set of collapse paths that cause the object to produce minimal visual distortion and processes the object until the collapse path reduces the object from its maximum resolution to the minimum resolution. Do. For each stored collapse path, the vertex to which the target vertex is to be connected and the connectivity change represented by the triangle list are stored. Thus, when a vertex is added to the object, the system can identify which triangle is connected to the added vertex by another vertex. This information is stored in the vertex collapse list 154 as described above.

  FIG. 4 illustrates an alternative embodiment of a method for determining a set of collapse paths. First, a target vertex is selected (400). Any one of the existing vertices of the object can be selected, and the order is not important. An input is then received (404) specifying the maximum number of adjacent vertices to examine each vertex. This allows the developer 166 to control the processing time of the system. By limiting the number of adjacent vertices examined by the system for each vertex, the system does not need to perform as many calculations.

  Adjacent vertices are then identified (408). Adjacent vertices are vertices that are connected along the edge to the target vertex. Adjacent vertices include any vertex that is directly connected to the target vertex, as well as any vertex that is connected to the target vertex via another one or more vertices. It can be inferred that this list can be quite large if every vertex is processed. However, as described above, the maximum number of adjacent vertices can be specified to minimize processing.

  After identifying adjacent vertices, a collapse path is determined between the target vertex and the adjacent vertices (412). The system determines whether the maximum number of collapse paths has been reached (416). If the maximum number of collapse paths has been reached, the system determines whether there are more vertices (420). If there are additional vertices, the collapse paths for the other vertices are calculated as described above. Also, if there are no more vertices, the system selects one collapse path from the set of collapse paths (304).

  FIG. 5 shows an example of collapse path selection. In this embodiment, the processor computation is minimized by limiting the number of collapse paths that will have collapse values. For the first iteration through the object, a collapse value is calculated for every collapse path. After the collapse path is selected, the object is collapsed along the collapse path. A new set of collapse paths is generated as described above. However, in this iteration, collapse values are generated for collapse paths that are within a predetermined distance from the collapse path previously used to collapse the object. After the previous collapse, the multiple collapse paths will remain the same, and their collapse values (ie, the measure of visual impact of the collapse on the object) will also remain the same.

  For example, in FIG. 2B, when C1 is selected as the collapse path, the object shown in FIG. 2C is obtained as a result. The collapse value of the collapse path between V8 and V11 remains the same for the two objects before and after such deformation. This is because the vertices around V8 and V11 are not affected by the decay of C1. Therefore, it is not necessary to recalculate the decay value of the decay path for V8 to V11. Since there is no visual distortion factor calculation for every collapse path after every collapse, the calculation of the system is greatly minimized and the processing speed is much faster.

  Thus, as shown in FIG. 5, the system determines whether the collapse path is within a threshold distance from the previous collapse path (500). The threshold can be preset or defined by the developer 166. Developer 166 can experiment with different thresholds to maximize accuracy while minimizing computations. If the collapse path is within the threshold, the system calculates a visual distortion factor for the collapse path (308). Also, if the collapse path is not within the threshold, the existing collapse value is subsequently used as the collapse value of the collapse path, and the next collapse path is selected.

  FIG. 6 shows three visual distortion factors that are preferably calculated according to a preferred embodiment of the present invention. First, the area change of the object is calculated in response to the collapse of the object along the selected collapse path (600). The area change of the object is calculated by calculating the surface area of the object before collapse, and then calculating the surface area of the object after collapse. The difference between the two surface areas is indicative of the effect on the surface area of the object that will undergo the collapse process. Second, an angular change is calculated in response to the collapse of the object along the collapse path (604). The angular change is a measure of the effect on the local curvature of the object that will undergo collapse. The system calculates the normal of the triangle of which the vertex is a part. Multiple points representing a large curvature are more important for the visual appearance of the object. Accordingly, such points are assigned a scale that reduces their collapse priority. Third, a local volume change is calculated in response to the collapse (608). Using the target vertex as the vertex of the pyramid, a pyramid is generated from the target vertex. The base of the pyramid is a triangle formed from three consecutive adjacent vertices. Such a series of pyramids is constructed from successive sets of adjacent triple vertices and their volumes are summed. The volume of the object is determined, the target vertex is collapsed along the collapse path, and the volume is calculated again. This volume change is used to represent the effect on the visual appearance of the object. The calculation of the “local volume” change of the pyramid is much faster than the calculation of the “true” volume of the object, and more accurately indicates the geometry of the object. Other visual distortion measures known to those skilled in the art can also be used in accordance with the present invention. Statistical measures of error, such as surface deviation, can also be used to calculate visual distortion.

  FIG. 7 shows an alternative embodiment of determining the collapse value for the selected collapse path. In the example, the system accepts an input from the developer 166 specifying the priority weights for different factors (700). The system multiplies each factor by the specified priority weight (704) and then combines each factor to obtain a collapse value (708). By allowing the developer 166 to specify weights, the developer 166 is allowed more creative control. Developer 166 can determine that the object is very pointed and therefore should give the highest weight to the angle change factor. Therefore, the developer 166 designates a high weight for the angle change factor. Collapse of an object having a large angle change factor will set a lower priority for collapse. Also, if the object represents an organic shape, the local volume factor becomes even more important. Developer 166 assigns a higher weight to the local volume factor, and the collapse priority that has a greater impact on the local volume will be set lower. If the developer 166 does not specify a weight, a default value that weights each factor equally is used. In one embodiment, the developer 166 can increase the processing speed of the system by removing factors from consideration. For example, the developer 166 can determine that the local volume change is not related to a particular object. Developer 166 then specifies that local volume changes should not be calculated for the object. This allows the system to process objects much faster.

  FIG. 8 shows an alternative embodiment of the collapse order determination step 204. The embodiment allows the developer 166 to “fine tune” the collapse order interactively. Since the visual distortion of an object is essentially a subjective decision, the present invention advantageously allows the developer's 166 subjective preference to be introduced into the collapsed state of the object. Initially, a set of collapse paths is determined as described above (800). The object is then displayed to the user at the current resolution level. If this is the first iteration, the object will be at the maximum resolution level. The system randomly selects one collapse path from the set of collapse paths to collapse the object. The system displays the collapsed object to developer 166, who can see the impact of the collapse on the object. If developer 166 approves the collapse, developer 166 selects the path. If the system receives an input to select the route (820), the system prioritizes the collapse based on the number of routes already selected. If the developer 166 does not approve the collapse, the next collapse path is selected and the process is repeated.

  In one embodiment, a collapse value is calculated for each collapse path, and the paths are prioritized as described above. The collapse path designated to collapse first is selected as the first path to be collapsed and displayed to developer 166. If the developer 166 selects the collapse path, the path maintains its priority. A new set of collapse paths is generated, and the highest priority collapse path is selected from the new set of collapse paths and displayed to the developer 166. If the developer 166 does not select the collapse route, the next highest priority route is selected and displayed to the developer 166. Of course, the developer 166 can specify a particular path at any time that is visible in the object that the developer 166 wishes to collapse. Such a choice by developer 166 will override any prior prioritization by the system.

  FIG. 9 shows an embodiment of the present invention. In this case, the developer 166 designates a set of a minimum number of vertices before calculating the collapse path. As described above, the set of minimum number of vertices is the set of vertices that the developer 166 does not want to collapse. Thus, as shown in FIG. 9, after a collapse path has been selected (900), the system causes the collapse path to collapse one vertex specified in the minimum set of vertices. It is determined whether or not (904). If there is a vertex in the minimum set of vertices, the collapse path is not selected.

  In another embodiment, the texture map is indexed by vertices. A texture map provides a realistic appearance to an object by providing a texture to the mapped area. The textures for different triangles can be quite different from each other. Thus, when collapsing a triangle, the system must determine the effect of the loss of triangle texture on the appearance of the object. Vertices on the edges of discontinuities in the texture are not collapsed due to the effect that collapse will have on the appearance of the object. For this reason, when selecting the collapse path, the vertex in the collapse path is inspected to determine whether the vertex is located on the edge of the discontinuous portion of the texture. If the vertex is located on the edge of a texture discontinuity, the collapse path is not selected.

  FIG. 10 shows the runtime management means of the present invention. The runtime management means executes addition or reduction of polygons to the object as necessary when the application is executed in real time. The runtime management means operates in association with the graphic system of the computer and the application program that has processed the object. At the start of the application, the runtime management means collapses objects referenced in the application (1000). The runtime management means stores the extended vertex collapse information for each collapse level of the object in the table (1004). The expanded vertex collapse information is information stored in the vertex collapse list 154, and the vertex collapse list 154 includes the vertex to be collapsed of each vertex to be collapsed, and the triangle that needs to be deleted from the model. Is specified. By storing the extended vertex collapse information in the table, the processor can add and delete polygons at a higher speed. This is because the processor need only access the table to determine the vertices and triangles to add, delete, or re-index, and does not have to perform any excessively required calculations. It is.

  In one embodiment, an expanded table for each object has already been created at the development stage, and the table is simply loaded into data memory to facilitate access at the start of the application. The runtime management means waits for a request from the application regarding the collapse level from the object. The initial appearance of each object is represented with a default resolution. When an application or graphics program requests (1008) increased or decreased resolution from the runtime management means, the runtime management means that the requested resolution is greater than the current collapse level of the object. Decide if the collapse level is required (1012). Since the current collapse level of the object is the only one of the objects stored in memory, the current collapse level is known. If the requested resolution requires a higher collapse level for the object, vertices are added to the object according to the vertex collapse information in the table until the requested collapse level is met. This continuous vertex addition provides a smooth rendering of the object and eliminates the problem of object popping described above. Similarly, if the requested resolution is one that requires a collapse level lower than the current collapse level, the vertex is collapsed until the correct resolution of the object is achieved (1016). The table also makes it possible to instantly add and delete polygons from an object when requested. The table also does not need to store all versions of the object, so that the present invention allows a minimum memory occupancy to be achieved. Also, artifacts due to object popping are eliminated by the addition or reduction of continuous polygons on the object. Thus, in accordance with the present invention, an efficient and fast object modeling process is disclosed that provides multiple levels of resolution and minimizes resource usage.

  FIG. 11 shows an alternative embodiment of runtime management means for analyzing objects to determine collapse levels. In this embodiment, as described above, the object is collapsed (1100), and vertex information is stored for each collapse level (1104). However, in this example, the object is analyzed (1108) to determine the optimal collapse level. If the runtime management means determines an optimal collapse level that requires a higher resolution (1112), vertices are added to the object (1120). Also, if the optimal collapse level requires a lower resolution than the current resolution, the vertex is collapsed (1116).

  FIG. 12 shows several methods for analyzing the optimal collapse level of an object. One or all of these methods can be used in accordance with the present invention to determine the optimal collapse level. Initially, the speed of the object is determined (1200). The speed of the object is determined by measuring the distance that the object has moved between the current frame and the previous frame and dividing the distance by the time elapsed between those frames. Alternatively, the speed measures the distance traveled over some of the most recently rendered frames, and the distance is the total elapsed time for rendering the entire recent frame sequence. Calculated by dividing. The determined speed is then compared to a table that maps the speed of the object to the collapse level. This table can be specially designed for a given object, or it can be a global table that gives a general correlation between velocity and collapse level. An object needs a lower resolution for its realistic rendering as its moving speed increases. This is because such movement tends to obscure the finer details of the object. Thus, the current speed of the object is compared with the table to determine the resolution required at that speed. If the runtime management means determines that the required resolution is a collapse level greater than the current collapse level of the object (1232), more polygons are added as described above (1236). . If the resolution required by the object is lower than the resolution given by the current collapse level, polygons are reduced (1240). Thus, the runtime management means dynamically manages the resolution of the object to provide optimum fidelity and minimize the use of processing power.

  The protruding area of the object is another factor used by the runtime management means to determine the optimal collapse level for the object. The protruding area of the object is an area that the object will occupy when rendered on the display. The larger the protruding area of the object, the higher the required resolution. The system determines (1208) the current protruding area of the object and compares the protruding area to a table that correlates the protruding area and the collapse level (1212). Next, the number of polygons is adjusted according to the comparison result (1232).

  The present invention also provides global polygon count management. In this embodiment, the user selects the number of target polygons (hereinafter referred to as the target polygon number) for each frame. In this embodiment, the system determines the number of polygons currently displayed in one frame (1216). The total number of polygons displayed in one frame is determined by determining the objects on the screen and summing the number of polygons of each object, or the number of triangles drawn on the screen in one frame. It is possible to make a calculation by holding a typical tally in the rendering means. This number is compared (1220) with a predetermined target polygon number. If the runtime management means determines that the current polygon count is smaller than the target polygon count (1232), additional polygons are added (1236). If it is determined that the current number of polygons is larger than the number of target polygons, the number of polygons is reduced (1240). The decision as to which object a polygon is added to and from which object the polygon is reduced can be implemented in many ways. It is possible to add or delete polygons uniformly for all polygons. Alternatively, it is possible to analyze objects one by one and add or delete polygons in units of individual objects.

  Alternatively, the user 170 can select a target frame rate (hereinafter referred to as a target frame rate). The runtime management means determines the current frame rate by monitoring the processor clock and determining the time required to render the frame (1224). The current frame rate is then compared to the target frame rate (1228). When the runtime management means determines that the current frame rate is faster than the target frame rate (1232), a polygon is added to the frame (1236) to slow down the frame rate. If the current frame rate is slower than the target frame rate, polygons are reduced from the frame (1240) to increase the frame rate. In this way, the runtime management means enables dynamic and global polygon management that requires minimal input from the user 170. This management process allows the present invention to be a universal platform, allowing the target frame rate or polygon count to be set as low as if the present invention were used in a system with a slower processor. Is possible, and the benefits described above are still provided. However, systems with faster processors can be set to have higher frame rates or polygon numbers, and the higher processing power of the system is maximized by the present invention.

  As shown in FIG. 13, the present invention can also be used to transmit data over a remote connection. When receiving data over a remote connection (eg, the Internet), the user 170 often waits for the data to be downloaded before the requested object is displayed. In accordance with the present invention, a minimal vertex set or lowest collapse level object is transmitted to the user 170 when requesting an object over a remote connection. This lowest resolution version of the object requires less data for display and is therefore transmitted to the user 170 much faster. Additional collapse levels are then continuously sent to the user 170 to increase the resolution of the object to its maximum resolution. Since each collapse level typically adds only a few polygons, each collapse level is also transmitted very quickly. This method allows the user to receive the lowest resolution version of the object very quickly and then shortly thereafter to receive the full resolution version of the object. If the user 170 does not need a full resolution object, the user 170 does not have to wait for unnecessary data (higher resolution data) to be transmitted before viewing the object. Also, even if the user 170 does not reach the maximum resolution but needs a higher resolution, the present invention transmits the higher resolution in packets, so that the user 170 can receive the maximum resolution version. The object can be viewed in less time than would be required to wait for the entire object to be downloaded.

  As shown in FIG. 13, a request for an object is received over a remote connection (1300). In response to the request, an object with the minimum resolution is transmitted to the requesting side (1304). The minimum resolution object is the lowest resolution object that can be displayed and still represent the object accurately. If a set of a minimum number of vertices of an object is specified by developer 166, that set is used as the minimum resolution to send. A packet of information is then sent (1308) containing the vertices needed to raise the collapse level of the object to the next higher resolution. As detailed above, this information includes the vertices and connections required to increase the resolution of the object. The system then determines (1312) whether the maximum resolution or target resolution has been transmitted. The system knows that the maximum resolution has been achieved when a packet is sent that contains the information necessary to increase the resolution of the object to its maximum resolution. Alternatively, the user 170 can specify a target resolution when requesting an object download. The optional selection of the target resolution allows the user to optimize the time required for data transfer to meet the user's fidelity needs. If the user 170 does not require a maximum resolution object, the user can specify that and only the intermediate resolution object is transmitted. The option is useful, for example, if the user 170 wants to see an object different from that being downloaded, or if the user 170 has a computer that cannot be viewed in high resolution. is there. If the target resolution or maximum resolution is not met, another packet is sent to the user 170. If the target resolution is satisfied, data transmission is complete.

Exemplary embodiments of the present invention are listed below.
1. A method for generating a three-dimensional visual representation of an object having multiple resolutions, comprising:
Get the vertex coordinates of the object,
Determine a collapse order for the vertices identified in the list of vertices;
Reordering the vertices identified in the list of vertices according to the determined collapse order;
A vertex collapse list that specifies adjacent vertices that are collapse destinations for target vertices and the like is generated according to the collapse order.
A method for generating a three-dimensional visual representation of an object having multiple resolutions.
2. Said step of determining the collapse order comprises:
Determine a set of decay paths,
Selecting one collapse path from the set of collapse paths;
Calculating a visual distortion factor for the selected decay path;
Determining a collapse value for the selected decay path as a function of the calculated visual distortion factor;
Repeating the steps of selecting a collapse path, calculating the visual distortion factor, and determining the collapse value for each collapse path,
Select the next vertex to be collapsed as the vertex with the collapse path that causes the object to have the least visual distortion,
Collapse the next vertex to be collapsed along the corresponding decay path;
Repeat the above steps until the minimum resolution level is achieved,
The method according to 1, comprising the steps of:
3. Said step of calculating a visual distortion factor comprises:
Calculating an area change factor for the selected decay path;
Calculating an angle change factor for the selected decay path;
Calculating a local volume change factor for the selected decay path;
3. The method according to 2, comprising the steps of:
4). Calculating the area change factor for the selected decay path;
Calculate the area of the object after collapsing the target vertex along the collapse path,
Dividing the calculated area from the area of the object before the collapse;
3. The method according to 3, comprising the steps of:
5. Calculating the local volume change factor for the selected decay path;
Calculate the volume of the object after collapsing the target vertex along the collapse path,
Subtracting the calculated volume from the volume of the object before the collapse;
3. The method according to 3, comprising the steps of:
6). Said step of calculating the volume comprises:
Select the target vertex to be the pyramid vertex,
Forming the base of the pyramid from a triangle connecting three consecutive adjacent vertices to the target vertex;
Calculate the volume of the pyramid;
Form the next pyramid from the next set of vertices consisting of three consecutive adjacent vertices;
Calculate the volume of the next pyramid,
Repeating the step of forming the next pyramid and the step of calculating the volume for all unique sets of three consecutive adjacent vertices;
Sum the volumes of the pyramids to get the volume of the object,
6. The method according to 5, comprising the steps of:
7). Receiving an input specifying a priority weight for a visual distortion factor from a user, wherein the step of determining a collapse value depends on the calculated visual distortion factor and the priority weight. 3. The method of 2, comprising determining a collapse value for the selected collapse path.
8). Depending on the step of collapsing the next vertex to be collapsed along the corresponding decay path, a local collapse path for the next vertex is identified and a visual distortion factor is calculated for each selected collapse path The method of 2, wherein said step and said step of determining a collapse value for a selected collapse path is repeated only for said local collapse path.
9. Said step of determining a set of decay paths comprising:
Select one target vertex,
Receives input specifying the maximum number of adjacent vertices for one target vertex;
Identifying a number of adjacent vertices in response to the received input;
Determining a collapse path in response to one coordinate of the one target vertex and the identified adjacent vertex;
Repeating the determining step for all of the identified adjacent vertices;
Repeating the steps of selecting a target vertex, identifying the adjacent vertex, determining the collapse path, and repeating the determining step for all of the identified adjacent vertices, for a plurality of vertices;
3. The method according to 2, comprising the steps of:
10. In response to selection of the collapse path, displaying the object before it is collapsed along the selected collapse path;
Collapse the object along the selected collapse path;
Displaying the object after being collapsed along the selected collapse path;
In response to receiving input selecting a collapse path, store the collapse path and its corresponding vertex in the collapse order list as the next vertex to be collapsed.
3. The method according to 2, comprising the steps of:
11. Receiving an input specifying a minimum number of sets of vertices, wherein the step of determining a collapse order determines the collapse order so that the specified minimum number of sets of vertices are not collapsed The method according to 1, comprising:
12 The method according to 1, wherein there are multiple resolution level objects,
Ordering the resolution levels from highest resolution level to lowest resolution level;
Select the highest resolution level for the collapse,
Said step of determining the collapse order comprises determining the collapse order for the highest resolution level, wherein the vertices of the next lower resolution level are not collapsed;
Repeating the selection step and the determination step for each resolution level;
The method according to 1, comprising the steps of:
13. 2. The method of 1, wherein a vertex attribute is associated with the vertex coordinate.
14 The method of 2, wherein the vertex has a texture map coordinate,
According to the selected collapse path, the first vertex is collapsed to the second vertex to generate a new vertex, and the texture map coordinates of the second vertex are assigned to the new vertex,
Identifying the collapse path as not to be used in response to the first vertex and the second vertex being on an edge of a texture discontinuity;
3. The method according to 2, comprising the steps of:
15. The method of 2, wherein the vertex has normal map coordinates,
In accordance with the selected collapse path, the first vertex is collapsed into the second vertex to generate a new vertex, and the normal map coordinates of the second vertex are assigned to the new vertex.
3. The method according to 2, comprising the steps of:
16. The method of 2, wherein the vertex has color map coordinates,
According to the selected collapse path, the first vertex is collapsed to the second vertex to generate a new vertex, and the color map coordinates of the second vertex are assigned to the new vertex,
Identifying the collapse path as not to be used in response to the first vertex and the second vertex being on the edge of a color discontinuity;
3. The method according to 2, comprising the steps of:
17. A method of displaying an object, wherein a vertex list and an adjacency list are stored for an object, vertices in the vertex list are identified by a collapse priority, and the adjacency list identifies a collapse path for the vertex,
Performing object collapse according to the vertex list and the neighbor list;
For each collapse level, store vertex information indicating which vertices exist in the object at the next collapse level higher than the current collapse level and the next collapse level lower than the current collapse level;
Receives input requesting the collapse level for an object,
In response to the requested collapse level that requires a higher resolution than the current collapse level, add vertices to the object according to the vertex list and the stored vertex information;
Collapsing vertices in an object according to the vertex list and the stored vertex information according to the requested collapse level, which requires a lower resolution than the current collapse level;
An object display method having the steps described above.
18. 18. The method according to 17, comprising storing expanded collapse information including triangle connection information about vertices.
19. A method of displaying an object, wherein a vertex list and an adjacency list are stored for an object, vertices in the vertex list are identified by a collapse priority, and the adjacency list identifies a collapse path for the vertex,
Performing object collapse according to the vertex list and the neighbor list;
For each collapse level, store vertex information indicating which vertices exist in the object at the next collapse level higher than the current collapse level and the next collapse level lower than the current collapse level;
Analyze the object to determine the collapse level,
In response to the determined collapse level requiring a higher resolution, add vertices to the object according to the vertex list and the stored vertex information;
Collapsing vertices in the object according to the vertex list and the stored vertex information in response to the determined collapse level requiring a lower resolution;
An object display method having the steps described above.
20. Said step of analyzing the object comprises:
Determine the speed of the object,
Determine the protruding area of the object,
20. The method according to 19, comprising the steps of:
21. Said step of analyzing the object comprises:
Determine the number of polygons currently displayed,
Comparing the determined number of polygons with a predetermined number of target polygons;
Adding a polygon to the object in response to the number of polygons currently being displayed being smaller than the predetermined target polygon number;
The method according to 20, comprising the steps of:
22. Said step of analyzing the object comprises:
Determine the current frame rate,
Comparing the current frame rate to a predetermined frame rate;
Collapsing vertices in an object in response to the current frame rate being less than the predetermined frame rate;
The method according to 1, comprising the steps of:
23. A method for transmitting data over a remote connection in a system in which a minimum resolution object is stored and individual information packets containing data for generating the higher resolution object are stored, comprising:
Receives a request for transmission of an object to be displayed,
Transmitting the lowest resolution version of the object in response to the received request;
Transmitting an information packet containing data for generating the next higher resolution object;
Determine whether the target resolution of the object is satisfied,
Repeating the step of transmitting an information packet containing data for generating the next higher resolution object in response to the target resolution of the object not being met,
A method for transmitting data over a remote connection, comprising the steps of:

100 computer system
104 processor
108 RAM
112 ROM
116 Input means
118 bus
120 displays
124 discs
138 Vertex list generation module
142 Collapse path determination module
146 Decay Value Analysis Module
150 Collapse path selection module
154 Vertex Collapse List
158 Vertex list

Claims (4)

A computer-implemented method for generating a three-dimensional visual representation of an object at a predetermined level of detail comprising:
Determining the collapse order for the vertices of the object across all levels of detail of the object;
Ordering the vertices of the object in a vertex list according to the determined collapse order;
Generating a vertex collapse list according to the collapse order, wherein the vertex collapse list is for each target vertex for at least one level of detail of the object, adjacent to the object to which the target vertex is collapsed. Specifying a vertex and each vertex collapse operation at each level of detail collapses each target vertex to an adjacent vertex directly connected to the target vertex at each level of detail;
Storing the vertex collapse list in memory;
Specifying the level of detail at which the object should be drawn;
Rendering a three-dimensional visual representation of the object with a specified level of detail using a vertex collapse list stored in the memory and the vertex list, the specified according to the vertex collapse list; Create a polygon using the target vertex and the adjacent vertex left in the vertex list after collapsing the target vertex to the adjacent vertex directly connected to the target vertex Drawing a three-dimensional visual representation of the object,
Determining the collapse order includes
Determining a set of collapse paths available at a level of detail;
For each collapse path in the set of collapse paths, calculate a visual distortion factor including area change, angle change, and local volume change of the object that occurs when a vertex is collapsed along the collapse path And
Determining collapse values for each of the set of collapse paths by weighting and combining the calculated visual distortion factors; and
Determining the set of collapse paths includes
Selecting one target vertex;
Receiving an input specifying a maximum number of vertices adjacent to the target vertex;
Identifying a number of adjacent vertices in response to received input;
Determining a collapse path according to the coordinates of the target vertex and the identified neighboring vertex;
Repeating the determination for all of the identified neighboring vertices;
Selecting the target vertex, identifying the adjacent vertex, determining the collapse path, and repeating the determination for all of the identified adjacent vertices To repeat about
A computer-implemented method comprising: A computer-implemented method for generating a three-dimensional visual representation of an object at a predetermined level of detail comprising:
Determining the collapse order for the vertices of the object across all levels of detail of the object;
Ordering the vertices of the object in a vertex list according to the determined collapse order;
Generating a vertex collapse list according to the collapse order, wherein the vertex collapse list is for each target vertex for at least one level of detail of the object, adjacent to the object to which the target vertex is collapsed. Specifying a vertex and each vertex collapse operation at each level of detail collapses each target vertex to an adjacent vertex directly connected to the target vertex at each level of detail;
Storing the vertex collapse list in memory;
Specifying the level of detail at which the object should be drawn;
Rendering a three-dimensional visual representation of the object with a specified level of detail using a vertex collapse list stored in the memory and the vertex list, the specified according to the vertex collapse list; Create a polygon using the target vertex and the adjacent vertex left in the vertex list after collapsing the target vertex to the adjacent vertex directly connected to the target vertex Drawing a three-dimensional visual representation of the object,
Have
Receiving the input specifying a minimum vertex set, wherein determining the collapse order comprises determining a collapse order in which the specified minimum vertex set is not collapsed. Method implemented in. A computer-implemented method for generating a three-dimensional visual representation of an object at a predetermined level of detail comprising:
Determining the collapse order for the vertices of the object across all levels of detail of the object;
Ordering the vertices of the object in a vertex list according to the determined collapse order;
Generating a vertex collapse list according to the collapse order, wherein the vertex collapse list is for each target vertex for at least one level of detail of the object, adjacent to the object to which the target vertex is collapsed. Specifying a vertex and each vertex collapse operation at each level of detail collapses each target vertex to an adjacent vertex directly connected to the target vertex at each level of detail;
Storing the vertex collapse list in memory;
Specifying the level of detail at which the object should be drawn;
Rendering a three-dimensional visual representation of the object with a specified level of detail using a vertex collapse list stored in the memory and the vertex list, the specified according to the vertex collapse list; Create a polygon using the target vertex and the adjacent vertex left in the vertex list after collapsing the target vertex to the adjacent vertex directly connected to the target vertex Drawing a three-dimensional visual representation of the object,
Have
Each vertex of the object has vertex coordinates and vertex attributes;
Each of the vertices has texture map coordinates;
The drawing is
Collapsing the first vertex into a second vertex;
After collapsing the first vertex to the second vertex, the texture map coordinates of the second vertex before collapsing the first vertex to the second vertex are the second Assign as vertex texture map coordinates,
Identifying the collapse path as a deprecated collapse path in response to the first vertex and the second vertex being on an edge of a texture discontinuity. . A computer-implemented method for generating a three-dimensional visual representation of an object at a predetermined level of detail comprising:
Determining the collapse order for the vertices of the object across all levels of detail of the object;
Ordering the vertices of the object in a vertex list according to the determined collapse order;
Generating a vertex collapse list according to the collapse order, wherein the vertex collapse list is for each target vertex for at least one level of detail of the object, adjacent to the object to which the target vertex is collapsed. Specifying a vertex and each vertex collapse operation at each level of detail collapses each target vertex to an adjacent vertex directly connected to the target vertex at each level of detail;
Storing the vertex collapse list in memory;
Specifying the level of detail at which the object should be drawn;
Rendering a three-dimensional visual representation of the object with a specified level of detail using a vertex collapse list stored in the memory and the vertex list, the specified according to the vertex collapse list; Create a polygon using the target vertex and the adjacent vertex left in the vertex list after collapsing the target vertex to the adjacent vertex directly connected to the target vertex Drawing a three-dimensional visual representation of the object,
Have
Each vertex of the object has vertex coordinates and vertex attributes;
Each of the vertices has color map coordinates;
The drawing is
Collapsing the first vertex into a second vertex;
After collapsing the first vertex into the second vertex, the color map coordinates of the second vertex before collapsing the first vertex into the second vertex, Assign as vertex colormap coordinates,
Identifying the collapse path as a deprecated collapse path in response to the first vertex and the second vertex being on an edge of a color discontinuity. .

Images