Block-based large-scale dynamic object rendering budget control method and system

Abstract

The invention discloses a block-based large-scale dynamic object rendering budget control method and system. Comprising the steps of defining a maximum rendering load which can be processed by a system and priority scores of all object types in the system, dividing a three-dimensional scene into a plurality of uniform square blocks and sequentially numbering the square blocks, inquiring a user and surrounding blocks on line, calculating priorities of the inquired blocks, and calculating the priorities of the inquired blocks according to the priorities of the inquired blocks. And carrying out resource allocation on the queried blocks according to the priority from high to low. According to the method, the 3D scene is subjected to block division, and then the objects in each block are dynamically subjected to importance scoring, so that more efficient rendering budget control is realized. According to the method, space management and a dynamic scoring mechanism are combined, and the rendering performance and the resource utilization rate in a complex scene are improved.

Description

Technical Field

[0001] The present invention belongs to the technical field of computer graphics, and in particular relates to a block-based large-scale dynamic object rendering budget control method and system. Background Art

[0002] Large-scale dynamic object rendering has important application value and necessity in modern computer graphics. With the rapid development of interactive applications such as games, virtual reality and augmented reality, real-time rendering technology has become a core element of user experience. Large-scale dynamic objects, such as pedestrians, vehicles and animals, often play a key role in these applications, enhancing the vividness and immersion of the scene. However, as the complexity of the scene increases, the computing resources and bandwidth required to render these dynamic objects also increase significantly, resulting in a decrease in real-time performance. Effective budget control for large-scale dynamic object rendering can not only improve the realism of the picture, but also directly affect user engagement and satisfaction.

[0003] AOI (Area of ​​Interest) is a commonly used performance optimization technique for rendering a large number of dynamic objects. This solution usually requires dynamically defining one or more areas of interest based on the user's position, perspective, and interactive behavior. These areas include the objects or parts of the scene that the user is currently paying attention to. Objects in the area of ​​interest will be rendered first, while objects that are not in the area can be rendered less frequently or completely eliminated. This allows the system to focus computing resources on the content that the user cares about most. AOI can help the system focus resources on the part that the user is currently paying attention to, thereby reducing unnecessary rendering calculations. Another method commonly used to optimize rendering performance is LOD (Level of Detail), which requires creating multiple models of different levels of detail for each object during the development phase. When rendering, the system determines which level of model to use based on the distance between the object and the camera. When the object is close to the camera, the system uses a high-detail model to ensure visual effects. When the object is far away, the system automatically switches to a low-detail model to reduce the computing resources required for rendering. This can significantly reduce the computing burden of rendering while ensuring visual quality.

[0004] However, for a scene with large-scale objects, even if AOI and LOD are used to control the objects and detail levels that users can see, there may still be a large number of dynamic objects around the user, resulting in excessive computation of the rendering system and reduced system performance, which will cause the system to lose real-time performance and bring a poor user experience. Therefore, a computing power control system is needed to control the amount of computation for system rendering and animation updates, that is, the overhead budget. Summary of the invention

[0005] In view of the shortcomings of the prior art, the present invention provides a large-scale dynamic object rendering budget control method and system based on block division. The technical solution of the invention is achieved through the following contents:

[0006] The first aspect of the present invention is a large-scale dynamic object rendering budget control method based on block, comprising the following steps:

[0007] (1) Budget definition: Based on the hardware performance and the complexity of the scene, define the maximum rendering load that can be processed, and set an upper limit on the number of objects for different LOD levels to form multiple LOD level buckets; high-level LOD buckets store objects with more details, and low-level LOD buckets store objects with simplified details; at the same time, prioritize all possible object types in the scene, and define the priority based on the importance of the object and its impact on the user experience;

[0008] (2) Block division: The 3D scene is divided into multiple uniform square blocks with a fixed length and width, and each block is numbered in order from front to back and from left to right; each block covers a specific range of 3D space; all objects within each block use the same LOD level;

[0009] (3) Online query: After updating the coordinates and orientations of all dynamic objects in the scene, query the block where the user's current location is located, and query all blocks within a fixed range around it, and then store these blocks in a list;

[0010] (4) Priority calculation: traverse each block in the list, calculate the priority of each block according to the priority algorithm, and store these blocks in a priority queue according to the priority. The block with a higher priority is closer to the head of the queue, and the block with a lower priority is closer to the tail of the queue.

