A method and system for supporting loading and display of hierarchical 3D Gaussian splash data in a Unity engine

Abstract

The application discloses a kind of support level 3D Gaussian splash data in Unity engine loading and demonstration method and system, wherein the method includes: parsing hier format data, generating the asset file that Unity engine can identify;Based on GPU parallel computing, the hierarchical structure of asset file is preprocessed, the rendering parameter of effective Gaussian sphere node is generated, the rendering parameter of effective Gaussian sphere node is called based on Unity engine, and effective Gaussian sphere data is loaded and rendered by instantiation;Dynamic update Gaussian sphere rendering content.The application accurately extracts the key information of binary tree node in hier format file, and generates the asset file adapted to Unity engine, solves the problem that the hierarchical structure cannot be utilized due to node information loss and format incompatibility of existing plug-ins, enhances the maintainability and expandability of data, ensures that the original data of million-level Gaussian sphere scene can be accurately and efficiently loaded into the engine, and overcomes the limitation of traditional method that only supports non-hierarchical PLY format.

Description

Technical Field

[0001] This invention relates to the field of data loading and display technology in the Unity engine, and in particular to a method and system for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine. Background Technology

[0002] 3D Gaussian splatter technology, as a key technology for real-time radiation field rendering, has been widely used in the field of large-scale 3D scene reconstruction and visualization. Existing Unity engine Gaussian splatter data loading and display plugins (such as the GitHub open-source project UnityGaussianSplatting) have chunk (data block) partitioning capabilities to accelerate traditional Gaussian rendering, but they only support non-hierarchical Gaussian splatter data in PLY format and cannot handle hier format hierarchical 3D Gaussian splatter data (generated by the GitHub project hierarchical-3d-gaussians for real-time rendering of large-scale datasets).

[0003] The hier format data uses a binary tree hierarchical structure to organize Gaussian spheres. Its core advantage lies in achieving efficient rendering of large-scale data through hierarchical pruning. Its binary tree nodes contain key information such as the parent node index, the starting index of the corresponding Gaussian sphere, the number of leaf Gaussian spheres, the number of merged Gaussian spheres, the binary tree depth, the starting index of the child node, and the number of child nodes. Existing Unity plugins have the following technical shortcomings:

[0004] First, node information is missing and the format is incompatible. Although chunk data can be identified, the key attributes of the binary tree nodes in the hier file cannot be parsed. Furthermore, the asset file storage format, metadata carrier, and Unity engine have poor compatibility, making it impossible to achieve precise pruning using the hierarchical structure. Second, rendering performance is insufficient. Due to the lack of node hierarchical information, the advantages of GPU parallel computing are not fully utilized, resulting in significant stuttering when rendering large-scale Gaussian spheres. Third, functional compatibility is poor: dynamic rendering adjustments based on node information are not supported, and hier format data cannot be exported to the universal PLY format to meet data reuse requirements.

[0005] For example, invention application number 202511666043.8 discloses a method and system for generating dredging terrain twins based on right-angled triangular meshes. This scheme uses batch rendering and height-based coloring of chunks to visualize the terrain. However, its scheme cannot handle hierarchical 3D Gaussian splash data in hierarchical format, thus failing to meet the data reuse requirements.

[0006] Therefore, in reality, a Unity loading and display solution that adapts to the characteristics of hier format nodes is needed to solve the above-mentioned node parsing, performance, and functionality issues. Summary of the Invention

[0007] To address the aforementioned problems, the present invention aims to provide a method and system for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine, thereby resolving issues such as missing node information, format incompatibility, insufficient rendering performance, and poor functional adaptability in existing Unity plugins when processing hierarchical 3D Gaussian splash data.

[0008] This invention provides a method and system for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine.

[0009] First aspect: A method for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine, including:

[0010] S1. Parse hier format data, extract basic asset files, hierarchical structure files and metadata, and generate asset files that can be recognized by the Unity engine;

[0011] S2. Based on GPU parallel computing, the hierarchical structure of the asset file is preprocessed. Redundant nodes are pruned by setting pixel thresholds, rendering parameters of effective Gaussian sphere nodes are generated, and the rendering parameters are stored using a rendering parameter buffer.

