A primitive binning and culling method and system for super-high resolution rendering

Abstract

This invention discloses a primitive binning and culling method and system for ultra-high resolution rendering, comprising: determining a scaling factor based on the ratio of the target resolution to the baseline resolution; scaling the baseline tile size according to the scaling factor to generate an adaptive coarse tile mesh, ensuring that the scale of the coarse tiles in the normalized device coordinate space is consistent with the tile scale under the baseline resolution; projecting primitives into screen space; determining candidate coarse tiles based on the overlap between the screen space bounding area of ​​the primitives and the coarse tiles; establishing sub-tile meshes defined by vertical and horizontal shared grid lines within the candidate coarse tiles; detecting and marking the sub-tiles where the primitive centers are located; traversing the vertical and horizontal shared grid lines respectively; performing primitive contour intersection calculation only once for each grid line; batch marking continuous sub-tile intervals based on the solution results; and generating a bitmask based on the marking results. This invention can maintain a stable overlap factor and reduce computational complexity at ultra-high resolution.

Description

Technical Field

[0001] This invention relates to the fields of computer graphics, GPU parallel computing and real-time rendering technology, and in particular to a primitive binning and culling method and system for ultra-high resolution rendering. Background Technology

[0002] Explicit primitive rendering pipelines such as 3D Gaussian Splatting (3DGS) typically include stages such as primitive preprocessing, screen space binning, sorting, and rasterization blending. The system first projects 3D primitives onto a 2D screen space, determining the projection center, depth, covariance or conic parameters, and screen bounding area. Then, based on the overlap relationship between primitives and screen tiles, primitive-tile reference pairs are generated. Primitive references within the same tile are arranged consecutively using methods such as GPU cardinality sorting to support subsequent parallel rasterization processing.

[0003] In existing 3DGS rendering pipelines, tile sizes are typically set to a fixed pixel size, such as 16×16 pixels. At standard resolutions like 1080p, this size achieves a reasonable balance between parallel granularity, sorting overhead, and cache locality. However, with the increasing demands for image quality from virtual reality and augmented reality display devices, the need for 4K, 8K, and even higher resolution rendering is becoming increasingly urgent. In these ultra-high resolution scenarios, the actual projection range of the same 3D primitive in the Normalized Device Coordinates (NDC) remains essentially unchanged, but the pixel area it covers in screen space increases approximately quadratically with a linear scale of resolution. If fixed pixel-size tiles are still used for binning, the average number of tiles covered by a single primitive will increase dramatically; this metric is called the overlap factor.

[0004] The workload of the binning stage is typically positively correlated with the product of the number of visible primitives and the overlap factor. When the output resolution increases while the tile size remains constant, the system needs to repeatedly generate, write, sort, and traverse reference data for a large number of repetitive primitive-tile overlay relationships, leading to a simultaneous increase in binning time, sorting buffer capacity, and rasterization pre-processing overhead. Experimental data shows that when the rendering resolution increases from 1080p to 8K, the binning stage's time contribution can rise from approximately 40% to approximately 64%, and the overlap factor can increase from approximately 2.6 to approximately 9.6, thus making the binning stage a significant performance bottleneck in ultra-high resolution 3DGS rendering.

[0005] To address the aforementioned issues, existing technologies have implemented solutions to reduce invalid references through compact primitive outline bounding box clipping, primitive bounding range refinement, or per-sub-tile intersection testing. However, these solutions typically still use fixed-pixel tiles as the basic binning unit, failing to fundamentally suppress the redundant reference expansion caused by resolution increases. Performing 2D intersection detection on each sub-tile within a coarse tile introduces additional computational overhead approximately proportional to the square of the number of sub-tiles, and exacerbates GPU thread bundle divergence, potentially further hindering overall rendering efficiency in ultra-high resolution scenes. Summary of the Invention

[0006] In view of the above-mentioned shortcomings in the fields of computer graphics, GPU parallel computing and real-time rendering technology, the present invention provides a primitive binning and culling method and system for ultra-high resolution rendering, which can adaptively adjust the binning granularity according to the target resolution and reduce computational complexity while maintaining fine-grained culling capability.

[0007] To achieve the above objectives, the embodiments of the present invention adopt the following technical solutions:

[0008] A primitive binning and culling method for ultra-high resolution rendering includes:

