Method and device for processing crack problem of 3D GS scene block rendering, equipment and medium

Abstract

The invention provides a processing method and device for a 3D GS scene block rendering crack problem, equipment and a medium, and the method comprises the steps: in a current frame rendering process, a GPU is rendering a previous frame of data in a second buffer area; meanwhile, the CPU performs data preprocessing on a to-be-rendered scene node of a current frame through a multi-thread assembly line, copies a 3D Gaussian primitive contained in a visible node to a first buffer area in an idle state, and transmits the 3D Gaussian primitive to a GPU video memory in a framing manner; and after all the data in the first buffer area are transmitted, switching a rendering data source of the GPU to the first buffer area in the main thread, globally sorting all the 3D Gaussian primitives to obtain a global drawing sequence, and sequentially drawing all the 3D Gaussian primitives of the current frame. The problem of cracks generated at the interface between the nodes during large-scale scene block rendering is effectively eliminated, the rendering quality and the visual effect are remarkably improved, meanwhile, dependence on hardware performance is reduced, and the overall rendering speed is increased.

Description

Technical Field

[0001] This application relates to the technical field of real-time 3D rendering, and in particular to methods, apparatus, equipment and media for dealing with the problem of cracks in 3DGS scene block rendering. Background Technology

[0002] In recent years, 3DGaussian Splatting (3DGS), as an emerging implicit scene representation and real-time rendering paradigm, has become the mainstream technology for large-scene 3D reconstruction due to its advantages such as modeling geometry and appearance with ellipsoidal Gaussian Primitives, supporting high-fidelity detail reconstruction, and rendering efficiency far superior to Neural Radiation Field (NeRF). Therefore, the industry generally adopts a spatial chunking strategy, dividing the entire scene into multiple independent nodes using octrees, quadtrees, or regular grids. Each node encapsulates all its internal Gaussian Primitives and their bounding boxes, and uses frustum culling to achieve on-demand loading and local rendering. However, this chunking mechanism causes a significant visual seams problem in 3DGS rendering, specifically manifested as obvious color level jumps, depth misalignments, or abnormal semi-transparent overlaps at the chunk boundaries, severely disrupting scene continuity. Analysis revealed that the problem stems from three interdependent technical contradictions: 1. Inconsistent rendering order between nodes: Different chunk nodes are independently sorted locally on the CPU (e.g., by node center depth), leading to conflicts in the rendering order of Gaussian primitives in the boundary region of adjacent nodes, causing alpha blending failure and Z-fighting; 2. Lack of a global reference system for intra-node sorting: Each node only sorts its internal primitives, without establishing a unified depth coordinate system across nodes, resulting in primitives of the same depth layer being scattered across different nodes and different rendering batches, failing to guarantee visually correct foreground and background occlusion relationships; 3. Dynamic changes in viewpoint exacerbate sorting mismatch: When the camera moves or rotates rapidly, the set of nodes within the view frustum dynamically increases or decreases, chunk boundaries frequently cross object surfaces, and local sorting results jump with each frame, causing flickering and jittering at crack positions, significantly increasing subjective visual interference. In summary, how to maintain the memory and bandwidth advantages brought by the chunking mechanism while completely eliminating interface cracks caused by local sorting under limited hardware resource constraints has become a core bottleneck problem for the large-scale application of 3DGS technology. Summary of the Invention

[0003] In view of this, the purpose of this application is to provide a method, apparatus, device and medium for handling the crack problem in 3DGS scene block rendering, and to construct a "double buffer management - sub-thread pipeline preprocessing - global sorting - rendering" to eliminate the interface crack problem between nodes when rendering large-scale 3D Gaussian splash blocks, improve rendering quality and visual effects, reduce hardware bandwidth requirements and improve rendering performance.

[0004] This application provides a method for handling the crack problem in 3DGS scene block rendering, the method including: During the rendering initialization phase of a 3DGS scene, a first buffer and a second buffer are set up; each buffer is used to hold a maximum of several 3D high-order primitives. During the current frame rendering process, the GPU is rendering the previous frame data in the second buffer. At the same time, the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copies the 3D Gaussian primitives contained in the visible scene nodes to be rendered to the first buffer which is in an idle state, and transmits them to the GPU memory frame by frame. After all the data in the first buffer has been transferred, the GPU's rendering data source is switched to the first buffer in the main thread. All 3D Homo spherical elements in the first buffer are globally sorted to construct a unified global rendering sequence, and all 3D Homo spherical elements of the current frame are rendered in sequence.