[0012] S3. Based on the rendering parameters of the valid Gaussian sphere node, call the Unity engine to instantiate and load the valid Gaussian sphere data for rendering;

[0013] S4. Based on the view update, re-trigger the S2 preprocessing, update the rendering parameters of the valid Gaussian sphere nodes, and dynamically update the Gaussian sphere rendering content.

[0014] In one embodiment of the present invention, it further includes:

[0015] S5. Based on GPU, filter the leaf node data of hier format data and convert it into PLY format file.

[0016] In one embodiment of the present invention, the assetization file includes:

[0017] The basic asset files include: Gaussian sphere chk block information, col color information, oth rotation and scaling information, and shs spherical harmonic function information;

[0018] The hierarchical structure file includes: Gaussian sphere node index information and box node bounding box information;

[0019] The basic asset files and hierarchical structure files are in .bytes format, and the metadata is in .asset format.

[0020] In one embodiment of the present invention, the Gaussian sphere node index information includes the parent node index, the corresponding Gaussian sphere index starting point, the number of leaf Gaussian spheres, the number of merged Gaussian spheres, the binary tree depth, the child node index starting point, and the number of child nodes.

[0021] In one embodiment of the present invention, the rendering parameters for generating valid Gaussian sphere nodes in S2 include:

[0022] Based on the parallel computing capabilities of the GPU, the system takes the node index information and node bounding box information as input, sets a preset pixel threshold, combines node attributes, calls the ComputeShader instruction to calculate the projection size of the node bounding box in the viewport, removes redundant Gaussian sphere nodes whose projection size is less than the threshold, and extracts the rendering parameters of the valid Gaussian sphere nodes.

[0023] In one embodiment of the present invention, the step S2, which utilizes a rendering parameter buffer to store rendering parameters, includes:

[0024] An IndirectBuffer is generated within the GPU, and rendering parameters are stored based on the IndirectBuffer.

[0025] In one embodiment of the present invention, when dynamically updating the Gaussian sphere rendering content in S4, the Unity engine instantiation rendering instruction is called as DrawProceduralIndirect().

[0026] The second aspect: A device for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine, comprising:

[0027] The hier file parsing module is used to read hier format data and parse the hier format data.

[0028] Asset generation module: Converts parsed data into asset files adapted for the Unity engine, including basic asset files, hierarchical structure files, and metadata;

[0029] GPU preprocessing module: Based on GPU parallel computing, preprocesses the hierarchical structure of the assetized file to obtain the rendering parameters of the effective Gaussian sphere nodes;

[0030] Real-time rendering module: Calls the Unity engine to instantiate and render a Gaussian sphere, and performs dynamic Gaussian sphere instantiation and rendering based on view updates.

[0031] Data export module: Uses GPU parallel computing to filter leaf node data in hier format and export it as a PLY format file.

[0032] Third aspect: An electronic device including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor, when executing the program, performs the steps of the method provided in the first aspect.

[0033] Fourth aspect: A non-transitory computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the method provided in the first aspect.

[0034] The beneficial effects of this invention are:

[0035] 1. This invention, through its parsing module, successfully extracts key information from binary tree nodes in hier format files and generates asset files compatible with the Unity engine. This technology solves the problem of existing plugins being unable to utilize hierarchical structures due to missing node information and format incompatibility, enabling Unity to natively recognize and process complex binary tree structures, laying a data foundation for subsequent preprocessing and rendering. The .asset file uniformly manages the format of each data block, enhancing data maintainability and scalability. It ensures that the original data of scenes with tens of millions of Gaussian spheres can be accurately and efficiently loaded into the engine, overcoming the limitation of traditional methods that only support non-hierarchical PLY formats.

[0036] 2. This invention fully utilizes the parallel computing capabilities of the GPU. Based on key node information and preset pixel thresholds, it calculates the node projection size in real time and removes redundant data to generate an optimized IndirectBuffer. Through parallel pruning on the GPU side, the number of Gaussian spheres to be rendered is effectively reduced, significantly lowering the GPU load. Combined with DrawProceduralIndirect instantiation rendering, CPU-GPU interaction overhead is minimized, achieving smooth real-time rendering. In scenes with tens of millions of Gaussian spheres, the frame rate can be increased from the basic level to a stable ≥60fps (or even up to 120fps), meeting the stringent requirements of high frame rate and low latency for large-scale 3D reconstruction applications.

