A lightweight 3DGS progressive streaming fine-grained web3D online rendering method and system

Abstract

The present application relates to the technical field of Web3D, three-dimensional Gaussian splash and three-dimensional Internet, and more particularly to a lightweight 3DGS progressive streaming fine-grained Web3D online rendering method and system. Through performing quantization compression, attribute separation and non-redundant incremental multi-level detail level construction on 3DGS data, lightweight fine-grained preprocessing is completed; simplified occlusion bodies are generated on the server and online visibility calculation is performed, and a transmission priority queue is generated according to the size of the Gaussian ellipsoid screen and the opacity; the 3D Tiles standard is combined with the octree index to realize phased progressive streaming transmission; on the Web side, incremental instantiation rendering is performed based on WebGPU, and dynamic video memory cache management is realized by using the least recently used strategy. The present application can realize the second-level loading and high-fidelity on-demand rendering of a billion-level Gaussian sphere scale city scene, and significantly reduces the network bandwidth and terminal computing power requirements.

Description

Technical Field

[0001] This invention relates to the fields of Web3D, 3D Gaussian splashing and 3D Internet technology, and more specifically to a lightweight 3DGS progressive streaming fine-grained Web3D online rendering method and system. Background Technology

[0002] 3D Gaussian Splash (3DGS) technology has garnered significant attention due to its high-quality real-time rendering capabilities. However, when dealing with city-level or large-scale digital twin scenes, 3DGS generates extremely large amounts of data (typically reaching gigabytes), and the raw data structure lacks effective spatial indexing and streaming loading mechanisms. Existing Web3D display technologies face the following bottlenecks when processing such massive amounts of data: 1. Computational bottleneck: Existing solutions mostly rely on static file loading, lacking intelligent computation intervention on the server side. The server cannot perform effective spatial indexing and real-time visibility calculations (such as frustum culling and occlusion culling) on ​​massive Gaussian data, resulting in a large amount of data that is not visible or occluded from the current viewpoint being sent into the transmission and rendering pipeline, causing serious ineffective computation and resource waste, making it difficult to support online browsing of large-scale and complex urban scenes.

[0003] 2. Network Transmission Bottleneck: Raw 3DGS data is typically stored in PLY format, resulting in massive file sizes (GB-level) and a lack of fine-grained chunking and LOD (Level of Detail) organization. This hinders efficient data compression and on-demand loading. In the mobile internet environment, this "full download" mode leads to excessively long initial screen loading times, low bandwidth utilization, and an inability to meet the demands of real-time access and low-latency interaction on mobile devices.

[0004] 3. Rendering efficiency bottleneck: Compared to native desktop applications, web browsers (Web-side) have relatively limited graphics interfaces (WebGL / WebGPU) and computing power. Faced with hundreds of millions of Gaussian bytes, the front-end struggles to handle the real-time sorting and rasterization of the entire dataset, resulting in low frame rates and even stuttering. Furthermore, the lack of incremental rendering mechanisms optimized for the Web environment leads to extremely poor dynamic interactive experiences in large-scale scenes.

[0005] 4. Caching resource bottleneck: Browser video memory (VRAM) resources are severely limited, making it difficult to handle all the data in city-level scenarios. Existing solutions lack efficient dynamic VRAM management and cache replacement mechanisms (such as LRU strategies). As the roaming range expands, the accumulated Gaussian data can easily lead to VRAM overflow (OOM) and browser crashes, limiting users' ability to continuously roam in large-scale scenarios.

[0006] Therefore, how to provide a lightweight 3DGS progressive streaming fine-grained Web3D online rendering method and system is a problem that urgently needs to be solved by those skilled in the art. Summary of the Invention

[0007] In view of this, the present invention provides a lightweight 3DGS progressive streaming fine-grained Web3D online rendering method and system, aiming to solve the above-mentioned technical problems.

[0008] To achieve the above objectives, the present invention adopts the following technical solution: A lightweight 3DGS progressive streaming fine-grained Web3D online rendering method includes the following steps: Lightweight, fine-grained preprocessing is performed on the original 3D Gaussian splash data, and efficient compression and quantization encoding compatible with multiple formats are carried out. Gaussian attributes are stored separately as geometric and lighting attributes, and redundant incremental multi-level detail data is constructed. On the server side, a simplified occlusion volume that fits the scene shape is generated and a spatial index is established. The viewpoint information of the client is received in real time, and online visibility calculation is performed to generate a potential visible set of the current viewpoint. The loading priority is calculated based on the screen size and opacity of the Gaussian ellipsoid, and a data transmission priority queue is generated. The 3D Tiles standard is used to spatially divide massive Gaussian data and establish index mapping relationships. Based on the priority queue, combined with the octree spatial index structure, progressive streaming transmission is performed to transmit data of different detail levels and different attribute streams in stages. The web client parses and incrementally instantiates the received data stream based on the WebGPU graphics interface, while establishing a video memory cache pool and using a least recently used strategy for dynamic video memory cache management.