[0005] In one possible implementation, the CPU preprocesses the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copies the 3D Gaussian primitives contained in the visible scene nodes to an idle first buffer, and transmits them to the GPU memory frame by frame, including: Based on the first sub-thread, the intersection test between the bounding box of the scene node to be rendered and the camera view frustum is performed to determine the visible scene node to be rendered. Based on the second sub-thread, the 3D Gaussian elements in the visible scene nodes to be rendered are stored in the first buffer; Based on the main thread, the 3D Gaussian elements in the first buffer are transferred to the GPU memory in a fixed amount of data in a frame-by-frame manner.

[0006] In one possible implementation, after performing an intersection test between the bounding box of the scene node to be rendered and the camera frustum based on the first sub-thread to determine the visible scene nodes to be rendered, the processing method further includes: Determine the total number of 3D Gaussian primitives contained in all visible scene nodes to be rendered; Determine whether the total number is greater than the maximum capacity. If the number is greater than the maximum number, the number of 3D Homo sapiens contained in the visible LOD level nodes to be rendered is reduced by adjusting the LOD level of the nodes until the total number is less than or equal to the maximum number that can be accommodated.

[0007] In one possible implementation, the maximum accommodating number is determined by the following steps: Real-time collection of historical rendering time, historical average CPU load rate, historical average GPU load rate, and the deviation between the current frame's actual frame rate and the target frame rate; The maximum number of frames that can be accommodated in the current frame is determined by processing the historical rendering time, historical average CPU load rate, historical average GPU load rate, and deviation value using a multidimensional mapping function.

[0008] In one possible implementation, while sequentially rendering all 3D Gaussian elements of the current frame, the processing method further includes: The CPU performs the data preprocessing through the multi-threaded pipeline. During the data preprocessing, the idle buffer used is the second buffer that is not currently used by the GPU. The processed data results are transmitted to the GPU memory in frames. After the transmission is completed, the GPU rendering data source is switched to realize the alternating use of the first buffer and the second buffer.

[0009] In one possible implementation, the sub-threads in the multi-threaded pipeline synchronize their data readiness states through a lock-free circular queue or memory barrier mechanism to ensure data integrity and thread safety during buffer switching.

[0010] In one possible implementation, the first buffer and the second buffer are both contiguous memory blocks and are mapped in the GPU memory as two independent unified buffer objects or shader storage buffer objects, respectively, for passing the position, rotation, scaling, opacity and spherical harmonic parameters of 3D Gaussian primitives to the GPU rendering pipeline.

[0011] This application embodiment also provides a device for processing crack problems in 3DGS scene block rendering, the device comprising: The initialization module is used to set up the first buffer and the second buffer during the rendering initialization phase of the 3DGS scene; each buffer is used to hold a maximum of several 3D hexagonal elements. The data processing module is used to preprocess the scene nodes to be rendered in the current frame during the rendering process of the current frame. While the GPU is rendering the data of the previous frame in the second buffer, the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline. The 3D Gaussian primitives contained in the visible scene nodes to be rendered are copied to the first buffer which is in an idle state and then transmitted to the GPU memory in frames. The rendering module is used to switch the GPU's rendering data source to the first buffer in the main thread after all the data in the first buffer has been transferred. It then performs global sorting on all 3D hexagonal primitives in the first buffer, constructs a unified global drawing sequence, and draws all 3D hexagonal primitives of the current frame in sequence.

[0012] This application embodiment also provides an electronic device, including: a processor, a memory, and a bus. The memory stores machine-readable instructions executable by the processor. When the electronic device is running, the processor communicates with the memory via the bus. When the machine-readable instructions are executed by the processor, the steps of the method for handling the crack problem in 3DGS scene block rendering as described above are performed.

[0013] This application also provides a computer-readable storage medium storing a computer program, which, when run by a processor, executes the steps of the method for handling the crack problem in 3DGS scene block rendering as described above.