[0011] (5) Budget allocation: Traverse each block in the priority queue from front to back, and put the objects in the currently traversed block into a higher-level LOD level bucket. If the upper limit of the bucket is reached, try to put it into the lower-level LOD bucket until all blocks are placed in the corresponding bucket; render the objects in the block at different LOD levels according to the LOD level bucket to improve system performance.

[0012] Furthermore, in step (4), the priority of each block is calculated using the following formula:

[0013]

[0014] Among them, i represents the block number currently traversed, j is the block number the user is currently in, S irepresents the total priority score of block No. i, Max is a maximum value defined in advance by the system, and W i represents the priority score of the object in the i-th block, D i Represents the distance priority score of block No. i, R i Represents the angle priority score of block number i.

[0015] Furthermore, the object priority score W in the block i The calculation formula is:

[0016]

[0017] Among them, n i represents the total number of objects in the i-th block, k is the serial number of the object on the i-th block, k = 1, 2, ..., n i , l ik is the priority score of the kth object in the i-th block, a l is the object priority score scaling factor.

[0018] Furthermore, the distance priority score D of the block i The calculation formula is:

[0019] D i =(M d -d i )*a d

[0020] Among them, M d is the maximum distance defined in advance by the system, d i represents the distance between the center point of block No. i and the user's location, a d is the distance fraction scaling factor.

[0021] Furthermore, the angle priority score of the block is:

[0022] R i =(M r -r i )*a r

[0023] Among them, M r is the maximum angle defined in advance by the system, r i is the angle between the line connecting the user and the i-th block and the direction the user is currently facing, a r is the angular scaling factor.

[0024] Furthermore, in step (5), the budget allocation mechanism adds the following rules:

[0025] (5.1) If the LOD priority of a block is to be lowered, a persistence judgment is required. The downgrade switch is performed only if the block remains at the current LOD level for a certain period of time. Otherwise, the switch is not performed.

[0026] (5.2) If the object that needs to switch the LOD level has animation, in addition to switching the rendered LOD level, the animation update frequency must also be switched.

[0027] The second aspect of the present invention is a large-scale dynamic object rendering budget control system based on block, comprising the following modules:

[0028] Budget definition module: used to define the maximum rendering load that can be processed according to the hardware performance and the complexity of the scene, and set the upper limit of the number of objects for different LOD levels to form multiple LOD level buckets; among them, high-level LOD buckets store objects with more details, and low-level LOD buckets store objects with simplified details; at the same time, all possible object types in the scene are prioritized, and the priority is defined according to the importance of the object and its impact on the user experience;

[0029] Block division module: used to divide the 3D scene into multiple uniform square blocks according to fixed length and width, and number each block in order from front to back and from left to right; each block covers a specific range of 3D space; all objects inside each block use the same LOD level;

[0030] Online query module: After updating the coordinates and orientations of all dynamic objects in the scene, it queries the block where the user is currently located based on the user's location, and queries all blocks within a fixed range around the user, and then stores these blocks in a list;

[0031] Priority calculation module: used to traverse each block in the list, calculate the priority of each block according to the priority algorithm, and store these blocks in a priority queue according to the priority. The block with a higher priority is closer to the head of the queue, and the block with a lower priority is closer to the tail of the queue.

[0032] Budget allocation module: used to traverse each block in the priority queue from front to back, and put the objects in the currently traversed block into a high-level LOD level bucket. If the upper limit of the bucket is reached, try to put it into the bottom-level LOD bucket until all blocks are placed in the corresponding bucket; render the objects in the block at different LOD levels according to the LOD level bucket to improve system performance.

[0033] The beneficial effects of the present invention are as follows:

[0034] The present invention can significantly improve the rendering efficiency of group dynamic objects by introducing a block-based rendering budget control method. In the scene, by evaluating the priority scores of objects and dynamically assigning LOD levels, the system effectively manages rendering resources and reduces unnecessary high-detail rendering operations. This method ensures that important objects within the user's perspective are always rendered with high quality, while objects far away from the field of view or unimportant are rendered with lower details, thereby minimizing the rendering burden and improving the overall performance of the system.