[0009] Furthermore, the multi-format compatible high-efficiency compression and quantization encoding supports multiple 3DGS data compression formats. It uses binary encoding technology to perform fixed-point processing on Gaussian attributes, quantizing the position of 32-bit floating-point numbers into 24-bit fixed-point integers, quantizing rotation into 8-bit signed integers, quantizing scaling into 8-bit logarithmic encoded integers, quantizing color into 8-bit unsigned integers, and quantizing spherical harmonic coefficients into 8-bit signed integers.

[0010] Furthermore, the separate storage of geometric and lighting attributes physically separates the basic attributes of Gaussian point position, rotation, and opacity from the spherical harmonic coefficients, dividing them into a basic flow and an extended flow. The basic flow contains geometric attributes and 0th-order spherical harmonics, used to quickly construct scene outlines and tones. The extended flow contains 1st-3rd order higher-order spherical harmonic coefficients, used to supplement viewpoint-related lighting details.

[0011] Furthermore, the non-redundant incremental multi-level detail data decomposes the 3DGS scene into multi-level detail data, with each level of data being unique. The client achieves progressive enhancement of image quality through cumulative loading. The initial level detail data contains the most significant top 10% Gaussian points in the scene, the next level detail data contains the next most important 20% Gaussian points, and so on to complete the division of all levels.

[0012] Furthermore, during the online visibility calculation process, the server receives camera parameters uploaded by the client in real time. First, it uses a KD tree to quickly remove tile data outside the view frustum, thus completing the view frustum removal. For candidate tiles within the view frustum, it uses a pre-generated occlusion volume to perform GPU hardware occlusion query or soft rasterization calculation to determine whether each tile is completely occluded by nearby buildings, thereby accurately generating the potential visible set of the current viewpoint.

[0013] Furthermore, the process of generating the data transmission priority queue is as follows: for Gaussian data in the visible set, the product of its projection screen ratio and opacity is used as the weight to generate a download priority queue, so that Gaussian points that contribute more to the visual experience are pushed to the client first.

[0014] Furthermore, the progressive streaming is performed in two stages: The first phase is the rapid response phase, which involves traversing the octree index on the server, locking the shallow nodes that are visible within the view frustum, and prioritizing the transmission of the initial level detail data and basic stream attributes corresponding to these nodes. The second stage is the image quality enhancement stage. When the client detects that the viewpoint is stationary or the network bandwidth is idle, it traverses downwards according to the octree hierarchy to request high-order incremental detail data of deep child nodes, while simultaneously transmitting the extended stream data of the corresponding nodes in parallel.

[0015] Furthermore, during the incremental instantiation rendering process, the client utilizes the WebGPU graphics interface to perform zero-copy parsing and direct mapping of the received binary compressed data stream to the video memory, directly appending the newly arrived Gaussian data to the WebGPU's storage buffer. The rendering loop only updates the instance count, without needing to re-upload the entire scene data.

[0016] Furthermore, in the dynamic video memory cache management process, a video memory cache pool is established on the browser side to monitor the video memory usage in real time. When the video memory usage exceeds a set threshold, the current cached Tile list is traversed, and the Tile's most recent access time and the current view frustum visibility are scored. The Least Recently Used strategy is used to automatically release Tile data and its video memory resources that have not been observed for a long time or are extremely far away.

