A large-scale dynamic object rendering budget control method and system based on block division

Abstract

The present invention discloses a block-based large-scale dynamic object rendering budget control method and system, comprising: defining the maximum rendering load that the system can handle and the priority scores of all object types in the system; dividing a three-dimensional scene into multiple uniform square blocks and sequentially numbering them; online querying the user and the blocks around them; calculating the priority of the queried blocks; and allocating resources to the queried blocks from high to low priority. By first dividing the 3D scene into blocks and then dynamically scoring the importance of objects within each block, the present invention achieves more efficient rendering budget control. This method combines space management with a dynamic scoring mechanism to improve rendering performance and resource utilization in complex scenes.

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 is of great 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 the 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 not only improves the realism of the picture but also directly affects user engagement and satisfaction.

[0003] Area of ​​Interest (AOI) is a commonly used performance optimization technique for rendering large numbers of dynamic objects. This approach typically involves dynamically defining one or more AOIs based on the user's position, perspective, and interaction behavior. These areas encompass the objects or parts of the scene the user is currently focused on. Objects within the AOI are rendered first, while objects outside the AOI are rendered less frequently or completely eliminated. This allows the system to focus computing resources on the content the user cares about most. AOIs help the system focus resources on the areas the user is currently focused on, reducing unnecessary rendering computations. Another commonly used method for optimizing rendering performance is Level of Detail (LOD). This method requires creating multiple models of different levels of detail for each object during the development phase. During rendering, the system determines which level of model to use based on the object's distance from the camera. When an object is close to the camera, the system uses a high-detail model to ensure visual quality. When the object moves away, the system automatically switches to a low-detail model to reduce the computing resources required for rendering. This significantly reduces the computational burden of rendering while maintaining visual quality.

[0004] However, for scenes with large-scale objects, even with AOI and LOD to control which objects and levels of detail the user can see, there may still be a large number of dynamic objects around the user, causing the rendering system to be overloaded with computations and degrading system performance. This can lead to a loss of real-time performance and a poor user experience. Therefore, a computing power control system is needed to control the computational load for system rendering and animation updates, i.e., the overhead budget. Summary of the Invention

[0005] To address the shortcomings of the existing technology, the present invention provides a block-based large-scale dynamic object rendering budget control method and system. The technical solution of the invention is achieved through the following:

[0006] A first aspect of the present invention is a block-based large-scale dynamic object rendering budget control method, 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, 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, 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: Divide the 3D scene into multiple uniform square blocks with 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 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 size of 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 the higher-level LOD 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 bucket to improve the performance of the system.