[0037] 3. This invention supports dynamic adjustments based on node information: when the viewpoint changes, the GPU preprocessing module is re-triggered, updating the IndirectBuffer to achieve real-time optimization of the rendered content, enhancing the adaptability of interactive applications. Simultaneously, a technology for exporting hier assets to the universal PLY format has been developed, reusing the GPU parallel framework to filter leaf node data and generate standard files. This solves the pain points of poor functional adaptability and lack of data reuse support in existing technologies. Users can flexibly export data according to their needs, promoting cross-platform or cross-tool data sharing; the dynamic update mechanism ensures that rendering is always based on the optimal dataset for the current viewpoint, balancing performance and visual quality. Attached Figure Description

[0038] Figure 1 This is a schematic flowchart of the method of the present invention;

[0039] Figure 2 This is a flowchart illustrating the principle of the method of the present invention;

[0040] Figure 3 This is a schematic diagram of the structure of the assetization document of this invention;

[0041] Figure 4 This is a schematic diagram of the system structure of the present invention;

[0042] Figure 5 This is a rendering effect diagram of the system of the present invention;

[0043] Figure 6 This is a schematic diagram of the structure of the electronic device of the present invention. Detailed Implementation

[0044] Embodiments of the present invention are described in detail below. Examples of these embodiments are illustrated in the accompanying drawings, wherein the same or similar symbols denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and should not be construed as limiting the present invention.

[0045] The existing Unity engine rendering suffers from problems such as missing node information and format incompatibility, insufficient rendering performance, and poor functional adaptability.

[0046] To address the aforementioned problems, this invention discloses a method and system for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine. To make the objectives, technical solutions, and advantages of this disclosure clearer, the following detailed description is provided in conjunction with specific embodiments.

[0047] Example 1:

[0048] This embodiment discloses a method for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine, such as... Figure 1 As shown, the steps include:

[0049] S1. Parse hier format data, extract basic asset files, hierarchical structure files and metadata, and generate asset files that can be recognized by the Unity engine.

[0050] This update extends the chunk acceleration functionality of the existing Gaussian splash plugin for the Unity engine, enabling hier format data reading and Unity asset file generation. Specifically:

[0051] First, perform hier format data parsing, reuse the existing chunk data recognition function, and focus on extracting binary tree node index information.

[0052] The binary tree node index information includes the parent node index, the starting point of the corresponding Gaussian ball index, the number of leaf Gaussian balls, the number of merged Gaussian balls, the binary tree depth, the starting point of the child node index, and the number of child nodes.

[0053] Based on node index information, a complete hierarchical structure can be constructed, clarifying the position and data relationships of each node in the binary tree. The parent node index determines the current node's parent level, while the child node index starting point and the number of child nodes identify the storage location and number of its subordinate nodes. Through this parent-child node index relationship, the binary tree hierarchy can be traversed level by level. The corresponding Gaussian ball index starting point points to the starting position of the Gaussian ball data contained in that node within the basic asset file. Combined with the number of leaf Gaussian balls, the unmerged original Gaussian ball data under that node can be accurately located and extracted. The number of merged Gaussian balls reflects the amount of merged Gaussian ball data contained in that node. The binary tree depth information provides a basis for formulating subsequent hierarchical loading strategies.

[0054] Simultaneously, node bounding box information is generated. This information is crucial data in hierarchical 3D Gaussian splatter data, describing the spatial extent of the set of Gaussian spheres associated with a binary tree node. In hierarchical format data, each binary tree node corresponds to a bounding box that completely encloses the spatial distribution region of all Gaussian spheres contained in that node and its child nodes. Based on node bounding box information, spatial retrieval and visibility determination can be performed quickly, providing a geometric basis for GPU parallel pruning.

[0055] Node index information and node bounding box information together form the hierarchical structure of the asset file. As the index and spatial description carrier of hierarchical 3D Gaussian splash data assetization, the hierarchical structure plays a dual role as a navigation map and a spatial map in the Unity engine's loading process.