[0009] Obtain the target resolution and determine a scaling factor based on the ratio of the target resolution to the baseline resolution. Scale the baseline tile size according to the scaling factor to generate an adaptive coarse tile grid on the target image plane.

[0010] The primitives are projected onto the screen space, and the candidate coarse tiles corresponding to each primitive are determined based on the screen space bounding area of ​​each primitive and the overlap relationship between each coarse tile.

[0011] Within each of the candidate coarse tiles, a sub-tile grid is established, defined by vertical and horizontal shared grid lines;

[0012] Perform fine-grained intersection detection within each of the candidate coarse tiles: mark the sub-tiles where the primitive center is located, and, based on the one-dimensional scan results of each of the vertical shared grid lines and each of the horizontal shared grid lines, batch mark the intersecting continuous sub-tile intervals;

[0013] A bitmask is generated based on the marking results of the fine-grained intersection detection, where each bit in the bitmask is used to indicate whether the corresponding sub-tile or corresponding primitive reference is valid.

[0014] According to one aspect of the invention, the scaling factor is determined based on the ratio of the target image width to the baseline image width, the ratio of the target image height to the baseline image height, the average of the two ratios, the maximum of the two ratios, or based on a scale value normalized to the display field of view.

[0015] According to one aspect of the invention, the target coarse tile size is obtained by: rounding the product of the scaling factor and the baseline tile size to the nearest integer, aligning it to the GPU thread block size, or cropping it to a preset upper or lower limit, so that the target coarse tile size is adapted to the GPU thread block configuration, shared memory capacity, or sort buffer size.

[0016] According to one aspect of the invention, the sub-tile mesh is established in any of the following ways: using sub-tiles with a fixed pixel size; using sub-tiles with a fixed number of rows and columns; adaptively dividing according to the size of the coarse tile; adaptively dividing according to the projected area of ​​the primitive; or dividing according to the GPU thread block size and shared memory capacity.

[0017] According to one aspect of the present invention, the marking of the sub-tile containing the center of the primitive specifically involves: calculating the local coordinates of the two-dimensional center of the primitive relative to the current coarse tile and its sub-tile grid; if the two-dimensional center is located within the current coarse tile or the current sub-tile grid, then the sub-tile containing the two-dimensional center is marked as a valid intersecting sub-tile.

[0018] According to one aspect of the present invention, the step of performing primitive contour intersection calculation only once for each shared grid line specifically includes:

[0019] Substitute the current shared grid line position offset into the primitive's contour equation to obtain a quadratic equation in another coordinate direction, and calculate the discriminant of this quadratic equation.

[0020] If the discriminant is less than zero, it is determined that the current shared grid line does not intersect with the primitive outline, and the entire row or column of sub-tiles corresponding to the current shared grid line is skipped.

[0021] If the discriminant is greater than or equal to zero, then solve for the root of the quadratic equation in one variable. The continuous interval determined by the root is mapped to the sub-tile row interval or column interval, and all sub-tiles in the row interval or column interval are batch-marked as valid intersections.

[0022] According to one aspect of the present invention, the mapping of the continuous interval determined by the root to the sub-tile row interval or column interval specifically involves: rounding up and down the two roots obtained by solving to obtain the covered continuous sub-tile index range, and marking all sub-tiles within the range as valid intersections at once.

[0023] According to one aspect of the invention, when the number of sub-tiles exceeds the number of bits in a single machine word, the effective intersection relationship is encoded as a multi-bit mask, wherein each machine word in the multi-bit mask corresponds to a subset of the sub-tile grid.

[0024] According to one aspect of the invention, the traversal of the valid bits in the bitmask is implemented by hardware bit operation primitives, which include: instructions for finding the first set bit, instructions for counting the number of set bits, and instructions for conditional broadcasting within a thread bundle to skip disjoint sub-tiles or non-contributing primitive references.

[0025] A primitive binning and culling system for ultra-high resolution rendering includes:

[0026] A parameter acquisition module is used to acquire rendering task parameters, which include at least the target resolution and the baseline tile size.

[0027] A scaling factor determination module is used to determine a scaling factor based on the ratio of the target resolution to the baseline resolution.

[0028] A coarse tile mesh generation module is used to scale the baseline tile size according to the scaling factor in order to generate an adaptive coarse tile mesh on the target image plane.