[0035] In addition, the present invention can dynamically adjust the rendering priority of different areas through block division and online query mechanism, ensuring the system's adaptability to complex scenes. Budget definition and allocation are combined with hardware performance and scene complexity, so that the system can maintain a high frame rate and stability under different hardware configurations. Through this intelligent budget control and allocation mechanism, the present invention significantly improves the quality and efficiency of real-time rendering and improves the user's interactive experience. BRIEF DESCRIPTION OF THE DRAWINGS

[0036] The attached figures are incorporated into the specification and serve as an integral part of the specification, illustrating the implementation methods of the various modules involved in the present invention in accordance with the principles of the present invention. The focus of the drawings is not to limit but to explain the principles of the invention. In the drawings,

[0037] Figure 1 It is an execution flow chart of the block-based large-scale dynamic object rendering budget control method of the present invention;

[0038] Figure 2 is a possible budget definition result in an embodiment of the present invention;

[0039] Figure 3 is a process diagram of calculating the priority of a queried block using a priority calculation formula in an embodiment of the present invention;

[0040] Figure 4 It is a process diagram of allocating resources using a priority queue according to the present invention;

[0041] Figure 5 It is a schematic diagram of the system flow of the present invention. DETAILED DESCRIPTION

[0042] The following detailed description refers to the drawings and will set forth specific details of an embodiment in order to provide a comprehensive understanding of the various aspects of the invention for which protection is sought. For developers who are familiar with the relevant technology, it is obvious that other embodiments different from the specific details described below can be used to implement certain modules and systems in the present invention. The following description is intended to be illustrative rather than limiting. All modifications, equivalent substitutions, etc. made within the spirit and principles of the invention should be included in the scope of protection of the invention.

[0043] The block-based large-scale dynamic object rendering budget control method of the present invention achieves more efficient rendering budget control by dividing the 3D scene into blocks and then scoring the importance of each block. The method combines space management and dynamic scoring mechanisms to improve rendering performance and resource utilization in complex scenes.

[0044] like Figure 1 As shown, the solution of the present invention is applied to a first-person open world game, and the specific implementation steps of a large-scale dynamic object rendering budget control method based on block include:

[0045] Step 1: If Figure 2 As shown, before the system starts rendering, the user needs to define the maximum number of resources at different LOD levels according to the complexity of the system and the quality of the hardware equipment, forming multiple LOD level buckets. High-level LOD buckets store objects with more details, and low-level LOD buckets store objects with simplified details. At the same time, priority scores are given to all possible object types in the game scene, such as treasure chests, vehicles, buildings, merchants, minerals, etc. The priority is defined based on the importance of the object and its impact on the user experience;

[0046] Step 2: The system divides the three-dimensional scene into multiple uniform square blocks with a fixed length and width according to the side length input by the user, and numbers all the blocks in sequence according to each row (x direction) and each column (z direction). The block number can be directly obtained based on the spatial position, so it does not need to be saved. For example, the scene has x and z blocks in the x and z directions respectively. By default, the point with spatial coordinates (x0, y0, z0) is mapped to the block coordinates (i, j) by rounding. The system calculates the number of the block with coordinates (i, j) through the formula id = i + j × x, and calculates the coordinates of the grid numbered id through the formula i = id% x, j = id / x. Each block covers a specific range of 3D space, and the block will update the objects contained in it in real time. These objects will be rendered at the same LOD level;

[0047] Step 3: After the system updates the positions of all objects in each frame, it updates the objects contained in the block, obtains the block number of the player through the player's position coordinates, and then obtains all blocks within a fixed range around the player through range search, and stores these blocks in a list;

[0048] Step 4: Traverse each block in the list, calculate the priority of each block according to the priority algorithm, and store these blocks in a priority queue according to the priority. The blocks with higher priorities are closer to the head of the queue, and the blocks with lower priorities are closer to the tail of the queue. This step can be accelerated by multi-threaded parallel processing. The priority of each block is calculated using the following formula:

[0049]

[0050] Among them, i represents the block number currently traversed, j is the block number where the player is currently located, S u represents the total priority score of block No. i, Max is a maximum value defined in advance by the system, and W i represents the priority score of the object in the i-th block, D i Represents the distance priority score of block No. i, R i Represents the angle priority score of block number i.

[0051] Furthermore, the object priority score W in the block i The calculation formula is:

[0052]

[0053] Among them, n i represents the total number of objects in the i-th block, k is the serial number of the object on the i-th block, k = 1, 2, ..., n i , l ik is the priority score of the kth object in the i-th block, a l It is the object priority score scaling factor, which is a constant defined in advance by the system.