[0056] Simultaneously, the properties of the Gaussian sphere are read to generate a basic asset file. This file includes Gaussian sphere chk block information, col color information, oth rotation and scaling information, and shs spherical harmonic function information. Based on this basic asset file, structured storage and fast access to the Gaussian sphere's fundamental data can be achieved. Specifically, the Gaussian sphere chk block information records the block division and verification information of the Gaussian sphere data in the storage medium, ensuring the integrity and accuracy of data reading; the col color information contains the RGB color values ​​and transparency parameters of each Gaussian sphere, providing basic data support for color rendering; the oth rotation and scaling information covers the rotation angle and scaling ratio data of the Gaussian sphere, directly affecting its posture and size in 3D space; and the shs spherical harmonic function information describes the light reflection characteristics of the Gaussian sphere surface through spherical harmonic coefficients, a key parameter for achieving realistic lighting rendering. By integrating these attribute information into the basic asset file, a solid data foundation is laid for the subsequent construction of hierarchical structures and data loading in the Unity engine.

[0057] Simultaneously, metadata is acquired, which records the size and data format of each basic asset file and assetized file, facilitating the system to quickly identify and adapt different types of file resources during data transmission, storage, and parsing.

[0058] Based on the base asset files, hierarchical structure files, and metadata, generate asset-based files that the Unity engine can recognize, such as... Figure 3 As shown, Figure 3 This describes the relationships between the basic asset files (.bytes suffix), hierarchical structure files (containing key information in node.bytes and box.bytes), and .asset metadata files generated after hier parsing. The basic asset files reuse chunk.bytes and Gaussian sphere attribute.bytes files; the hierarchical structure files use node.bytes to store the seven types of node index information and box.bytes to store bounding box information; and the asset metadata files use the .asset format, recording the size and data format of each .bytes file.

[0059] S2. Based on GPU parallel computing, the hierarchical structure of the asset file is preprocessed. Redundant nodes are pruned by setting pixel thresholds, rendering parameters of effective Gaussian sphere nodes are generated, and the rendering parameter buffer is used for storage.

[0060] Leveraging the parallel computing capabilities of the GPU, the system takes node index information (node.bytes), node bounding box information (box.bytes), and a preset pixel threshold (e.g., 6 pixels) as input. Through parallel computation, combined with attributes such as node depth and the number of child nodes, the ComputeShader instruction is invoked to efficiently calculate the projection size of the node bounding box in the viewport, eliminate redundant nodes with projection sizes smaller than the threshold, extract the valid Gaussian sphere index, and obtain the rendering parameters of the valid Gaussian sphere nodes.

[0061] Furthermore, rendering parameters are stored in an IndirectBuffer generated by the GPU, reducing CPU-GPU interaction and adapting to the video memory management mechanism.

[0062] S3. Based on the rendering parameters of the valid Gaussian sphere node, call the Unity engine to instantiate and load the valid Gaussian sphere data for rendering.

[0063] Load the asset data of each .bytes based on the .asset metadata file, call the Unity engine instantiation rendering method DrawProceduralIndirect(), bind the rendering parameters stored in IndirectBuffer, and use the effective index and attribute data to perform rendering, thereby realizing the parallel instantiation and drawing of Gaussian sphere nodes.

[0064] Based on parameters such as the number of instances and the starting index in the IndirectBuffer, the Unity engine automatically reads the position, scale, rotation, and color attributes of the corresponding valid Gaussian sphere nodes from the GPU memory. Combined with the GPU's parallel computing and rendering capabilities, it efficiently completes the real-time visualization of large-scale hierarchical 3D Gaussian splash data.

[0065] S4. Based on the view update, re-trigger the S2 preprocessing, update the rendering parameters of the valid Gaussian sphere nodes, and dynamically update the Gaussian sphere rendering content.

[0066] When the viewpoint changes, the rendering parameters of the effective Gaussian sphere nodes are recalculated, and the rendered content is dynamically updated to ensure smooth display of scenes with tens of millions of Gaussian spheres. Leveraging the characteristics of hierarchical data structures, high-level Gaussian sphere nodes within the view frustum and key viewing distances are prioritized, while low-level nodes far from the viewpoint or at the edge of the view frustum are simplified or removed. This further optimizes rendering resource allocation while maintaining visual quality, avoiding unnecessary computation that consumes GPU performance. The preprocessing process triggered by viewpoint updates is executed in parallel with the rendering thread. Utilizing Unity's multi-threading mechanism reduces main thread blocking, ensuring frame rate stability during dynamic adjustments, and achieving real-time, efficient, and high-quality visualization of large-scale hierarchical 3D Gaussian splash data under complex viewpoint changes.