[0014] This application provides a method, apparatus, device, and medium for handling the 3DGS scene block rendering crack problem. The method includes: setting a first buffer and a second buffer during the 3DGS scene rendering initialization phase; wherein each buffer is used to hold a maximum of several 3D Gaussian primitives; during the rendering of the current frame, the GPU is rendering the previous frame data in the second buffer, while the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copying the 3D Gaussian primitives contained in the visible scene nodes to be rendered to the first buffer which is in an idle state, and transmitting them to the GPU memory frame by frame; after all the data in the first buffer has been transmitted, the GPU's rendering data source is switched to the first buffer in the main thread, all 3D Gaussian primitives in the first buffer are globally sorted, a unified global drawing sequence is constructed, and all 3D Gaussian primitives of the current frame are drawn sequentially. This method, employing a "dual-buffer management—sub-thread pipeline preprocessing—global sorting—rendering" approach, eliminates the node interface crack problem during large-scene 3D Gaussian splash block rendering, improves rendering quality and visual effects, reduces hardware bandwidth requirements, and improves rendering performance.

[0015] To make the above-mentioned objectives, features and advantages of this application more apparent and understandable, preferred embodiments are described below in detail with reference to the accompanying drawings. Attached Figure Description

[0016] To more clearly illustrate the technical solutions of the embodiments of this application, the accompanying drawings used in the embodiments will be briefly introduced below. It should be understood that the following drawings only show some embodiments of this application and should not be regarded as a limitation of the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0017] Figure 1 A flowchart illustrating a method for handling crack problems in 3DGS scene block rendering provided in an embodiment of this application; Figure 2 This is one of the structural schematic diagrams of a device for processing cracks in 3DGS scene block rendering provided in an embodiment of this application; Figure 3 A second schematic diagram of a device for processing cracks in 3DGS scene block rendering provided in an embodiment of this application; Figure 4 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0018] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. The components of the embodiments of this application described and shown in the accompanying drawings can generally be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of this application provided in the accompanying drawings is not intended to limit the scope of the claimed application, but merely represents selected embodiments of this application. Based on the embodiments of this application, every other embodiment obtained by those skilled in the art without inventive effort falls within the scope of protection of this application.

[0019] First, the applicable application scenarios of this application will be introduced. This application can be applied to the technical field of real-time 3D rendering.

[0020] Research has revealed that the problems with the chunking mechanism stem from three interdependent technical contradictions: 1. Inconsistent rendering order between nodes: Different chunk nodes are independently sorted locally by the CPU (e.g., by node center depth), leading to conflicts in the rendering order of Gaussian primitives in the boundary region of adjacent nodes, causing alpha blending failure and Z-fighting; 2. Lack of a global reference system for intra-node sorting: Each node only sorts its internal primitives, without establishing a unified depth coordinate system across nodes, resulting in primitives of the same depth layer being scattered across different nodes and different rendering batches, failing to guarantee visually correct foreground and background occlusion relationships; 3. Dynamic changes in viewpoint exacerbate sorting mismatch: When the camera moves or rotates rapidly, the set of nodes within the view frustum dynamically increases or decreases, chunk boundaries frequently cross object surfaces, and local sorting results jump with frames, causing flickering and jittering at crack positions, significantly increasing subjective visual interference. In summary, how to maintain the memory and bandwidth advantages of the chunking mechanism while completely eliminating interface cracks caused by local sorting under limited hardware resource constraints has become a core bottleneck problem for the large-scale application of 3DGS technology.

[0021] Based on this, the embodiments of this application provide a method for handling the crack problem in 3DGS scene block rendering. The method constructs a "double buffer management - sub-thread pipeline preprocessing - global sorting - rendering" to eliminate the interface crack problem between nodes when rendering large-scale 3D Gaussian splash blocks, thereby improving rendering quality and visual effects, reducing hardware bandwidth requirements, and improving rendering performance.

[0022] Please see Figure 1 , Figure 1 This is a flowchart illustrating a method for handling cracks in 3DGS scene block rendering, as provided in an embodiment of this application. Figure 1 As shown in the embodiments of this application, the processing method includes: S101: During the rendering initialization phase of a 3DGS scene, set up a first buffer and a second buffer; each buffer is used to hold a maximum of several 3D Gaussian primitives.

[0023] Here, both the first and second buffers are contiguous linear video memory regions, pre-allocated in the GPU video memory by the GPU driver through an interface; each buffer is logically divided into fixed-size primitive slots, each slot is used to store the complete attribute data of a 3D Gaussian primitive, including but not limited to: three-dimensional spatial position coordinates (x, y, z); 3×3 covariance matrix (used to characterize the shape and rotation of the ellipsoid); opacity (α) and RGB color values, and other attributes.