[0054] Furthermore, the distance priority score D of the block i The calculation formula is:

[0055] D i =(M d -d i )*a d

[0056] Among them, M d is the maximum distance defined in advance by the system, d i Indicates the distance between the center point of block i and the player's position, a d is the distance fraction scaling factor, which is a constant defined in advance by the system.

[0057] Furthermore, the angle priority score of the block is:

[0058] R i=(M r -r i )*a r

[0059] Among them, M r is the maximum angle defined in advance by the system, r i is the angle between the line connecting the user and the i-th block and the direction the user is currently facing, a r is the angle scaling factor, which is a constant defined in advance by the system.

[0060] A possible outcome is Figure 3 As shown in the figure, assuming that the scene has been divided into fixed-size blocks according to the side length input by the user, and the block where the player is located in the current frame is the gray block in the figure, the system queries the 5×5 blocks (orange blocks) around the player and puts these blocks into the list to be calculated. After calculation according to the priority algorithm above, the priority scores of these 25 blocks are as follows Figure 3 As shown in the numbers.

[0061] Step 5: Figure 4 As shown, each block in the priority queue is traversed from front to back, and the objects in the currently traversed block are placed in the highest possible LOD level bucket. If the upper limit of the bucket is reached, try to put it into the bottom LOD bucket until all blocks are placed in the corresponding bucket. If the LOD priority of the block is to be reduced, persistence judgment is required. Only when the block is at the current LOD level for a certain period of time (3 seconds in this embodiment) or more will it be downgraded and switched, otherwise it will not be switched to prevent the problem of frequent flickering of the screen. In addition, if the object that needs to be switched at the LOD level has animation, in addition to switching the rendered LOD level, the update frequency of the animation must also be switched at the same time to achieve the purpose of further improving the system performance. The system will render the objects in the block at different LOD levels according to the LOD level bucket to improve the performance of the system.

[0062] In addition, if Figure 5 As shown, the present invention also provides a large-scale dynamic object rendering budget control system based on block, which includes the following modules:

[0063] Budget definition module: used to define the maximum rendering load that can be processed according to the hardware performance and the complexity of the scene, and set the upper limit of the number of objects for different LOD levels to form multiple LOD level buckets; among them, high-level LOD buckets store objects with more details, and low-level LOD buckets store objects with simplified details; at the same time, all possible object types in the scene are prioritized, and the priority is defined according to the importance of the object and its impact on the user experience;

[0064] Block division module: used to divide the 3D scene into multiple uniform square blocks according to fixed length and width, and number each block in order from front to back and from left to right; each block covers a specific range of 3D space; all objects inside each block use the same LOD level;

[0065] Online query module: After updating the coordinates and orientations of all dynamic objects in the scene, it queries the block where the user is currently located based on the user's location, and queries all blocks within a fixed range around the user, and then stores these blocks in a list;

[0066] Priority calculation module: used to traverse each block in the list, calculate the priority of each block according to the priority algorithm, and store these blocks in a priority queue according to the priority. The block with a higher priority is closer to the head of the queue, and the block with a lower priority is closer to the tail of the queue.

[0067] Budget allocation module: used to traverse each block in the priority queue from front to back, and put the objects in the currently traversed block into the highest possible LOD level bucket. If the upper limit of the bucket is reached, try to put it into the bottom LOD bucket until all blocks are placed in the corresponding buckets; render the objects in the block at different LOD levels according to the LOD level bucket to improve the performance of the system.

[0068] Although the above describes the specific implementation mode of the present invention in conjunction with the accompanying drawings, it is not intended to limit the scope of protection of the present invention. Those skilled in the art should understand that various modifications or variations that can be made by those skilled in the art without creative work on the basis of the technical solution disclosed in the present invention should be included in the scope of protection of the present invention.

Claims