[0067] S5. Based on GPU, filter the leaf node data of hier format data and convert it into PLY format file.

[0068] On the GPU, leaf node data in the hier format file is processed in parallel. Based on preset filtering conditions such as spatial range and density threshold, the Gaussian sphere unit set that meets the visualization requirements is quickly located and extracted. The filtered leaf node data is then subjected to coordinate transformation, normal vector calculation, and color information integration, converting it into a standard PLY format data structure containing vertex position, texture coordinates, vertex color, and normal vector.

[0069] like Figure 2 As shown, the method of this invention first loads hier format data assets (reading .asset and .bytes files), then performs GPU node preprocessing (clipping based on key node information), then instantiates and renders, and finally triggers re-preprocessing by updating the viewpoint. These four steps clearly demonstrate the logical connections of the entire rendering process.

[0070] This invention provides an end-to-end closed-loop management method for large-scale hierarchical 3D Gaussian splash data in the Unity engine, from file loading and node filtering to final visualization. By using the loading of hier format data assets as the starting point, the complete import and parsing of the original data is ensured. The GPU node preprocessing stage leverages parallel computing capabilities to efficiently trim the data, reducing the data volume burden for subsequent rendering. The instantiation rendering step generates graphics based on the preprocessed effective data, directly impacting the output of the visualization effect. The re-preprocessing mechanism triggered by viewpoint updates dynamically responds to changes in viewpoint during user interaction, ensuring the accuracy and smoothness of the visualization effect under different viewing angles by adjusting the data set involved in rendering in real time. These four steps are closely linked and work collaboratively to form a complete and efficient solution for loading and displaying hierarchical 3D Gaussian splash data, effectively solving the technical challenge of real-time visualization of large-scale complex data in the Unity engine.

[0071] Example 2:

[0072] This embodiment discloses a system for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine, which is applied to the method described in Embodiment 1.

[0073] like Figure 4 As shown, the system includes a hier file parsing module, an asset generation module, a GPU preprocessing module, a real-time rendering module, and a data export module.

[0074] The hier file parsing module is used to read hier format data and parse the hier format data.

[0075] Develop a hier file parsing module that reuses the existing chunk data recognition function. Focus on extracting key information of binary tree nodes, including parent node index, corresponding Gaussian sphere index starting point, number of leaf Gaussian spheres, number of merged Gaussian spheres, binary tree depth, child node index starting point and number of child nodes, etc. At the same time, read Gaussian sphere attributes, including position, color and sphere harmonic coefficients, as well as node bounding box information.

[0076] The asset generation module converts parsed data into asset files adapted for the Unity engine.

[0077] The asset generation module converts and parses data into Unity engine-recognizable assets, including: basic asset files, including reused chunk.bytes and Gaussian sphere attribute.bytes files; hierarchical structure files, including node.bytes storing seven types of key node information and box.bytes storing bounding box information; and asset metadata files, including .asset format, recording the size and data format of each .bytes file.

[0078] GPU preprocessing module: Based on GPU parallel computing, preprocesses the hierarchical structure of assetized files to obtain rendering parameters for valid Gaussian sphere nodes.

[0079] The GPU preprocessing module, based on the parallel computing capabilities of the GPU, takes node key information (node.bytes), box.bytes, and a preset pixel threshold (e.g., 6 pixels) as input. Through parallel computing, it combines attributes such as node depth and the number of child nodes, calls the ComputeShader instruction, efficiently calculates the projection size of the node bounding box in the viewport, removes redundant nodes with projection sizes smaller than the threshold, and extracts the valid Gaussian sphere index.

[0080] Furthermore, an IndirectBuffer is generated within the GPU to store rendering parameters, reducing CPU-GPU interaction and adapting to the video memory management mechanism.

[0081] Real-time rendering module: Calls the Unity engine to instantiate and render a Gaussian sphere, and performs dynamic Gaussian sphere instantiation and rendering based on view updates.