[0024] It should be noted that the maximum number of elements that can be accommodated is written into the RenderingContext structure during initialization and serves as a hard upper limit threshold for node selection, LOD pruning, data copying, and transmission in all subsequent frame processing flows. This threshold cannot be dynamically exceeded.

[0025] In one possible implementation, the maximum accommodating number is determined by the following steps: A: Real-time collection of historical rendering time, historical average CPU load rate, historical average GPU load rate, and the deviation between the current frame's actual frame rate and the target frame rate.

[0026] Here, the historical rendering time, historical average CPU load rate, historical average GPU load rate, and the deviation between the current frame's actual frame rate and the target frame rate are collected in real time.

[0027] B: Based on the multidimensional mapping function, the historical rendering time, the historical average CPU load rate, the historical average GPU load rate, and the deviation value are processed to determine the maximum number of frames that can be accommodated in the current frame.

[0028] Here, the maximum number of frames that can be accommodated in the current frame (Mopt) is calculated in real time using historical frame rendering time, historical CPU load rate, historical GPU load rate, and deviation value. Mopt=func(historical frame rendering time, CPU load, GPU load, FPS deviation); Among them, func ( ) is a multidimensional mapping function that controls the total number of 3D Gaussian primitives rendered per frame by dynamically adjusting the LOD level, thereby achieving automatic frame rate adjustment and ensuring frame rate stability.

[0029] In one possible implementation, the first buffer and the second buffer are both contiguous memory blocks and are mapped in the GPU memory as two independent unified buffer objects or shader storage buffer objects, respectively, for passing the position, rotation, scaling, opacity and spherical harmonic parameters of 3D Gaussian primitives to the GPU rendering pipeline.

[0030] Here, to ensure the atomicity and zero-copy efficiency of the double-buffer switching, the first and second buffers adopt an aligned allocation strategy in GPU memory: their starting addresses are aligned to 4KB page boundaries, and their physical addresses do not overlap. After initialization, the buffer handles are bound to the Uniform Buffer Object (UBO) or Shader Storage Buffer Object (SSBO) of the rendering pipeline, allowing the GPU shader to directly access them during the rendering phase. This double-buffer structure does not participate in any real-time computation; it only serves as a deterministic data exchange intermediary between CPU-side data preprocessing and GPU-side rendering execution. Its very existence achieves spatiotemporal decoupling between data production (CPU sub-threads) and data consumption (GPU rendering pipeline), providing underlying memory architecture support for subsequent global sorting and crack elimination.

[0031] S102: During the current frame rendering process, the GPU is rendering the previous frame data in the second buffer. At the same time, the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copies the 3DGS primitives and 3D Gaussian primitives contained in the visible scene nodes to be rendered to the first buffer which is in an idle state, and transmits them to the GPU memory in frames.

[0032] In this step, while the current frame is being rendered, the GPU is rendering the data of the previous frame in the second buffer. The CPU uses a multi-threaded pipeline to preprocess the data of the scene nodes to be rendered in the current frame to determine the visible scene nodes to be rendered. The 3D Gaussian primitives contained in the visible scene nodes to be rendered are copied to the first buffer, which is currently in an idle state, and then transferred to the GPU memory.

[0033] Here, during rendering, a view frustum is clipped for each frame to filter out all visible nodes Ns within the view frustum. It is ensured that the total number of all 3D Gaussian primitives of all visible nodes Ns does not exceed the maximum number M that the buffer can hold. During the filtering process, LOD can be dynamically switched to ensure that Ns meets the requirements.

[0034] In one possible implementation, the sub-threads in the multi-threaded pipeline synchronize their data readiness states through a lock-free circular queue or memory barrier mechanism to ensure data integrity and thread safety during buffer switching.

[0035] In one possible implementation, the CPU preprocesses the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copies the 3D Gaussian primitives contained in the visible scene nodes to be rendered to a first buffer that is currently idle, and then transfers them to the GPU memory, including: (1): Based on the first sub-thread, the intersection test of the bounding box of the scene node to be rendered and the camera view frustum is performed to determine the visible scene node to be rendered.