[0029] The projection module is used to project primitives onto the screen space and determine the candidate coarse tiles corresponding to each primitive based on the screen space enclosure range of each primitive and the overlap relationship between each coarse tile.

[0030] The sub-tile mesh creation module is used to create a sub-tile mesh defined by vertical shared mesh lines and horizontal shared mesh lines within each of the candidate coarse tiles;

[0031] The intersection detection module is used to perform fine-grained intersection detection within each of the candidate coarse tiles, including: marking the sub-tile where the primitive center is located, and, based on the one-dimensional scan results of each of the vertical shared grid lines and each of the horizontal shared grid lines, batch marking the intersecting continuous sub-tile intervals;

[0032] The bitmask generation module is used to generate a bitmask based on the marking results of the fine-grained intersection detection. Each bit in the bitmask is used to indicate whether the corresponding sub-tile or corresponding primitive reference is valid.

[0033] Advantages of implementing this invention:

[0034] 1. Effectively suppresses the growth of overlap factor at ultra-high resolution, reducing the processing load in the binning stage. This invention correlates the coarse tile size with the target resolution, maintaining an approximately constant scale of the coarse tiles in the normalized device coordinate space. This ensures that the overlap factor, representing the number of tiles covered by a single primitive, remains stable at ultra-high resolutions such as 4K and 8K. Compared to traditional fixed-pixel tile schemes, this significantly reduces the number of primitive-tile duplicate references, sorting input size, and binning buffer writes, fundamentally alleviating the performance bottleneck of the binning stage at high resolutions.

[0035] 2. Significantly reduces intersection detection computation while maintaining fine-grained culling capabilities. This invention further sets up sub-tile meshes within the adaptive coarse tiles, replacing the two-dimensional intersection detection of each sub-tile with a one-dimensional scan along the vertical and horizontal shared mesh lines. This reduces the complexity of intersection detection from being quadratically related to the number of sub-tiles to being linearly related to the number of mesh lines, significantly reducing the amount of GPU arithmetic computation without affecting the accuracy of fine-grained culling.

[0036] 3. Improve rasterization efficiency through bitmask encoding and hardware-accelerated traversal. This invention compresses fine-grained intersection detection results into a bitmask representation, enabling the rasterization stage to quickly traverse effective primitives or effective sub-tiles using GPU hardware bit manipulation instructions. This skips a large number of invalid alpha mixing calculations and probability density evaluations, effectively reducing thread bundle divergence and invalid arithmetic calculations, and improving GPU resource utilization efficiency.

[0037] 4. Significantly improves rendering speed while maintaining visual quality. This invention only changes the binning granularity, culling strategy, and traversal method of primitives, without altering the mathematical expression, projection formula, or color composition rules of the primitives. Therefore, while maintaining the original scene's visual quality essentially unchanged, it can significantly improve the rendering frame rate at ultra-high resolutions. Experimental results show that at 8K resolution, the solution of this invention can significantly improve rendering speed, providing the necessary computational margin for 4K / 8K virtual reality and augmented reality applications. Attached Figure Description

[0038] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0039] Figure 1 This is a flowchart illustrating a primitive binning and culling method for ultra-high resolution rendering as described in this invention.

[0040] Figure 2 This is a schematic diagram illustrating the growth of the fixed tile overlap factor according to the present invention;

[0041] Figure 3 This is a schematic diagram illustrating the adaptive coarse tile maintaining NDC scale according to the present invention;

[0042] Figure 4 This is a schematic diagram of the one-dimensional scanning removal of sub-tiles according to the present invention;

[0043] Figure 5This is a schematic diagram of bitmask encoding and rasterization traversal as described in this invention;

[0044] Figure 6 This is a schematic diagram of the primitive binning and culling system for ultra-high resolution rendering described in this invention. Detailed Implementation

[0045] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0046] Example 1

[0047] like Figure 1 As shown, a primitive binning and culling method for ultra-high resolution rendering includes:

[0048] Step S1: Obtain the target resolution, determine a scaling factor based on the ratio of the target resolution to the baseline resolution, and scale the baseline tile size according to the scaling factor to generate an adaptive coarse tile grid on the target image plane; Step S1 specifically includes the following steps:

[0049] Step S11: Obtain rendering task parameters;