[0082] The real-time rendering module loads the asset data of each .bytes based on the .asset metadata file, calls the Unity instantiation rendering method (DrawProceduralIndirect()), and binds the valid index and attribute data in the IndirectBuffer for rendering. When the camera view changes, the preprocessing module is triggered to recalculate the validity of nodes and dynamically update the rendering content to ensure smooth display of the scene with tens of millions of Gaussian spheres.

[0083] Data export module: Uses GPU parallel computing to filter leaf node data in hier format and export it as a PLY format file.

[0084] The data export module reuses the GPU parallel framework, filters binary tree leaf nodes based on key node information, extracts the corresponding Gaussian sphere data and writes it to a temporary cache; it reads the cached data to the CPU, organizes and generates files according to the PLY format specification, and supports users to select the export path.

[0085] Application examples:

[0086] Based on Unity 6.0 and above, implemented in the Direct3D12 driver environment, the specific implementation process is as follows: Figure 2 As shown:

[0087] Asset loading phase: Obtain the CityScene.hier file containing 5 million Gaussian spheres, parse it to generate CityScene.asset and files such as chunk.bytes and node.bytes, and store them in the Assets directory.

[0088] GPU preprocessing stage: Import assets, input a 6-pixel threshold, call ComputeShader to prune redundant nodes, generate IndirectBuffer, effectively reducing the amount of rendering data by more than 40%.

[0089] Rendering execution phase: IndirectBuffer performs rendering. In a scene with 5 million Gaussian spheres, the frame rate increases from 60fps to 120fps after clipping. For scenes with tens of millions of spheres, the frame rate is ≥60fps.

[0090] Dynamic update phase: When the viewpoint changes, the IndirectBuffer is re-preprocessed and updated; when export is required, the leaf node data is extracted to generate a PLY file.

[0091] Figure 5 This is a real-time rendering of a scene (city building scene) with tens of millions of Gaussian spheres implemented using the method of this invention in the Unity editor. The bottom of the screen displays the hier asset information, the right side indicates the currently loaded hier asset information (including the total number of Gaussian spheres and pixel threshold settings), the middle window displays the scene rendering effect, and the upper right corner of the window indicates the frame rate (≥60fps), which intuitively demonstrates the smooth rendering performance and image fidelity of this invention in large-scale scenes.

[0092] The present invention also provides an electronic device, Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention, such as... Figure 6As shown, the electronic device may include a processor, a communications interface, memory, and a communication bus, wherein the processor, communications interface, and memory communicate with each other via the communication bus. The processor can invoke logical instructions from the memory, for example, to execute the following method:

[0093] S1. Parse hier format data, extract basic asset files, hierarchical structure files and metadata, and generate asset files that can be recognized by the Unity engine;

[0094] S2. Based on GPU parallel computing, the hierarchical structure of the asset file is preprocessed. Redundant nodes are pruned by setting pixel thresholds, rendering parameters of effective Gaussian sphere nodes are generated, and the rendering parameters are stored using a rendering parameter buffer.

[0095] S3. Based on the rendering parameters of the valid Gaussian sphere node, call the Unity engine to instantiate and load the valid Gaussian sphere data for rendering;

[0096] S4. Based on the view update, re-trigger the S2 preprocessing, update the rendering parameters of the valid Gaussian sphere nodes, and dynamically update the Gaussian sphere rendering content.

[0097] Furthermore, the logical instructions in the aforementioned memory can be implemented as software functional units and sold or used as independent products, and can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or a part 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 the present invention. 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.

[0098] This invention also provides a non-transitory computer-readable storage medium storing a computer program thereon, which, when executed by a processor, is implemented to perform the methods provided in the above embodiments, including, for example:

[0099] S1. Parse hier format data, extract basic asset files, hierarchical structure files and metadata, and generate asset files that can be recognized by the Unity engine;

[0100] S2. Based on GPU parallel computing, the hierarchical structure of the asset file is preprocessed. Redundant nodes are pruned by setting pixel thresholds, rendering parameters of effective Gaussian sphere nodes are generated, and the rendering parameters are stored using a rendering parameter buffer.

[0101] S3. Based on the rendering parameters of the valid Gaussian sphere node, call the Unity engine to instantiate and load the valid Gaussian sphere data for rendering;