[0036] Here, the first child thread is awakened at the start of the current frame K, and its input is: the set of all nodes N={n1,n2,...,n...} of the current frame after the scene space is divided. n}, where each node n i Associate an axis-aligned bounding box (AABB), whose minimum and maximum coordinates are denoted as (min... xi ,min i ,minz i ) and (max) xi ,max i ,maxz i The current frame camera parameters include viewpoint position, viewing direction, near / far clipping plane distance, and horizontal / vertical field of view. A six-plane frustum in the standard right-hand rule is constructed from these parameters. The equations of the six clipping planes are derived using the row vectors of the camera projection matrix. The six-plane frustum is then used to construct a frustum for each node n. i The intersection determination of the separation axis theorem identifies the visible scene nodes to be rendered.

[0037] In one possible implementation, after performing an intersection test between the bounding box of the scene node to be rendered and the camera frustum based on the first sub-thread to determine the visible scene nodes to be rendered, the processing method further includes: Determine the total number of 3D Homo spherical elements contained in all visible scene nodes to be rendered; determine whether the total number is greater than the maximum accommodating number; if it is greater, reduce the number of 3D Homo spherical elements contained in the visible scene nodes to be rendered by adjusting the LOD level, until the total number is less than or equal to the maximum accommodating number.

[0038] Here, the nodes are traversed in ascending order of their depth values. For each node n... i Read its pre-constructed multi-level LOD data structure (e.g., LOD0 contains all primitives, LOD1 contains 50%, LOD2 contains 25%, etc.), and select the LOD level that satisfies the lowest cumulative number of primitives ≤ Mopt. i If the cumulative sum exceeds Mopt when traversing to a certain node, then the node is forcibly downgraded to a higher LOD (i.e., fewer primitives) until the sum is ≤ Mopt.

[0039] (2): Based on the second sub-thread, store the 3D Gaussian elements in the visible scene nodes to be rendered into the first buffer.

[0040] Here, the second sub-thread processes each node n of the selected LOD level. i All corresponding 3D Homo sapiens (laid out in memory) are written in batches to the free slots of the first buffer using zero-copy (memcpy). The starting offset address of the write is maintained by the atomic accumulator to ensure that there are no conflicts when writing concurrently to multiple nodes. A fixed-size metadata area (MetadataHeader) is reserved at the head of the first buffer, in which the actual total number of primitives in this aggregation, the starting index of the effective slot, the ending index, and the original index mapping table of each node are written.

[0041] (3): Based on the main thread, the 3D Gaussian elements in the first buffer are transferred to the GPU memory in a fixed amount of data in a frame-by-frame manner.

[0042] Here, after the second child thread completes the metadata writing, the main thread triggers the transmission process by polling the completion flag in the metadata header. The transmission strictly follows a fixed frame size P fragmentation strategy, where P is a preset positive integer.

[0043] S103: After all the data in the first buffer has been transferred, the GPU's rendering data source is switched to the first buffer in the main thread. All 3D Homo spherical elements in the first buffer are globally sorted to construct a unified global rendering sequence, and all 3D Homo spherical elements of the current frame are rendered in sequence.

[0044] In this step, after the main thread completes the batch memory transfer of all 3D Gaussian elements in the first buffer and confirms data readiness via the CUDA event `event_full`, the system enters the GPU-side rendering preparation stage. This stage is completed by the GPU graphics pipeline before the rendering command is submitted, switching data sources with zero latency, constructing a global drawing sequence based on a deterministic algorithm, and performing semi-transparent blending without depth testing in a strict depth order, thereby eliminating block boundary cracks at the root.

[0045] Here, the GPU performs a global depth sort on all 3D Gaussian primitives in the first buffer, and constructs the global rendering sequence based on the Euclidean distance d from the center point of each 3D Gaussian primitive to the camera viewpoint. i The descending index sequence I=[i1,i2,...,i s ], where S is the total number of actual primitives in the first buffer, and satisfies d i1 ≥d i2 ≥…≥d i s.

[0046] In this application, compared with traditional local sorting within blocks (such as independent sorting of each node), global sorting forces all primitives to participate in the same sorting instance, completely eliminating Z-fighting and rendering order reversal caused by the jump of depth values ​​across blocks.