[0050] Obtain the primitive set, camera parameters, target image width and height, baseline resolution, baseline tile size, and sub-tile size from the scene to be rendered. In this embodiment, the baseline resolution is set to 1080p, and the baseline tile size (denoted as...) is... Set the size to 16×16 pixels, and set the size of the sub-tiles to 16×16 pixels.

[0051] Each primitive in the primitive set includes at least spatial location, scale or covariance, opacity, color parameters, and geometric parameters for projection.

[0052] Step S12: Determine the resolution scaling factor;

[0053] The linear scaling factor k is determined based on the target image width and the baseline image width. Specifically, k is the ratio of the target image width to the baseline image width.

[0054] As another alternative implementation, k can also be the ratio of the target image height to the baseline image height, the average of the two ratios, the maximum of the two ratios, or a scale value normalized according to the display field of view, pixel density, or number of pixels per degree.

[0055] Step S13: Generate adaptive coarse tile mesh;

[0056] according to Calculate the target coarse tile size and generate a coarse tile mesh on the target image plane.

[0057] Preferably, for Perform integer rounding, thread block alignment, or preset upper and lower bound pruning to adapt the target coarse tile size to the GPU thread block, shared memory, and sort buffer configuration.

[0058] Therefore, the scale of the target coarse tile in the normalized equipment coordinate space is basically consistent with that of the baseline tile.

[0059] The theoretical derivation is as follows: Let the tile size be S, the projected area of ​​the primitive on the pixel screen space be a, and the ratio of the primitive bounding box area to its effective area be ρ. Then the primitive overlap factor can be approximately expressed as:

[0060]

[0061] When the linear scaling factor of the target resolution relative to the baseline resolution is At that time, the projected area of ​​the primitive approximately becomes This invention allows for the adjustment of coarse tile dimensions. ,but:

[0062]

[0063] This indicates that adaptive coarse tiles can keep the overlap factor O constant and not increase with increasing resolution.

[0064] Therefore, as Figure 2 As shown, the overlap factor increases sharply with increasing resolution under the fixed tile scheme.

[0065] like Figure 3 As shown, the present invention increases the size of the coarse tile with increasing resolution, so that the coarse tile maintains an approximately constant size in the normalized device coordinate space.

[0066] Step S2: Project the primitives onto the screen space, and determine the candidate coarse tiles corresponding to each primitive based on the screen space bounding area of ​​each primitive and the overlap relationship between each coarse tile.

[0067] Step S2 specifically includes the following steps:

[0068] Step S21: Perform view transformation, projection transformation and screen space parameter calculation for each graphic element to obtain the two-dimensional center, depth, two-dimensional covariance or conic parameter and screen space bounding range of the graphic element.

[0069] Step S22: Based on the overlap between the screen space bounding range and the coarse tile grid, determine the set of candidate coarse tiles that the primitive may cover.

[0070] Step S3: Establish a sub-tile mesh defined by vertical and horizontal shared grid lines within each of the candidate coarse tiles;

[0071] For each primitive and candidate coarse tile, a sub-tile mesh defined by vertical and horizontal shared grid lines is created within the candidate coarse tile.

[0072] In this embodiment, the sub-tiles use a fixed pixel size of 16×16 pixels.

[0073] As an alternative implementation, the sub-tiles can also use a fixed number of rows and columns M_x × M_y, or be adaptively determined based on the primitive size, thread block configuration, or display area importance.

[0074] Step S4: Perform fine-grained intersection detection within each of the candidate coarse tiles: mark the sub-tiles where the primitive center is located, and, based on the one-dimensional scan results of each of the vertical shared grid lines and each of the horizontal shared grid lines, batch mark the intersecting continuous sub-tile intervals;

[0075] Step S4 specifically includes the following steps:

[0076] Step S41: The center contains the detection.

[0077] Calculate the local coordinates of the two-dimensional center of the primitive in screen space relative to the current coarse tile and its sub-tile grid; if the two-dimensional center is located within the current coarse tile or the current sub-tile grid, then mark the sub-tile containing the two-dimensional center as a valid intersecting sub-tile.

[0078] Step S42: Perform a one-dimensional scan culling along the vertical shared grid line.