[0102] S4. Based on the view update, re-trigger the S2 preprocessing, update the rendering parameters of the valid Gaussian sphere nodes, and dynamically update the Gaussian sphere rendering content.

[0103] The device embodiments described above are merely illustrative. 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 modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0104] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods described in the various embodiments or some parts of the embodiments.

[0105] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications 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 the present invention.

Claims

1. A method for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine, characterized in that, include: S1. Parse the hier format data to generate an asset file recognizable by the Unity engine, wherein the hier format data is Gaussian sphere data organized using a binary tree hierarchical structure; including the following steps: S11. Read hier format data, extract key index information of binary tree nodes, and generate node index data; S12. Extract spatial range data of the Gaussian sphere set associated with each binary tree node, and generate node bounding box data; S13. Read the Gaussian sphere attribute data and generate Gaussian sphere basic attribute data, wherein the basic attribute data includes Gaussian sphere block information, color information, rotation and scaling information, and spherical harmonic function information; S14. Store the node index data, node bounding box data, and Gaussian sphere basic attribute data as hierarchical structure files and basic asset files that can be recognized by the Unity engine, and generate metadata files that record the size and data format of each file to form asset files; S2. The hierarchical structure file is preprocessed based on GPU parallel computing. Redundant nodes are pruned by setting pixel thresholds, rendering parameters for effective Gaussian sphere nodes are generated, and the rendering parameters are stored using a rendering parameter buffer. S3. Based on the rendering parameters of the valid Gaussian sphere node, call the Unity engine to instantiate and load the valid Gaussian sphere data for rendering; S4. Based on the view update, re-trigger the S2 preprocessing, update the rendering parameters of the valid Gaussian sphere nodes, and dynamically update the Gaussian sphere rendering content.

2. The method according to claim 1, characterized in that, Also includes: S5. Based on GPU, filter the leaf node data of hier format data and convert it into PLY format file.

3. The method according to claim 1, characterized in that, The assetization file: The basic asset files include: Gaussian sphere chk block information, col color information, oth rotation and scaling information, and shs spherical harmonic function information; The hierarchical structure file includes: Gaussian sphere node index information and box node bounding box information; The basic asset files and hierarchical structure files are in .bytes format, and the metadata is in .asset format.

4. The method according to claim 3, characterized in that, The Gaussian sphere node index information includes the parent node index, the starting point of the corresponding Gaussian sphere index, the number of leaf Gaussian spheres, the number of merged Gaussian spheres, the binary tree depth, the starting point of the child node index, and the number of child nodes.

5. The method according to claim 3, characterized in that, The rendering parameters for generating valid Gaussian sphere nodes in S2 include: Based on the parallel computing capabilities of the GPU, the system takes the node index information and node bounding box information as input, sets a preset pixel threshold, combines node attributes, calls the ComputeShader instruction to calculate the projection size of the node bounding box in the viewport, removes redundant Gaussian sphere nodes whose projection size is less than the threshold, and extracts the rendering parameters of the valid Gaussian sphere nodes.

6. The method according to claim 5, characterized in that, The rendering parameters in S2 are stored in a rendering parameter buffer, including: An IndirectBuffer is generated within the GPU, and rendering parameters are stored based on the IndirectBuffer.

7. The method according to claim 1, characterized in that, When dynamically updating the Gaussian sphere rendering content in S4, the Unity engine instantiation rendering instruction is called as DrawProceduralIndirect().

8. A system for loading and displaying hierarchical 3D Gaussian splash data in the Unity engine, employing the method described in any one of claims 1 to 7, characterized in that... include: The hier file parsing module is used to read hier format data and parse the hier format data. Asset generation module: Converts parsed data into asset files adapted for the Unity engine, including basic asset files, hierarchical structure files, and metadata; GPU preprocessing module: Based on GPU parallel computing, preprocesses the hierarchical structure of the assetized file to obtain the rendering parameters of the effective Gaussian sphere nodes; Real-time rendering module: Calls the Unity engine to instantiate and render a Gaussian sphere, and performs dynamic Gaussian sphere instantiation and rendering based on view updates; Data export module: Uses GPU parallel computing to filter leaf node data in hier format and export it as a PLY format file.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the steps of the method as described in any one of claims 1 to 7.

10. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method as described in any one of claims 1 to 7.

Images