[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, W i represents the priority score of the object in block i, D i Represents the distance priority score of block i, R i Indicates the angle priority score of block i.

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

[0016]

[0017] Among them, n i Indicates the total number of objects in block i, k is the sequence number of the objects in block i, 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 The maximum distance defined in advance by the system, d i Indicates the distance between the center point of block 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 The maximum angle defined in advance by the system, r i is the angle between the direction of 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 is subject to the following rules:

[0025] (5.1) If the LOD priority of a block is to be lowered, a persistence check 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 block-based large-scale dynamic object rendering budget control system, comprising the following modules:

[0028] Budget Definition Module: This module is used to define the maximum rendering load that can be processed based on hardware performance and scene complexity. It also sets an upper limit on the number of objects at different LOD levels, forming multiple LOD buckets. Higher-level LOD buckets contain objects with more details, while lower-level LOD buckets contain objects with simplified details. Furthermore, a priority score is assigned to all possible object types in the scene, with the priority defined based on the object's importance and its impact on the user experience.

[0029] Block division module: used to divide the 3D scene into multiple uniform square blocks with 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 within 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 current block based on the user's location, and queries all blocks within a fixed range around it, 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 size of 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 the 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.

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

[0034] This invention significantly improves the rendering efficiency of groups of dynamic objects by introducing a block-based rendering budget control method. By evaluating object priority scores and dynamically assigning LOD levels within a scene, the system effectively manages rendering resources and reduces unnecessary high-detail rendering operations. This approach ensures that important objects within the user's field of view are always rendered at high quality, while out-of-field or less important objects are rendered at lower detail, minimizing the rendering burden and improving overall system performance.

[0035] Furthermore, through block partitioning and online query mechanisms, this invention dynamically adjusts the rendering priority of different areas, ensuring the system's adaptability to complex scenarios. By combining hardware performance with scene complexity to define and allocate budgets, the system maintains high frame rates and stability across different hardware configurations. Through this intelligent budget control and allocation mechanism, this invention significantly improves the quality and efficiency of real-time rendering and enhances the user experience. BRIEF DESCRIPTION OF THE DRAWINGS

[0036] The accompanying drawings are incorporated into the specification and serve as an integral part of the specification, illustrating the implementation 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 the invention, 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 This 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, which refers to the accompanying drawings, will set forth specific details of one embodiment in order to provide a comprehensive understanding of all aspects of the claimed invention. It will be apparent to those skilled in the art that certain modules and systems of the present invention may be implemented using alternative embodiments that differ from the specific details described below. The following description is intended to be illustrative rather than limiting. Any modifications, equivalent substitutions, etc. made within the spirit and principles of the invention are intended to be included within the scope of protection of the invention.

[0043] This block-based large-scale dynamic object rendering budget control method achieves more efficient rendering budget control by dividing a 3D scene into blocks and then assigning importance scores to each block. This method combines space management with a dynamic scoring mechanism 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. The specific implementation steps of a block-based large-scale dynamic object rendering budget control method include:

[0045] Step 1: If Figure 2 As shown, before the system begins rendering, the user needs to define the maximum number of resources at different LOD levels based on the complexity of the system and the quality of the hardware, forming multiple LOD level buckets. Higher-level LOD buckets store objects with more details, while lower-level LOD buckets store objects with simplified details. At the same time, all possible object types in the game scene, such as treasure chests, vehicles, buildings, merchants, and minerals, are prioritized. 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 of 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 obtained directly according to 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 updating the positions of all objects in each frame, the system updates the objects contained in the block. It obtains the block number of the player using the player's position coordinates, then uses range search to obtain all blocks within a fixed range around the player and saves 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 level. Blocks with higher priorities are closer to the head of the queue, and blocks with lower priorities are closer to the tail of the queue. This step can be accelerated by using 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, W i represents the priority score of the object in block i, D i Represents the distance priority score of block i, R i Indicates the angle priority score of block i.

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

[0052]

[0053] Among them, n i Indicates the total number of objects in block i, k is the sequence number of the objects in block i, 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 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 The maximum angle defined in advance by the system, r i is the angle between the direction of 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, 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 around the player (orange blocks) 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 LOD bucket of the bottom level until all blocks are placed in the corresponding bucket. If the LOD priority of the block is to be reduced, a persistence judgment is required. The downgrade switch is only performed if the block is at the current LOD level for a certain period of time (3 seconds in this embodiment) or more. Otherwise, no switch is performed 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 also needs to be switched at the same time to achieve the purpose of further improving 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 segmentation, which includes the following modules:

[0063] Budget Definition Module: This module is used to define the maximum rendering load that can be processed based on hardware performance and scene complexity. It also sets an upper limit on the number of objects at different LOD levels, forming multiple LOD buckets. Higher-level LOD buckets contain objects with more details, while lower-level LOD buckets contain objects with simplified details. Furthermore, a priority score is assigned to all possible object types in the scene, with the priority defined based on the object's importance and its impact on the user experience.

[0064] Block division module: used to divide the 3D scene into multiple uniform square blocks with 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 within 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 current block based on the user's location, and queries all blocks within a fixed range around it, 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 size of 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 lower 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.

[0068] Although the above describes the specific embodiments 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 on the basis of the technical solutions disclosed in the present invention without the need for creative work should be included in the scope of protection of the present invention.

Claims

1. A block-based large-scale dynamic object rendering budget control method, 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, 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, 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: Divide the 3D scene into multiple uniform square blocks with 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 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 size of 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 the higher-level LOD 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 bucket to improve the performance of the system.

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, W i represents the priority score of the object in block i, D i Represents the distance priority score of block i, R i Indicates the angle priority score of block 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 Indicates the total number of objects in block i, k is the sequence number of the objects in block i, 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 The maximum distance defined in advance by the system, d i Indicates the distance between the center point of block 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 score for the block in question: R i =(M r -r i )*a r Among them, M r The maximum angle defined in advance by the system, r i is the angle between the direction of 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 is subject to the following rules: (5.1) If the LOD priority of a block is to be lowered, a persistence check 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 segmentation, characterized in that: The system includes the following modules: Budget Definition Module: This module is used to define the maximum rendering load that can be processed based on hardware performance and scene complexity. It also sets an upper limit on the number of objects at different LOD levels, forming multiple LOD buckets. Higher-level LOD buckets contain objects with more details, while lower-level LOD buckets contain objects with simplified details. Furthermore, a priority score is assigned to all possible object types in the scene, with the priority defined based on the object's importance and its impact on the user experience. Block division module: used to divide the 3D scene into multiple uniform square blocks with 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 within 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 current block based on the user's location, and queries all blocks within a fixed range around it, 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 size of 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 the 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.

Images