1. A large-scale dynamic object rendering budget control method based on block segmentation, characterized in that: The method comprises the following steps: (1) Budget definition: Based on the hardware performance and the complexity of the scene, define the maximum rendering load that can be processed, and set an upper limit on the number of objects for different LOD levels to form multiple LOD level buckets; high-level LOD buckets store objects with more details, and low-level LOD buckets store objects with simplified details; at the same time, prioritize all possible object types in the scene, and define the priority based on the importance of the object and its impact on the user experience; (2) Block division: The 3D scene is divided into multiple uniform square blocks with a fixed length and width, and each block is numbered in order from front to back and from left to right; each block covers a specific range of 3D space; all objects within each block use the same LOD level; (3) Online query: After updating the coordinates and orientations of all dynamic objects in the scene, query the block where the user's current location is located, and query all blocks within a fixed range around it, and then store these blocks in a list; (4) Priority calculation: traverse each block in the list, calculate the priority of each block according to the priority algorithm, and store these blocks in a priority queue according to the priority. The block with a higher priority is closer to the head of the queue, and the block with a lower priority is closer to the tail of the queue. (5) Budget allocation: Traverse each block in the priority queue from front to back, and put the objects in the currently traversed block into a higher-level LOD level bucket. If the upper limit of the bucket is reached, try to put it into the lower-level LOD bucket until all blocks are placed in the corresponding bucket; render the objects in the block at different LOD levels according to the LOD level bucket to improve system performance.

2. The block-based large-scale dynamic object rendering budget control method according to claim 1, characterized in that: In step (4), the priority of each block is calculated using the following formula: Among them, i represents the block number currently traversed, j is the block number the user is currently in, S i represents the total priority score of block No. i, Max is a maximum value defined in advance by the system, and W i represents the priority score of the object in the i-th block, D i Represents the distance priority score of block No. i, R i Represents the angle priority score of block number i.

3. The block-based large-scale dynamic object rendering budget control method according to claim 2, characterized in that: The object priority score W in the block i The calculation formula is: Among them, n i represents the total number of objects in the i-th block, k is the serial number of the object on the i-th block, k = 1, 2, ..., n i , l ik is the priority score of the kth object in the i-th block, a l is the object priority score scaling factor.

4. The block-based large-scale dynamic object rendering budget control method according to claim 2, characterized in that: The distance priority score D of the block i The calculation formula is: D i =(M d -d i )*a d Among them, M d is the maximum distance defined in advance by the system, d i represents the distance between the center point of block No. i and the user's location, a d is the distance fraction scaling factor.

5. The block-based large-scale dynamic object rendering budget control method according to claim 2, characterized in that: Angular priority scores for the blocks: R i =(M r -r i )*a r Among them, M r is the maximum angle defined in advance by the system, r i is the angle between the line connecting the user and the i-th block and the direction the user is currently facing, a r is the angular scaling factor.

6. The block-based large-scale dynamic object rendering budget control method according to claim 1, characterized in that: In step (5), the budget allocation mechanism adds the following rules: (5.1) If the LOD priority of a block is to be lowered, a persistence judgment is required. The downgrade switch is performed only if the block remains at the current LOD level for a certain period of time. Otherwise, the switch is not performed. (5.2) If the object that needs to switch the LOD level has animation, in addition to switching the rendered LOD level, the animation update frequency must also be switched.

7. A large-scale dynamic object rendering budget control system based on block division, characterized in that: The system includes the following modules: Budget definition module: used to define the maximum rendering load that can be processed according to the hardware performance and the complexity of the scene, and set the upper limit of the number of objects for different LOD levels to form multiple LOD level buckets; among them, high-level LOD buckets store objects with more details, and low-level LOD buckets store objects with simplified details; at the same time, all possible object types in the scene are prioritized, and the priority is defined according to the importance of the object and its impact on the user experience; Block division module: used to divide the 3D scene into multiple uniform square blocks according to fixed length and width, and number each block in order from front to back and from left to right; each block covers a specific range of 3D space; all objects inside each block use the same LOD level; Online query module: After updating the coordinates and orientations of all dynamic objects in the scene, it queries the block where the user is currently located based on the user's location, and queries all blocks within a fixed range around the user, and then stores these blocks in a list; Priority calculation module: used to traverse each block in the list, calculate the priority of each block according to the priority algorithm, and store these blocks in a priority queue according to the priority. The block with a higher priority is closer to the head of the queue, and the block with a lower priority is closer to the tail of the queue. Budget allocation module: used to traverse each block in the priority queue from front to back, and put the objects in the currently traversed block into a high-level LOD level bucket. If the upper limit of the bucket is reached, try to put it into the bottom-level LOD bucket until all blocks are placed in the corresponding bucket; render the objects in the block at different LOD levels according to the LOD level bucket to improve system performance.

Images