[0017] A lightweight 3DGS progressive streaming fine-grained Web3D online rendering system includes a data preprocessing module, a server-side scheduling module, a streaming transmission module, and a Web-side rendering cache module; The data preprocessing module performs efficient compression and quantization encoding on the raw 3D Gaussian splash data, compatible with multiple formats. It separates and stores Gaussian attributes by geometric and lighting properties, and constructs redundant incremental multi-level detail data. The server-side scheduling module generates a simplified occlusion volume that fits the scene shape and establishes a spatial index. It receives viewpoint information from the client in real time, performs online visibility calculations to generate a potential visible set for the current viewpoint, calculates loading priority based on the screen size and opacity of the Gaussian ellipsoid, and generates a data transmission priority queue. The streaming module spatially partitions the massive Gaussian data using the 3D Tiles standard and establishes an index mapping relationship. Based on the priority queue and an octree spatial index structure, it performs progressive streaming transmission, transmitting data of different detail levels and attribute streams in stages. The web-side rendering cache module parses and incrementally instantiates the received data stream based on the WebGPU graphics interface, while establishing a video memory cache pool and dynamically managing the video memory cache using a least recently used strategy.

[0018] Compared to existing technologies, this invention achieves second-level loading and real-time high-fidelity rendering of a city scene with a scale of billions of Gaussian spheres on the Web through end-to-end collaboration of data preprocessing, server-side visibility scheduling, progressive streaming transmission, and client-side incremental rendering caching. The data volume is reduced by about an order of magnitude compared to the original format, while maintaining a high frame rate and high-quality visual effects. It significantly reduces network bandwidth and terminal computing power requirements, effectively prevents video memory overflow, and ensures the smoothness of continuous roaming of large-scale scenes. Attached Figure Description

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

[0020] Figure 1 This is a flowchart illustrating the overall architecture of the lightweight Web3DGS progressive streaming rendering method in this invention. Figure 2 This is a flowchart of the online visibility calculation based on frustum culling in this invention; Figure 3 This is a schematic diagram of the incremental LOD rendering logic on the Web side in this invention; Figure 4This is a schematic diagram of client-side dynamic cache management in this invention; Figure 5 This is a diagram of the full-link collaborative architecture of "computation-transmission-rendering-pacing" in this invention. Detailed Implementation

[0021] The technical solutions in the embodiments of the present invention will be clearly and completely described below. 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.

[0022] The purpose of this invention is to provide an efficient lightweight Web3D instantiation method and system for 3D Gaussian splash scenes. To make the above-mentioned objectives, features and advantages of this invention more apparent and understandable, the invention will be further described in detail below with reference to specific embodiments.

[0023] Lightweight fine-grained preprocessing of S1.3DGS data S1.1 This method supports multiple 3DGS data compression formats to adapt to different network environments and terminal performance requirements. As one of the core compression strategies, the system adopts a high-compression-ratio binary encoding technique: quantizing the position of a 32-bit floating-point number into a 24-bit fixed-point integer, quantizing rotation into an 8-bit signed integer, quantizing scaling into an 8-bit logarithmic encoded integer, and quantizing color into an 8-bit unsigned integer. This lightweight strategy can significantly reduce data volume, typically compressing the data to about 1 / 10 of the original PLY format.

[0024] First, the system receives the raw 3D Gaussian data (usually in PLY format). To significantly reduce data volume and adapt to different network bandwidth environments, this invention designs a multi-format compatible data parsing interface that supports loading multiple compression standards. In this embodiment, an efficient compression strategy based on binary quantization encoding is used to perform fixed-point processing on the Gaussian properties. Specific implementation details are as follows: 1. Positions: The original 32-bit or 64-bit floating-point coordinates are quantized using 24-bit fixed-point integers. This process achieves a data size reduction of approximately 25% to 62.5% while maintaining geometric position accuracy.

[0025] 2. Rotation property: Converts 32-bit floating-point quaternions into 8-bit signed integers, achieving a size reduction rate of up to 81.25% by reducing precision redundancy.

[0026] 3. Scales: 8-bit logarithmic encoded integers are used to replace the original floating-point numbers. The logarithmic space characteristics are used to efficiently express the non-linear changes in the scale of objects, with a reduction rate of 75%-87.5%.

[0027] 4. Spherical Harmonics: Compresses the 32-bit floating-point SH coefficients, which occupy a large amount of storage space, into 8-bit signed integers, achieving an extreme compression of 75%–87.5%.

[0028] Through the above efficient quantization compression strategy, the overall data volume can be reduced to about 1 / 10 of the original PLY format, and there is basically no loss of visual quality when rendering on the web.

[0029] S1.2 implements a strategy of separating geometric and lighting attributes. Basic attributes such as the position, rotation, and opacity of Gaussian points are separated from spherical harmonics (SH). In fast browsing mode, only basic attributes are loaded, while higher-order SH data is loaded as needed, thus significantly reducing the initial data transfer volume.