[0047] In one possible implementation, while sequentially rendering all 3D Gaussian elements of the current frame, the processing method further includes: The CPU performs the data preprocessing through the multi-threaded pipeline. During the data preprocessing, the idle buffer used is the second buffer that is not currently used by the GPU. The processed data results are transmitted to the GPU memory in frames. After the transmission is completed, the GPU rendering data source is switched to realize the alternating use of the first buffer and the second buffer.

[0048] The buffer role is defined as having two attributes: the data processing role is the buffer currently being written to 3D Gaussian primitives by the CPU sub-thread, and the data rendering role is the buffer currently being read by the GPU pipeline and used for drawing.

[0049] Here, at the start of frame K, the system is in a known initial state: if K=1 (first frame), the first buffer is initialized as a data processing buffer, and the second buffer is idle; the GPU has not yet started rendering, so there is no rendering buffer; if K>1, then according to frame K... When the final state is determined at the end of frame 1, the data processing role of frame K is always the buffer used for rendering in the previous frame, and it is converted into a processing role in this frame; the data rendering role of frame K is always the buffer used for processing in the previous frame, and it is converted into a rendering role in this frame.

[0050] In this application, through a dual-buffer rotation mechanism, CPU-side data preprocessing and GPU-side rendering execution are completely decoupled in time and space: the CPU can prepare data for frame K+1 in parallel for the idle buffer while the GPU renders frame K. This application provides a method for handling the crack problem in 3DGS scene block rendering. The method includes: setting a first buffer and a second buffer during the rendering initialization phase of the 3DGS scene; wherein each buffer is used to hold a maximum of several 3D Gaussian primitives; during the rendering of the current frame, the GPU is rendering the previous frame data in the second buffer, while the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copying the 3D Gaussian primitives contained in the visible scene nodes to be rendered to the first buffer which is in an idle state, and transmitting them to the GPU video memory frame by frame; after all the data in the first buffer has been transmitted, the GPU's rendering data source is switched to the first buffer in the main thread, all 3D Gaussian primitives in the first buffer are globally sorted, a unified global drawing sequence is constructed, and all 3D Gaussian primitives of the current frame are drawn sequentially. This method, which constructs a "dual buffer management—sub-thread pipeline preprocessing—global sorting—rendering" mechanism, eliminates the interface crack problem between nodes during 3D Gaussian splash block rendering of large scenes, improves rendering quality and visual effects, reduces hardware bandwidth requirements, and improves rendering performance.

[0051] Please see Figure 2 , Figure 3 , Figure 2 This is one of the structural schematic diagrams of a device for processing cracks in 3DGS scene block rendering provided in an embodiment of this application; Figure 3 This is a second schematic diagram of a device for processing cracks in 3DGS scene segmented rendering, provided as an embodiment of this application. Figure 2 As shown, the processing device 200 includes: Initialization module 210 is used to set up a first buffer and a second buffer during the rendering initialization phase of a 3DGS scene; each buffer is used to hold a maximum of several 3D Gaussian primitives. The data processing module 220 is used to preprocess the scene nodes to be rendered in the current frame during the current frame rendering process. While the GPU is rendering the previous frame data in the second buffer, the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copies the 3D Gaussian primitives contained in the visible scene nodes to be rendered to the first buffer which is in an idle state, and transmits them to the GPU memory in frames. The rendering module 230 is used to switch the GPU's rendering data source to the first buffer in the main thread after all the data in the first buffer has been transmitted, to globally sort all the 3D hexagonal primitives in the first buffer, to construct a unified global drawing sequence, and to draw all the 3D hexagonal primitives of the current frame in sequence.

[0052] Furthermore, the data processing module 220 is used by the CPU to preprocess the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copying the 3D Gaussian primitives contained in the visible scene nodes to be rendered to the first buffer in an idle state, and transmitting them to the GPU memory frame by frame: Based on the first sub-thread, the intersection test between the bounding box of the scene node to be rendered and the camera view frustum is performed to determine the visible scene node to be rendered. Based on the second sub-thread, the 3D Gaussian elements in the visible scene nodes to be rendered are stored in the first buffer; Based on the main thread, the 3D Gaussian elements in the first buffer are transferred to the GPU memory in a fixed amount of data in a frame-by-frame manner.

[0053] Furthermore, the data processing module 220 is also used for: Determine the total number of 3D Gaussian primitives contained in all visible scene nodes to be rendered; Determine whether the total number is greater than the maximum capacity. If the number is greater than the maximum number, the number of 3D Homo sapiens contained in the visible LOD level nodes to be rendered is reduced by adjusting the LOD level of the nodes until the total number is less than or equal to the maximum number that can be accommodated.