[0079] Traverse the vertical shared grid lines in the sub-tile mesh. For the same vertical grid line shared by adjacent sub-tiles, perform the primitive outline intersection solution only once. Substitute the lateral offset of the vertical grid line relative to the primitive center into the quadratic outline equation of the primitive, determine whether there is an intersection according to the discriminant, and if there is an intersection, map the obtained vertical continuous interval to the sub-tile row interval and mark the corresponding sub-tile once.

[0080] Step S43: Perform a one-dimensional scan removal along the horizontal shared grid line.

[0081] Traverse the horizontal shared grid lines in the sub-tile grid. For the same horizontal grid line shared by adjacent sub-tiles, perform the primitive outline intersection solution only once. Substitute the vertical offset of the horizontal grid line relative to the primitive center into the quadratic outline equation of the primitive, determine whether there is an intersection according to the discriminant, and if there is an intersection, map the obtained horizontal continuous interval to the sub-tile column interval and mark the corresponding sub-tile once.

[0082] The projected primitive outline adopts a quadratic form

[0083]

[0084] It means that, among them and These represent the offset of the current query position relative to the center of the element. , , Derived from two-dimensional inverse covariance, conic parameters, or equivalent primitive contour parameters. The density cutoff threshold is defined as all conditions that satisfy the following conditions. The tiles all fall inside the primitives.

[0085] Fixed during vertical scanning Direction offset , get about The quadratic equation of

[0086]

[0087] Calculate the discriminant ,like This indicates that the vertical line is completely outside the primitive outline, and the entire row of sub-tiles does not intersect; therefore, it is skipped. This indicates that the vertical line passes through the primitive outline. Then, solve the two roots of the quadratic equation in one variable. Based on the continuous interval determined by the roots, map it to the sub-tile column interval, and mark all sub-tiles in the column interval as valid intersections in batches.

[0088] Preferably, the two roots obtained by solving are rounded up and down respectively to obtain the index range of the continuous sub-tiles covered, and all sub-tiles within this range are marked as valid intersections at once.

[0089] The intersecting relationship between grid lines and primitive outlines is determined by checking if the discriminant is non-negative, and continuous intervals are defined using two roots, thus avoiding the need to perform a separate two-dimensional intersection check for each sub-tile. For example... Figure 4 As shown, the removal of sub-tiles within the coarse tile is achieved by scanning the vertical and horizontal shared grid lines. For a sub-tile grid with dimensions of M×M, the time complexity of traditional two-dimensional tile-by-tile detection is O(M²), while the time complexity of one-dimensional shared grid line search in this invention is O(M).

[0090] Step S5: Generate a bitmask based on the marking results of the fine-grained intersection detection. Each bit in the bitmask is used to indicate whether the corresponding sub-tile or corresponding primitive reference is valid.

[0091] The set of valid intersecting sub-tiles obtained in step S4 is encoded into one or more machine bitmasks. Each bit corresponds to a sub-tile, a primitive reference, or a valid relation in a primitive batch.

[0092] In this embodiment, a 32-bit mask is used for each batch of 32 candidate primitives.

[0093] As an alternative implementation, a 64-bit mask is used for each batch of 64 candidate primitives; when the number of sub-tiles exceeds the number of bits in a single machine word, the effective intersection relationship is encoded into a multi-word mask, in which each machine word corresponds to a subset of the sub-tile grid.

[0094] Subsequent processing steps:

[0095] Step S6: Generate binning key values ​​and perform sorting.

[0096] Key-value pairs are generated based on valid coarse tiles or valid sub-tiles. The key in each key-value pair includes a tile identifier and a primitive depth, and the value includes a primitive index and the bitmask. Radix sort is then performed on the GPU to arrange primitive references within the same tile consecutively and in depth-ordered fashion.

[0097] As an alternative implementation, the sorting can also be performed on a CPU or heterogeneous processor, using merge sort or equivalent sort.

[0098] Step S7: Perform rasterization fast traversal.

[0099] During the rendering phase, for each tile, its continuous primitive range and corresponding bitmask are read. The valid bits in the bitmask are traversed using hardware bit manipulation primitives. These primitives include instructions for finding the first set bit (e.g., __ffs()), instructions for counting the number of set bits (e.g., __popc()), and instructions for conditional broadcasting within a thread bundle (e.g., __ballot_sync()). This avoids bit-by-bit judgment and branch jumps in the mask, reduces thread bundle divergence and invalid arithmetic calculations, skips non-intersecting sub-tiles or non-contributing primitive references, and reduces invalid alpha blending and invalid probability density calculations.