[0030] To support fast initial screen loading, this invention implements an attribute separation strategy. The core geometric attributes (position, rotation, scale, opacity) of Gaussian elements are physically separated from higher-order appearance attributes (spherical harmonics).

[0031] Base Stream: Contains only geometric properties and 0th-order spherical harmonics (basic RGB colors), used to quickly build scene outlines and tones.

[0032] Extension Stream: Contains 1st to 3rd order higher-order spherical harmonics, used to supplement viewpoint-dependent lighting details (such as highlights and reflections) when bandwidth is sufficient. S1.3, for large-scale scenes, constructs a multi-level Level of Detail (LOD) index, decomposing the 3DGS scene into multi-level LOD data ( Unlike traditional Level of Detail (LOD) which contains redundant data, this invention employs a "redundant incremental LOD" strategy, decomposing scene data into... LOD0 contains the top 10% of the most significant Gaussian points in the scene (typically filtered based on size and opacity). Includes the second most important 20% Gaussian point, and so on. The client accumulates... You can get higher image quality without having to download the basic data again.

[0033] S2. Server-side online visibility retrieval and computing power scheduling S2.1 Voxel Block Generation: Simplified voxel blocks that fit the scene shape are pre-generated on the server side.

[0034] On the server side, the 3DGS scene is pre-processed into voxels or meshes to generate simplified occlusion volumes that fit the scene geometry. Simultaneously, a spatial index based on a KD-tree or octree is established for fast retrieval of tile data blocks within the view frustum.

[0035] S2.2. Online Visibility Calculation: The server receives viewpoint information from the client in real time, performs frustum culling and occlusion culling calculations using occlusion volumes, and accurately determines the set of visible components under the current viewpoint.

[0036] The server receives camera parameters (position, orientation, field of view) uploaded by the client in real time.

[0037] Frustum Culling: First, KD trees are used to quickly remove tile data outside the frustum.

[0038] Occlusion Culling: For candidate tiles within the view frustum, GPU hardware occlusion query or soft rasterization calculation is performed using pre-generated occlusion volumes. The system determines whether each tile is completely occluded by nearby buildings, thereby accurately generating the "current view potential visible set (PVS)".

[0039] S2.3 Priority Scheduling: Calculate loading priority based on the screen size and transparency of the Gaussian splash ellipsoid, and generate a data transmission queue.

[0040] For Gaussian data within the visible set, the system calculates the product of its projection screen size and opacity as weights to generate a download priority queue. This ensures that Gaussian points that contribute the most to the visual experience (such as large nearby objects) are pushed to the client first.

[0041] S3. Progressive streaming based on octree indexing This stage primarily relies on spatial indexing and priority strategies to achieve efficient network data distribution.

[0042] S3.1. Data Blocking and Index Mapping: The massive Gaussian data is spatially divided into blocks using the 3D Tiles standard. The system assigns a unique 3D Tiles index to each Tile data block, which typically contains metadata information such as level and spatial coordinates (X, Y, Z), thereby establishing a direct mapping relationship from the logical index to the physical SPZ data block.

[0043] S3.2. Priority-based streaming scheduling: Based on the priority queue generated in S2, the system requests and transmits corresponding Tile data blocks in batches over the network. The system first traverses the server's octree index to quickly locate shallow nodes that are visible within the view frustum. It then prioritizes transmitting the corresponding data for these nodes. Hierarchical data and "basic flow" properties (i.e., position, rotation, scaling, opacity, and 0th order spherical harmonics). This step ensures that the complete geometric skeleton and basic color tone of the scene can be immediately received and rendered when the user moves the viewpoint quickly, effectively eliminating "white screen" or "gap" phenomena and ensuring the continuity and responsiveness of the interactive experience.

[0044] When the client detects that the viewpoint is stationary or the network bandwidth is idle, the system further traverses downwards according to the octree hierarchy to request deeper child nodes. Incremental detail data. At the same time, the "extended stream" data (i.e., 1st to 3rd order higher spherical harmonic coefficients) of the corresponding nodes are transmitted in parallel to gradually fill in the high-frequency lighting details and texture features of the scene, improving the rendering quality from basic geometry to photorealistic quality.

[0045] S4 Web-based incremental rendering and dynamic cache management This phase is primarily responsible for high-performance display and resource scheduling on the client side.

[0046] S4.1. WebGPU Incremental Rendering: The client utilizes the WebGPU graphics interface to perform zero-copy parsing and direct memory mapping on the received data stream. The rendering pipeline employs an incremental update strategy, appending only the Gaussian points contained in newly arriving tiles to the GPU storage buffer, avoiding repeated submission and redrawing of the entire scene data, thereby significantly reducing rendering overhead.

[0047] S4.2 Dynamic Cache Management: A video memory cache pool is established on the browser side to dynamically monitor memory usage in real time. The system adopts the LRU (Least Recently Used) strategy, which periodically cleans up tile data that is outside the field of view or has low priority based on the relevance of the tile's access timestamp to the current viewpoint, effectively preventing video memory overflow (OOM) and ensuring frame rate stability during continuous roaming.

[0048] When video memory usage exceeds a threshold (e.g., 80%), the system iterates through the currently cached tile list and scores it based on "recent access time" and "current frustum visibility." It automatically releases tile data and its video memory resources that have not been observed for a long time or are extremely far away, thereby enabling roaming of an infinitely large scene within limited video memory.

[0049] The present invention also discloses a lightweight 3DGS progressive streaming fine-grained Web3D online rendering system, including a data preprocessing module, a server scheduling module, a streaming transmission module and a Web rendering cache module; The data preprocessing module performs efficient compression and quantization encoding on the raw 3D Gaussian splash data, compatible with multiple formats. It separates and stores Gaussian attributes into geometric and lighting attributes, and constructs redundant incremental multi-level detail data. The server-side scheduling module generates a simplified occlusion volume that fits the scene shape and establishes a spatial index. It receives viewpoint information from the client in real time, performs online visibility calculations to generate a potential visible set for the current viewpoint, calculates loading priority based on the screen size and opacity of the Gaussian ellipsoid, and generates a data transmission priority queue. The streaming module spatially partitions massive Gaussian data using the 3DTiles standard and establishes index mapping relationships. Based on the priority queue and combined with an octree spatial index structure, it performs progressive streaming transmission, transmitting data of different detail levels and different attribute streams in stages. The web-side rendering cache module parses and incrementally instantiates the received data stream based on the WebGPU graphics interface, while establishing a video memory cache pool and using a least recently used strategy for dynamic video memory cache management.

[0050] Through the above implementation methods, the present invention successfully achieved second-level loading and real-time high-fidelity rendering of a city scene with a scale of one billion Gaussian spheres on the Web, reducing the data volume by about an order of magnitude compared to the original format (e.g., from 20GB to about 2GB), while maintaining a high frame rate and high-quality visual effect.

[0051] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. The same or similar parts between the various embodiments can be referred to each other.

[0052] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A lightweight 3DGS progressive streaming fine-grained Web3D online rendering method, characterized in that, Includes the following steps: Lightweight, fine-grained preprocessing is performed on the original 3D Gaussian splash data, and efficient compression and quantization encoding compatible with multiple formats are carried out. Gaussian attributes are stored separately for geometric and lighting attributes, and redundant incremental multi-level detail data is constructed. On the server side, a simplified occlusion volume that fits the scene shape is generated and a spatial index is established. The viewpoint information of the client is received in real time, and online visibility calculation is performed to generate a potential visible set of the current viewpoint. The loading priority is calculated based on the screen size and opacity of the Gaussian ellipsoid, and a data transmission priority queue is generated. The 3D Tiles standard is used to spatially divide massive Gaussian data and establish index mapping relationships. Based on the priority queue, combined with the octree spatial index structure, progressive streaming transmission is performed to transmit data of different detail levels and different attribute streams in stages. The web client parses and incrementally instantiates the received data stream based on the WebGPU graphics interface, while establishing a video memory cache pool and using a least recently used strategy for dynamic video memory cache management.

2. The lightweight 3DGS progressive streaming fine-grained Web3D online rendering method according to claim 1, characterized in that, The multi-format compatible high-efficiency compression and quantization encoding supports multiple 3DGS data compression formats. It uses binary encoding technology to perform fixed-point processing on Gaussian attributes, quantizing the position of 32-bit floating-point numbers into 24-bit fixed-point integers, quantizing rotation into 8-bit signed integers, quantizing scaling into 8-bit logarithmic encoded integers, quantizing color into 8-bit unsigned integers, and quantizing spherical harmonic coefficients into 8-bit signed integers.

3. The lightweight 3DGS progressive streaming fine-grained Web3D online rendering method according to claim 1, characterized in that, The separate storage of geometric and lighting attributes physically separates the basic attributes of Gaussian points, such as position, rotation, and opacity, from spherical harmonics, dividing them into a basic flow and an extended flow. The basic flow contains geometric attributes and 0th-order spherical harmonics, used to quickly construct scene outlines and tones. The extended flow contains 1st-3rd order higher-order spherical harmonics, used to supplement viewpoint-related lighting details.

4. The lightweight 3DGS progressive streaming fine-grained Web3D online rendering method according to claim 1, characterized in that, The non-redundant incremental multi-level detail data decomposes the 3DGS scene into multi-level detail data, with each level of data being unique. The client achieves progressive enhancement of image quality through cumulative loading. The initial level of detail data contains the top 10% of the most significant Gaussian points in the scene, the next level of detail data contains the next 20% of the most important Gaussian points, and so on to complete the division of all levels.

5. The lightweight 3DGS progressive streaming fine-grained Web3D online rendering method according to claim 1, characterized in that, During the online visibility calculation process, the server receives camera parameters uploaded by the client in real time. First, it uses a KD tree to quickly remove tile data outside the view frustum to complete the view frustum removal. For candidate tiles inside the view frustum, it uses a pre-generated occlusion volume to perform GPU hardware occlusion query or soft rasterization calculation to determine whether each tile is completely occluded by nearby buildings, thereby accurately generating the potential visibility set of the current viewpoint.

6. The lightweight 3DGS progressive streaming fine-grained Web3D online rendering method according to claim 1, characterized in that, The process of generating the data transmission priority queue is as follows: for Gaussian data in the visible set, the product of its projection screen ratio and opacity is used as the weight to generate a download priority queue, so that Gaussian points that contribute more to the visual experience are pushed to the client first.

7. The lightweight 3DGS progressive streaming fine-grained Web3D online rendering method according to claim 1, characterized in that, The progressive streaming is performed in two phases: The first phase is the rapid response phase, which involves traversing the octree index on the server, locking the shallow nodes that are visible within the view frustum, and prioritizing the transmission of the initial level detail data and basic stream attributes corresponding to these nodes. The second stage is the image quality enhancement stage. When the client detects that the viewpoint is stationary or the network bandwidth is idle, it traverses downwards according to the octree hierarchy to request high-order incremental detail data of deep child nodes, while simultaneously transmitting the extended stream data of the corresponding nodes in parallel.

8. The lightweight 3DGS progressive streaming fine-grained Web3D online rendering method according to claim 1, characterized in that, During the incremental instantiation rendering process, the client uses the WebGPU graphics interface to perform zero-copy parsing and direct memory mapping on the received binary compressed data stream, and directly appends the newly arrived Gaussian data to the WebGPU's storage buffer. The rendering loop only updates the instance count and does not need to re-upload the entire scene data.

9. A lightweight 3DGS progressive streaming fine-grained Web3D online rendering method according to claim 1, characterized in that, During the dynamic video memory cache management process, a video memory cache pool is established on the browser side to monitor video memory usage in real time. When video memory usage exceeds a set threshold, the current cached Tile list is traversed, and a score is calculated based on the Tile's most recent access time and the current view frustum visibility. The Least Recently Used strategy is used to automatically release Tile data and its video memory resources that have not been observed for a long time or are extremely far away.

10. A lightweight 3DGS progressive streaming fine-grained Web3D online rendering system, characterized in that, It includes a data preprocessing module, a server-side scheduling module, a streaming module, and a web-side rendering cache module; The data preprocessing module performs efficient compression and quantization encoding on the raw 3D Gaussian splash data, compatible with multiple formats. It separates and stores Gaussian attributes by geometric and lighting properties, and constructs redundant incremental multi-level detail data. The server-side scheduling module generates a simplified occlusion volume that fits the scene shape and establishes a spatial index. It receives viewpoint information from the client in real time, performs online visibility calculations to generate a potential visible set for the current viewpoint, calculates loading priority based on the screen size and opacity of the Gaussian ellipsoid, and generates a data transmission priority queue. The streaming module spatially partitions the massive Gaussian data using the 3D Tiles standard and establishes an index mapping relationship. Based on the priority queue and an octree spatial index structure, it performs progressive streaming transmission, transmitting data of different detail levels and attribute streams in stages. The web-side rendering cache module parses and incrementally instantiates the received data stream based on the WebGPU graphics interface, while establishing a video memory cache pool and dynamically managing the video memory cache using a least recently used strategy.

Images