[0054] Furthermore, such as Figure 3 As shown, the processing device 200 further includes a determining module 240, which determines the maximum accommodating number through the following steps: Real-time collection of historical rendering time, historical average CPU load rate, historical average GPU load rate, and the deviation between the current frame's actual frame rate and the target frame rate; The maximum number of frames that can be accommodated in the current frame is determined by processing the historical rendering time, historical average CPU load rate, historical average GPU load rate, and deviation value using a multidimensional mapping function.

[0055] Furthermore, the rendering module 230 is also used for: The CPU performs the data preprocessing through the multi-threaded pipeline. During the data preprocessing, the idle buffer used is the second buffer that is not currently used by the GPU. The processed data results are transmitted to the GPU memory in frames. After the transmission is completed, the GPU rendering data source is switched to realize the alternating use of the first buffer and the second buffer.

[0056] This application provides a processing device for the 3DGS scene block rendering crack problem. The processing device includes: an initialization module, used to set a first buffer and a second buffer during the rendering initialization phase of the 3DGS scene; wherein each buffer is used to accommodate a maximum of several 3D Gaussian primitives; a data processing module, used to, during the current frame rendering process, while the GPU is rendering the previous frame data in the second buffer, the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copies the 3D Gaussian primitives contained in the visible scene nodes to be rendered to the first buffer which is in an idle state, and transmits them to the GPU video memory frame by frame; and a rendering module, used to, after all the data in the first buffer has been transmitted, switch the GPU's rendering data source to the first buffer in the main thread, perform global sorting on all the 3D Gaussian primitives in the first buffer, construct a unified global drawing sequence, and sequentially draw all the 3D Gaussian primitives of the current frame. The "double buffer management - sub-thread pipeline preprocessing - global sorting - rendering" approach eliminates the interface crack problem between nodes when rendering large-scale 3D Gaussian splash blocks, improving rendering quality and visual effects, reducing hardware bandwidth requirements, and improving rendering performance.

[0057] Please see Figure 4 , Figure 4 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Figure 4 As shown, the electronic device 400 includes a processor 410, a memory 420, and a bus 430.

[0058] The memory 420 stores machine-readable instructions executable by the processor 410. When the electronic device 400 is running, the processor 410 communicates with the memory 420 via the bus 430. When the machine-readable instructions are executed by the processor 410, they can perform the operations described above. Figure 1 The steps of the method for handling the crack problem in the 3DGS scene block rendering shown in the method embodiment can be found in the method embodiment for specific implementation, and will not be repeated here.

[0059] This application also provides a computer-readable storage medium storing a computer program, which, when executed by a processor, can perform the above-described actions. Figure 1 The steps of the method for handling the crack problem in the 3DGS scene block rendering shown in the method embodiment can be found in the method embodiment for specific implementation, and will not be repeated here.

[0060] Those skilled in the art will understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0061] In the several embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. The apparatus embodiments described above are merely illustrative. For example, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. Furthermore, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Additionally, the shown or discussed mutual couplings, direct couplings, or communication connections may be through some communication interfaces; indirect couplings or communication connections between devices or units may be electrical, mechanical, or other forms.

[0062] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0063] In addition, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0064] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a processor-executable, non-volatile, computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0065] Finally, it should be noted that the above-described embodiments are merely specific implementations of this application, used to illustrate the technical solutions of this application, and not to limit them. The scope of protection of this application is not limited thereto. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that any person skilled in the art can still modify or easily conceive of changes to the technical solutions described in the foregoing embodiments, or make equivalent substitutions for some of the technical features, within the scope of the technology disclosed in this application. Such modifications, changes, or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be covered within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A method for handling the crack problem in 3DGS scene block rendering, characterized in that, The processing method includes: During the rendering initialization phase of a 3DGS scene, a first buffer and a second buffer are set up; each buffer is used to hold a maximum of several 3D high-order primitives. During the current frame rendering process, the GPU is rendering the previous frame data in the second buffer. At the same time, the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copies the 3D Gaussian primitives contained in the visible scene nodes to be rendered to the first buffer which is in an idle state, and transmits them to the GPU memory frame by frame. After all the data in the first buffer has been transferred, the GPU's rendering data source is switched to the first buffer in the main thread. All 3D Homo spherical elements in the first buffer are globally sorted to construct a unified global rendering sequence, and all 3D Homo spherical elements of the current frame are rendered in sequence.