[0100] like Figure 5 As shown, the fine-grained rejection result is encoded as a bitmask, and the valid bits are quickly traversed using hardware bit manipulation instructions during the rasterization stage.

[0101] Step S8: Output the rendering result.

[0102] Accumulate color, opacity, and depth information according to the forward-to-backward blending rules, and output a target resolution image.

[0103] As alternative implementation methods, a backward-to-forward blending rule can also be used, or a stereoscopic display image can be output as an intermediate result for use in subsequent rendering pipelines.

[0104] Example 2

[0105] The difference between this embodiment and Embodiment 1 lies in the specific method of determining the size of the coarse tile.

[0106] In the 3DGS renderer, a 16×16 pixel tile at 1080p resolution is used as the baseline. When the user requests 4K output, the coarse tile size is adjusted to 32×32 pixels; when the user requests 8K output, the coarse tile size is adjusted to 64×64 pixels. Within each coarse tile, fine-grained culling is still performed at a sub-tile granularity of 16×16 pixels to balance duplicate reference suppression and local culling accuracy.

[0107] In this embodiment, the target coarse tile size is obtained by rounding the result of the calculation S_target = k × S_base to the nearest integer, so that the coarse tile size is exactly 32 pixels in 4K and exactly 64 pixels in 8K, which facilitates GPU thread block alignment and sorting buffer configuration.

[0108] Example 3

[0109] The difference between this embodiment and Embodiment 1 lies in the different processing flow when the graphic element covers multiple coarse tiles.

[0110] For primitives that cover multiple coarse tiles after projection, the system first determines candidate coarse tiles based on the screen space bounding range, and then performs a shared grid line scan in each candidate coarse tile. If only a few sub-tiles in a certain coarse tile intersect with the elliptical contour, the bitmask only marks these valid sub-tiles; after the rasterization thread reads the bitmask, it only performs the contribution calculation of the primitive on the pixels in the corresponding sub-tiles, thereby avoiding repeated processing of invalid sub-tile regions of the same primitive in different tiles.

[0111] Example 4

[0112] The difference between this embodiment and Embodiment 1 lies in the specific method of partitioning the GPU's parallel execution.

[0113] Within the GPU kernel, each warp or block processes a batch of candidate primitives within a tile. The system compresses the fine-grained intersection results into a 32-bit or 64-bit mask, using __ffs() or equivalent instructions to obtain the positions of the valid bits one by one. Compared to performing 2D intersection detection sub-tile by sub-tile, this method reduces redundant solving and thread divergence, making it particularly suitable for ultra-high resolution scenarios with a large number of candidate primitives (e.g., more than 32) within each tile.

[0114] Example 5

[0115] The difference between this embodiment and Embodiment 1 is that the selection and applicable scope of several parameters have been expanded.

[0116] The resolution scaling factor can also be determined based on the image diagonal length, display device pixel density, foveation area, dynamic resolution scaling ratio, or multi-view display configuration; the coarse tile size can be obtained by integer multiple alignment, thread block alignment, cache line alignment, or empirical lookup table method.

[0117] Sub-tiles can be adaptively divided based on the size of the coarse tile, the projected area of ​​the primitive, or the GPU thread block size and shared memory capacity. For boundary regions, non-uniform sub-tiles can also be allowed, or edge sub-tiles can be cropped to the actual image range.

[0118] Fine-grained intersection culling can be achieved using conical parameter thresholding, ellipse-line segment intersection, bounding box-ellipse intersection, conservative rasterization, or lookup table approximation methods. The bitmask can be 8-bit, 16-bit, 32-bit, 64-bit, 128-bit, or multi-word masks, and can also be replaced with compressed index lists, prefix sum encoding, sparse visibility tables, or block Boolean tables.

[0119] This method is not limited to 3D Gaussian Splatting, but can also be used for 2D Gaussian splatting, surfel rendering, voxel projection, particle rendering, elliptical primitive rasterization, and other primitive rendering tasks with local support regions after projection.

[0120] The remaining steps in this embodiment are the same as in Embodiment 1, and will not be repeated here.

[0121] Comparative example:

[0122] The traditional 3DGS rendering method with fixed 16×16 pixel tiles is used as a comparison.

[0123] At 1080p resolution, the rendering efficiency of the traditional method and the embodiment of the present invention is basically equivalent. However, at 4K and 8K resolutions, the binning time of the traditional method increases from about 40% at 1080p to about 64% at 8K, and the overlap factor increases from about 2.6 to about 9.6; while in the embodiment of the present invention, the overlap factor remains stable because the coarse tile size increases linearly with resolution. As shown in Table 1, based on a single NVIDIA RTX 4090 GPU computing platform, the adaptive coarse tile binning strategy and bitmask encoding scheme proposed in this invention were verified on two publicly available datasets, Mip-NeRF360 and Mill 19, respectively. The rendering speed (Frames Per Second) and the speedup compared to the traditional scheme were recorded at 4K / 8K resolutions.

[0124] Table 1. Acceleration effect of the proposed method at 4K / 8K rendering resolution.

[0125]

[0126] As shown in Table 1, in the 8K rendering task of the Mip-NeRF 360 dataset, the adaptive binning strategy of this invention improves the rendering speed from 149 FPS to 188 FPS, a speedup of 1.263 times. Further combining bitmask encoding and hardware traversal, the rendering speed is further improved to 244 FPS, a speedup of 1.636 times. Consistent performance improvements are also achieved on the Mill 19 dataset, with a maximum speedup of 2.412 times at 8K. Experimental results demonstrate that the proposed method achieves significant speedup effects in various scenarios.

[0127] Example 6

[0128] like Figure 6 As shown, a primitive binning and culling system for ultra-high resolution rendering includes:

[0129] The parameter acquisition module M1 is used to acquire rendering task parameters, which include at least the target resolution and the baseline tile size.

[0130] Scaling factor determination module M2 is used to determine the scaling factor based on the ratio of the target resolution to the baseline resolution;

[0131] The coarse tile mesh generation module M3 is used to scale the baseline tile size according to the scaling factor in order to generate an adaptive coarse tile mesh on the target image plane.

[0132] The projection module M4 is used to project the primitives onto the screen space and determine the candidate coarse tiles corresponding to each primitive based on the screen space enclosure range of each primitive and the overlap relationship between each coarse tile.

[0133] The sub-tile mesh creation module M5 is used to create a sub-tile mesh defined by vertical shared mesh lines and horizontal shared mesh lines within each of the candidate coarse tiles;

[0134] The intersection detection module M6 is used to perform fine-grained intersection detection within each of the candidate coarse tiles, including: marking the sub-tile where the primitive center is located, and, based on the one-dimensional scan results of each of the vertical shared grid lines and each of the horizontal shared grid lines, batch marking the intersecting continuous sub-tile intervals;

[0135] Bitmask generation module M7 is used to generate a bitmask based on the marking results of the fine-grained intersection detection. Each bit in the bitmask is used to indicate whether the corresponding sub-tile or corresponding primitive reference is valid.

[0136] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A primitive binning and culling method for ultra-high resolution rendering, characterized in that, include: Obtain the target resolution and determine a scaling factor based on the ratio of the target resolution to the baseline resolution. Scale the baseline tile size according to the scaling factor to generate an adaptive coarse tile grid on the target image plane. The primitives are projected onto the screen space, and the candidate coarse tiles corresponding to each primitive are determined based on the screen space bounding area of ​​each primitive and the overlap relationship between each coarse tile. Within each of the candidate coarse tiles, a sub-tile grid is established, defined by vertical and horizontal shared grid lines; Perform fine-grained intersection detection within each of the candidate coarse tiles: mark the sub-tiles where the primitive center is located, and, based on the one-dimensional scan results of each of the vertical shared grid lines and each of the horizontal shared grid lines, batch mark the intersecting continuous sub-tile intervals; A bitmask is generated based on the marking results of the fine-grained intersection detection, where each bit in the bitmask is used to indicate whether the corresponding sub-tile or corresponding primitive reference is valid.

2. The primitive binning and culling method for ultra-high resolution rendering according to claim 1, characterized in that, The scaling factor is determined based on the ratio of the target image width to the baseline image width, the ratio of the target image height to the baseline image height, the average of the two ratios, the maximum of the two ratios, or based on the scale value after normalization of the display field of view.