2. The processing method according to claim 1, characterized in that, The CPU preprocesses the scene nodes to be rendered in the current frame through a multi-threaded pipeline, copies the 3D Gaussian primitives contained in the visible scene nodes to the first buffer which is in an idle state, and transmits them to the GPU memory frame by frame, including: Based on the first sub-thread, the intersection test between the bounding box of the scene node to be rendered and the camera view frustum is performed to determine the visible scene node to be rendered. Based on the second sub-thread, the 3D Gaussian elements in the visible scene nodes to be rendered are stored in the first buffer; Based on the main thread, the 3D Gaussian elements in the first buffer are transferred to the GPU memory in a fixed amount of data in a frame-by-frame manner.

3. The processing method according to claim 2, characterized in that, After determining the visible scene nodes to be rendered by performing an intersection test between the bounding box of the scene node to be rendered and the camera frustum based on the first sub-thread, the processing method further includes: Determine the total number of 3D Gaussian primitives contained in all visible scene nodes to be rendered; Determine whether the total number is greater than the maximum capacity. If the number is greater than the maximum number, the number of 3D Homo sapiens contained in the visible LOD level nodes to be rendered is reduced by adjusting the LOD level of the nodes until the total number is less than or equal to the maximum number that can be accommodated.

4. The processing method according to claim 1, characterized in that, The maximum capacity is determined by the following steps: Real-time collection of historical rendering time, historical average CPU load rate, historical average GPU load rate, and the deviation between the current frame's actual frame rate and the target frame rate; The maximum number of frames that can be accommodated in the current frame is determined by processing the historical rendering time, historical average CPU load rate, historical average GPU load rate, and deviation value using a multidimensional mapping function.

5. The processing method according to claim 1, characterized in that, When sequentially drawing all 3D Gaussian elements of the current frame, the processing method further includes: The CPU performs the data preprocessing through the multi-threaded pipeline. During the data preprocessing, the idle buffer used is the second buffer that is not currently used by the GPU. The processed data results are transmitted to the GPU memory in frames. After the transmission is completed, the GPU rendering data source is switched to realize the alternating use of the first buffer and the second buffer.

6. The processing method according to claim 1, characterized in that, In the multi-threaded pipeline, each sub-thread synchronizes its data readiness state through a lock-free circular queue or memory barrier mechanism to ensure data integrity and thread safety during buffer switching.

7. The processing method according to claim 1, characterized in that, Both the first buffer and the second buffer are contiguous memory blocks, and are mapped in the GPU memory as two independent unified buffer objects or shader storage buffer objects, respectively, to pass the position, rotation, scaling, opacity and spherical harmonic parameters of 3D Gaussian primitives to the GPU rendering pipeline.

8. A device for handling crack problems in 3DGS scene segmented rendering, characterized in that, The processing device includes: The initialization module is used to set up the first buffer and the second buffer during the rendering initialization phase of the 3DGS scene; each buffer is used to hold a maximum of several 3D hexagonal elements. The data processing module is used to preprocess the scene nodes to be rendered in the current frame during the rendering process of the current frame. While the GPU is rendering the data of the previous frame in the second buffer, the CPU performs data preprocessing on the scene nodes to be rendered in the current frame through a multi-threaded pipeline. The 3D Gaussian primitives contained in the visible scene nodes to be rendered are copied to the first buffer which is in an idle state and then transmitted to the GPU memory in frames. The rendering module is used to switch the GPU's rendering data source to the first buffer in the main thread after all the data in the first buffer has been transferred. It then performs global sorting on all 3D hexagonal primitives in the first buffer, constructs a unified global drawing sequence, and draws all 3D hexagonal primitives of the current frame in sequence.

9. An electronic device, characterized in that, include: The device includes a processor, a memory, and a bus. The memory stores machine-readable instructions executable by the processor. When the electronic device is running, the processor communicates with the memory via the bus. The machine-readable instructions are executed by the processor to perform the steps of the method for handling the 3DGS scene block rendering crack problem as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, performs the steps of the method for handling the crack problem in 3DGS scene block rendering as described in any one of claims 1 to 7.

Images