3. The primitive binning and culling method for ultra-high resolution rendering according to claim 1, characterized in that, The target coarse tile size is obtained by rounding the product of the scaling factor and the baseline tile size, aligning it according to the GPU thread block size, or cropping it according to preset upper and lower limits, so that the target coarse tile size is adapted to the GPU thread block configuration, shared memory capacity, or sorting buffer size.

4. The primitive binning and culling method for ultra-high resolution rendering according to claim 1, characterized in that, The sub-tile mesh is established in any of the following ways: using sub-tiles with a fixed pixel size; using sub-tiles with a fixed number of rows and columns; adaptively dividing according to the size of the coarse tile; adaptively dividing according to the projected area of ​​the primitive; or dividing according to the GPU thread block size and shared memory capacity.

5. The primitive binning and culling method for ultra-high resolution rendering according to claim 1, characterized in that, The process of marking the sub-tile containing the center of the primitive is as follows: calculate the local coordinates of the two-dimensional center of the primitive relative to the current coarse tile and its sub-tile grid. If the two-dimensional center is located within the current coarse tile or the current sub-tile grid, then the sub-tile containing the two-dimensional center is marked as a valid intersecting sub-tile.

6. The primitive binning and culling method for ultra-high resolution rendering according to claim 1, characterized in that, The step of performing primitive contour intersection solving only once for each shared grid line specifically includes: Substitute the current shared grid line position offset into the primitive's contour equation to obtain a quadratic equation in another coordinate direction, and calculate the discriminant of this quadratic equation. If the discriminant is less than zero, it is determined that the current shared grid line does not intersect with the primitive outline, and the entire row or column of sub-tiles corresponding to the current shared grid line is skipped. If the discriminant is greater than or equal to zero, then solve for the root of the quadratic equation in one variable. The continuous interval determined by the root is mapped to the sub-tile row interval or column interval, and all sub-tiles in the row interval or column interval are batch-marked as valid intersections.

7. The primitive binning and culling method for ultra-high resolution rendering according to claim 6, characterized in that, The mapping of the continuous interval determined by the root to the sub-tile row interval or column interval is specifically as follows: the two roots obtained by solving are rounded up and down respectively to obtain the index range of the covered continuous sub-tiles, and all sub-tiles in this range are marked as valid intersections at once.

8. The primitive binning and culling method for ultra-high resolution rendering according to claim 1, characterized in that, When the number of sub-tiles exceeds the number of bits in a single machine word, the effective intersection relationship is encoded into a multi-bit mask, where each machine word in the multi-bit mask corresponds to a subset of the sub-tile grid.

9. The primitive binning and culling method for ultra-high resolution rendering according to claim 1, characterized in that, The traversal of the valid bits in the bitmask is implemented through hardware bit operation primitives, which include: instructions for finding the first set bit, instructions for counting the number of set bits, and instructions for conditional broadcasting within a thread bundle to skip disjoint sub-tiles or non-contributing primitive references.

10. A primitive binning and culling system for ultra-high resolution rendering, characterized in that, The primitive binning and culling method for ultra-high resolution rendering based on any one of claims 1 to 9 includes: A parameter acquisition module is used to acquire rendering task parameters, which include at least the target resolution and the baseline tile size. A scaling factor determination module is used to determine a scaling factor based on the ratio of the target resolution to the baseline resolution. A coarse tile mesh generation module is used to scale the baseline tile size according to the scaling factor in order to generate an adaptive coarse tile mesh on the target image plane. The projection module is used to project primitives onto the screen space and determine the candidate coarse tiles corresponding to each primitive based on the screen space enclosure range of each primitive and the overlap relationship between each coarse tile. The sub-tile mesh creation module is used to create a sub-tile mesh defined by vertical shared mesh lines and horizontal shared mesh lines within each of the candidate coarse tiles; The intersection detection module is used to perform fine-grained intersection detection within each of the candidate coarse tiles, including: marking the sub-tile where the primitive center is located, and, based on the one-dimensional scan results of each of the vertical shared grid lines and each of the horizontal shared grid lines, batch marking the intersecting continuous sub-tile intervals; The bitmask generation module is used to generate a bitmask based on the marking results of the fine-grained intersection detection. Each bit in the bitmask is used to indicate whether the corresponding sub-tile or corresponding primitive reference is valid.

Images