Data processing method, device, medium and equipment in game

Abstract

This application discloses a data processing method, a data processing device, a computer-readable storage medium, and an electronic device for games. The method includes: acquiring three-dimensional Gaussian splash model data of virtual objects in a target game scene; dividing multiple Gaussian basic units in the three-dimensional Gaussian splash model data into multiple Gaussian basic unit clusters based on the unit attribute parameters of each Gaussian basic unit in the three-dimensional Gaussian splash model data; constructing a collision proxy corresponding to each Gaussian basic unit cluster based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster; and detecting collision events of virtual objects in the target game scene based on the collision proxy and triggering corresponding physical feedback based on the collision events. Thus, this application can realize the implementation of three-dimensional Gaussian splash assets in games by constructing corresponding collision proxies for virtual objects composed of three-dimensional Gaussian splash model data.

Description

Technical Field

[0001] This application relates to the field of three-dimensional Gaussian splashing technology, specifically to a data processing method for games, a data processing device for games, a computer-readable storage medium, and an electronic device. Background Technology

[0002] 3D Gaussian Splatting (3DGS) has gradually become a key focus in game art production due to its high real-time rendering performance and high-quality scene reconstruction capabilities. However, in actual game development, 3DGS struggles to participate in physical interactions within game scenes. For example, because 3DGS assets are typically composed of hundreds of thousands of semi-transparent ellipsoidal primitives with soft-boundary probabilistic characteristics, 3DGS is incompatible with the collision detection algorithms used by game physics engines, which are based on defined geometric boundaries, thus making it unsuitable for game physics engine integration. Consequently, 3DGS is often used only as a visual background in game scenes and cannot be used to construct an interactive game world for players. Summary of the Invention

[0003] This application provides a data processing method, a data processing device, a computer-readable storage medium, and an electronic device for games. By constructing a corresponding collision proxy for virtual objects composed of 3D Gaussian splash model data, the game physics engine can identify the collision range of different parts of the virtual object through the collision proxy. This enables the 3D Gaussian splash model data, which was originally only visually rendered, to achieve physical effects such as stepping, collision, and interaction, thus realizing the implementation of 3D Gaussian splash assets in games.

[0004] On one hand, embodiments of this application provide a data processing method for games, the method comprising: Obtain three-dimensional Gaussian splash model data of virtual objects in the target game scene, wherein the three-dimensional Gaussian splash model data includes multiple Gaussian basic units and unit attribute parameters of each Gaussian basic unit. The unit attribute parameters include at least a covariance matrix parameter and a mean vector. The covariance matrix parameter is used to indicate the shape of the Gaussian basic unit, and the mean vector is used to indicate the position of the midpoint of the Gaussian basic unit. Based on the unit attribute parameters of each Gaussian basic unit, the plurality of Gaussian basic units are divided into a plurality of Gaussian basic unit clusters, wherein each Gaussian basic unit cluster includes at least one Gaussian basic unit. Based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster, a collision proxy is constructed corresponding to each Gaussian basic unit cluster. The collision proxy is used to indicate the collision range of a portion of virtual objects in the target game scene. The portion of virtual objects is constructed by the Gaussian basic units within the Gaussian basic unit cluster. Based on the collision proxy, collision events of the virtual objects in the target game scene are detected, and corresponding physical feedback is triggered based on the collision events.

[0005] On the other hand, embodiments of this application provide a data processing device for games, the device comprising: The acquisition module is used to acquire three-dimensional Gaussian splash model data of virtual objects in the target game scene. The three-dimensional Gaussian splash model data includes multiple Gaussian basic units and unit attribute parameters of each Gaussian basic unit. The unit attribute parameters include at least a covariance matrix parameter and a mean vector. The covariance matrix parameter is used to indicate the shape of the Gaussian basic unit, and the mean vector is used to indicate the position of the midpoint of the Gaussian basic unit. A partitioning module is used to partition the plurality of Gaussian basic units into a plurality of Gaussian basic unit clusters according to the unit attribute parameters of each Gaussian basic unit, wherein each Gaussian basic unit cluster includes at least one Gaussian basic unit. A construction module is used to construct a collision proxy corresponding to each Gaussian basic unit cluster based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster. The collision proxy is used to indicate the collision range of a portion of virtual objects in the target game scene. The portion of virtual objects is constructed by the Gaussian basic units within the Gaussian basic unit cluster. The detection module is used to detect collision events of the virtual objects in the target game scene based on the collision proxy, and trigger corresponding physical feedback based on the collision events.

[0006] On the other hand, embodiments of this application provide a computer-readable storage medium storing a computer program adapted for loading by a processor to execute the data processing method in a game as described in any of the above embodiments.

[0007] On the other hand, embodiments of this application provide an electronic device, which includes a processor and a memory. The memory stores a computer program, and the processor executes the data processing method in the game as described in any of the above embodiments by calling the computer program stored in the memory.

[0008] On the other hand, embodiments of this application provide a computer program product, including computer instructions, which, when executed by a processor, implement the data processing method in a game as described in any of the above embodiments.

[0009] The data processing method, data processing device, computer-readable storage medium, electronic device, and computer program product provided in this application can acquire three-dimensional Gaussian splash model data of virtual objects in a target game scene, and divide multiple Gaussian basic units in the three-dimensional Gaussian splash model data into multiple Gaussian basic unit clusters according to the unit attribute parameters of each Gaussian basic unit in the three-dimensional Gaussian splash model data, and construct a collision proxy corresponding to each Gaussian basic unit cluster according to the unit attribute parameters of each Gaussian basic unit in each Gaussian basic unit cluster, and detect collision events of the virtual objects in the target game scene based on the collision proxy and trigger corresponding physical feedback based on the collision events. Thus, by constructing corresponding collision proxies for virtual objects composed of three-dimensional Gaussian splash model data, the game physics engine can identify the collision range of different parts of the virtual object through the collision proxy, thereby enabling the three-dimensional Gaussian splash model data, which could originally only be visually rendered, to realize physical effects such as trampling, collision, and interaction, realizing the implementation of three-dimensional Gaussian splash assets in the game. Furthermore, without reconstructing the geometric mesh from 3D Gaussian splash model data, the adaptation of 3D Gaussian splash assets to game physics can be achieved directly through processing native data such as the covariance matrix parameters, opacity parameters, and mean vector of Gaussian basic units. This simplifies the adaptation process and reduces art production costs. Additionally, by clustering local regions using Gaussian basic units, overall collision detection is broken down into local proxy detection, which reduces computational load to some extent, ensuring real-time performance and smooth gameplay. Attached Figure Description

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

[0011] Figure 1 This is one of the flowcharts illustrating a data processing method in a game provided in an embodiment of this application.

[0012] Figure 2 This is a second flowchart illustrating the data processing method in a game provided in this application embodiment.

[0013] Figure 3 This is the third flowchart illustrating the data processing method in a game provided in this application embodiment.

[0014] Figure 4 This is the fourth flowchart illustrating the data processing method in a game provided in this application embodiment.

[0015] Figure 5 The fifth flowchart illustrates the data processing method in a game provided in this application embodiment.

[0016] Figure 6 This is the sixth flowchart illustrating the data processing method in a game provided in this application embodiment.

[0017] Figure 7 This is the seventh flowchart illustrating the data processing method in a game provided in this application embodiment.

[0018] Figure 8 This is a schematic diagram of the collision proxy generation process provided in an embodiment of this application.

[0019] Figure 9 This is a schematic diagram illustrating the process of binding collision agents to skeletal joints as provided in an embodiment of this application.

[0020] Figure 10 This is a schematic diagram of the collision proxy update process provided in an embodiment of this application.

[0021] Figure 11 This is a schematic diagram of the structure of a data processing device in a game provided in an embodiment of this application.

[0022] Figure 12 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Detailed Implementation

[0023] 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. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0024] This application provides a data processing method, a data processing device, a computer-readable storage medium, and an electronic device for games. Specifically, the data processing method for games in this application can be executed by an electronic device, which can be a terminal or a server. The terminal can be a smartphone, tablet, laptop, smart TV, wearable smart device, smart vehicle terminal, etc. The terminal can also include a client, which can be a browser client, instant messaging client, or mini-program, etc. The server can be an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, content delivery networks (CDN), and big data and artificial intelligence platforms.

[0025] It should be noted that, in this embodiment, the execution entity of the data processing method in the game can be a terminal device or a server. The terminal device can be a local terminal device or a client device in a cloud platform. This embodiment does not limit the type of execution entity.

[0026] For example, when the data processing method in the game runs on a terminal device, the terminal device may include a display screen and a processor. The display screen is used to present a graphical user interface (GUI) and receive instructions generated by the user interacting with the GUI. The processor is used to store applications, generate the GUI, respond to instructions, and control the display of the GUI on the display screen. When the user operates the GUI through the display screen, the GUI can control the local content of the terminal device in response to the received operation instructions. The terminal device can provide the GUI to the user in various ways, such as rendering it on the terminal device's display screen or presenting the GUI through holographic projection.

[0027] For example, when the data processing method in the game runs on a server, this method can be implemented and executed based on a cloud system. The cloud system includes servers and client devices. The application's runtime and the graphical user interface (GUI) presentation are separate. The storage and execution of the game's data processing methods are completed on the server. The GUI presentation, however, is completed on the client. The client is primarily used for receiving and sending data and for presenting the GUI. For example, the client can be a display device with data transmission capabilities located close to the user, such as a mobile terminal, television, computer, PDA, personal digital assistant, or head-mounted display. However, the terminal device performing data processing is the server in the cloud. During this process, the user operates the client to send instructions to the server. The server executes the instructions, encodes and compresses the GUI data, returns it to the client via the network, and finally, the client decodes and outputs the GUI.

[0028] It should be noted that, in this embodiment, the execution entity of the data processing method in the game can be a terminal device or a server. The terminal device can be a local terminal device or a client device in the aforementioned cloud system. This embodiment does not limit the type of execution entity.

[0029] The technical solution of this application will be described in detail below through specific embodiments. It should be noted that the following specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0030] In recent years, 3D Gaussian Splatting (3DGS) technology has become an important candidate technology for game art content production due to its excellent real-time rendering performance and high-quality scene reconstruction capabilities. This technology represents a 3D scene as a set of Gaussian primitives, each of which is described by four parameters: mean vector, covariance matrix, opacity, and spherical harmonic coefficient.

[0031] In practical applications, artists can use 3DGS technology to train real-world scenes or reference assets, quickly obtaining high-quality 3D scene assets with photorealistic qualities—these are 3DGS assets. Then, by sorting Gaussian primitives by depth and performing alpha blending, a rendering process can be achieved, reaching real-time frame rates on consumer-grade graphics processing units (GPUs). However, a fundamental obstacle hinders the practical implementation of 3DGS assets in games: 3DGS assets cannot participate in game physics interactions.

[0032] For example, game physics engines' collision detection systems can only handle well-defined geometric primitives, including convex hulls, axis-aligned bounding boxes (AABBs), spheres, and capsules. Game engines typically employ algorithms such as the Gilbert–Johnson–Keerthi algorithm (GJK), the Separating Axis Theorem (SAT), or Bounding Volume Hierarchy. These algorithms require inputs of geometric shapes with clearly defined vertex and face information, or geometric primitives that can be described analytically. However, 3DGS assets are essentially collections of numerous semi-transparent ellipsoidal primitives, whose soft-boundary probability distribution characteristics are incompatible with these requirements. Consequently, in 3DGS-rendered scenes, players cannot step on the ground, cannot collide with props, and character actions cannot trigger physical responses. 3DGS assets are merely "pretty background images" and cannot become an interactive game world.

[0033] For example, in game animation systems, skeletal skinning animation is the standard animation method for characters and movable objects. Skeletal transformations (i.e., joint rotation and displacement) are passed to mesh vertices through skinning weights, thereby driving character movement. 3DGS assets with skeletal animation need to be able to update in real time as the skeleton's pose changes; otherwise, the collision shape will not match the visible appearance.

[0034] To address the issue of 3DGS assets being unable to participate in game physics interactions, various methods for integrating 3DGS assets into the game's physics system have been proposed in related technologies. However, these methods have several drawbacks, as detailed below: First, Gaussian splatting geometry extraction methods introduce significant offline computational overhead during application. For example, the Surface-Aligned Gaussian Splatting (SuGaR) method extracts usable geometric meshes from 3DGS models by adding surface alignment regularization during training and then extracting triangular meshes via Poisson reconstruction. However, the SuGaR method consumes a considerable amount of time in the regularization fine-tuning stage, and collision extraction is subsequently performed on the mesh. This entire process is offline and cannot meet the efficiency requirements during the game asset import phase. Furthermore, the SuGaR method outputs a generic triangular mesh, rather than a collision descriptor format that can be directly used by the game physics engine, requiring additional format conversion steps, and it does not provide LOD grading or skeletal linkage mechanisms.

[0035] Secondly, the Gaussian Splatting for Physics-Based Simulations (GASP) method achieves physical simulation of Gaussian splatting (GS) objects by transforming flattened Gaussians into triangular patches and integrating them with the Material Point Method (MPM) physics engine. This method typically utilizes a balanced iterative reduction and clustering using hierarchies (BIRCH) clustering acceleration strategy. However, this strategy only uses the center position information of Gaussian elements, resulting in poor clustering quality for shapes such as slender rods and thin plates. Furthermore, GASP's output is geared towards MPM simulation and does not provide outputs similar to PhysX, the Bullet physics simulation engine, or the Havok game dynamics development kit. It lacks Level of Detail (LOD) grading and a skeletal skinning linkage mechanism, and its computational speed cannot meet the real-time requirements of game runtime.

[0036] Third, while methods using Large Language Models (LLMs) to understand natural language descriptions and generate physical properties (such as PhysTalk) can generate single convex hull collision proxies for 3D objects, a single convex hull cannot accurately represent objects with concave structures, such as door frames, chairs, and letter shapes. Furthermore, online LLM calls introduce unacceptable network latency and uncertainty. This method fails to provide a stable frame budget guarantee mechanism for real-time game interaction and lacks LOD grading and incremental skeletal update mechanisms.

[0037] Fourth, the Gaussian Splatting for Virtual Environment Rendering and Scene Editing (GS-Verse) method achieves physical interaction in Virtual Reality (VR) scenes by directly binding pre-existing high-quality triangular mesh assets to Gaussian point clouds as collision proxies. However, this method inherently relies on pre-existing high-quality meshes, extracting them through offline tools such as SuGaR and TRELLIS, thus not simplifying the art workflow. Furthermore, the collision interface provided by this method only uses Unity's high-level Application Programming Interface (API) instead of the engine's native descriptors, lacks LOD levels, and does not support skeletal skinning linkage.

[0038] Fifth, existing skeletal collision methods in the game industry, such as PhysXRagdoll, require artists to manually attach collision capsules or convex hulls to each bone of each character. For 3DGS assets trained from real-world shooting, the cost of manual annotation completely contradicts the advantages of automated 3DGS production, creating a significant workflow disruption.

[0039] In summary, current 3DGS technology still faces several obstacles in the practical application of game physics interaction. There is an urgent need for a solution that can efficiently and automatically generate collision descriptors adapted to the game physics engine for 3DGS assets and support LOD grading and skeletal skinning linkage.

[0040] For the above issues, please refer to Figure 1 , Figure 1 This is a flowchart illustrating a data processing method in a game provided in an embodiment of this application. It should be noted that the steps shown may be executed in a logical order different from that shown in the flowchart. The method includes: 110: Obtain the 3D Gaussian splash model data of virtual objects in the target game scene. The 3D Gaussian splash model data includes multiple Gaussian basic units and the unit attribute parameters of each Gaussian basic unit. The unit attribute parameters include at least the covariance matrix parameter and the mean vector. The covariance matrix parameter is used to indicate the shape of the Gaussian basic unit, and the mean vector is used to indicate the position of the midpoint of the Gaussian basic unit. 120: Based on the element attribute parameters of each Gaussian element, multiple Gaussian elements are divided into multiple Gaussian element clusters, wherein each Gaussian element cluster includes at least one Gaussian element. 130: Based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster, construct a collision proxy corresponding to each Gaussian basic unit cluster. The collision proxy is used to indicate the collision range of some virtual objects in the target game scene. Some virtual objects are constructed from Gaussian basic units within the Gaussian basic unit cluster. 140: Based on collision proxy, detect collision events of virtual objects in the target game scene, and trigger corresponding physical feedback based on the collision events.

[0041] Specifically, 3D Gaussian Splatting (3DGS) technology can quickly generate photorealistic virtual object assets required for games. However, these assets are composed of a large number of Gaussian basic units and lack standard collision geometry structures such as geometric meshes and convex hulls that can be recognized by traditional game physics engines. As a result, 3DGS virtual objects can only serve as "backgrounds" for pure visual rendering and cannot participate in game physics events such as trampling, collision, and interaction. This has become the main obstacle to the actual implementation of 3DGS technology in games.

[0042] Based on this, this application proposes a data processing method for games, which directly relies on the original data of the 3D Gaussian splash model, divides it by Gaussian basic unit clustering and constructs corresponding collision proxies, and finally realizes the collision event detection and response of virtual objects based on the collision proxies, so that 3DGS virtual objects have the ability to interact with game physics.

[0043] In some embodiments, the target game scene can be understood as a three-dimensional interactive space loaded during game runtime, in which virtual objects exist and physically interact.

[0044] In some embodiments, virtual objects can be understood as game entities in a scene rendered by a three-dimensional Gaussian splash model, including characters, props, scene buildings, etc.

[0045] In some embodiments, three-dimensional Gaussian splash model data can be understood as virtual object data constructed using 3DGS technology.

[0046] In some embodiments, the Gaussian basic unit can be understood as the smallest constituent unit of a three-dimensional Gaussian splash model, which is an ellipsoidal basic rendering primitive.

[0047] In some embodiments, the unit attribute parameters can be understood as a set of parameters describing the characteristics of the Gaussian basic unit itself, and are the main components of the three-dimensional Gaussian splash model data.

[0048] In some embodiments, the covariance matrix parameter can be understood as one of the element attribute parameters, used to define the three-dimensional shape, orientation, and anisotropy scale of the Gaussian basic element.

[0049] In some embodiments, the mean vector can be understood as one of the element attribute parameters, used to mark the center position coordinates of the Gaussian fundamental element in three-dimensional space.

[0050] In some embodiments, a Gaussian basic unit cluster can be understood as a set of Gaussian basic units formed after being classified according to attribute parameters, corresponding to a local physical region of a virtual object.

[0051] In some embodiments, a collision proxy can be understood as a simplified geometric collider constructed for a Gaussian basic unit cluster, recognizable by the physics engine, used to characterize the local collision extent of a virtual object.

[0052] In some embodiments, a collision event can be understood as a game-triggered event in which a virtual object comes into spatial contact or collides with other objects or characters in the scene.

[0053] In some embodiments, physical feedback can be understood as the corresponding physical response executed by the game physics engine after a collision event is triggered.

[0054] In some examples, physical feedback includes in-game physical response effects such as collision blocking, object displacement, force-induced scattering, and character stun upon being hit.

[0055] To more clearly illustrate the data processing method in the game provided in the embodiments of this application, please refer to the following exemplary description: First, the electronic device acquires the 3D Gaussian splash model data of the virtual object in the target game scene. The core of this data consists of multiple Gaussian basic units, as well as the covariance matrix parameter, opacity parameter, and mean vector of each unit. These three types of attribute parameters define the shape, transparency, and spatial position of the unit, respectively, providing raw data support for all subsequent processing steps.

[0056] Then, based on the aforementioned attribute parameters of each Gaussian basic unit, the electronic device divides the scattered Gaussian basic units into multiple Gaussian basic unit clusters, with each cluster containing at least one unit. Based on this, the virtual object as a whole can be split into multiple local physical regions, avoiding computational redundancy caused by overall processing and allowing the subsequently constructed collision proxy to better fit the local shape of the virtual object.

[0057] Subsequently, the electronic device constructs a corresponding collision proxy for each Gaussian basic unit cluster, utilizing the attribute parameters of all Gaussian basic units within the cluster. It can be understood that the collision proxy is a local virtual object constructed from the units within the corresponding cluster, which can be recognized by the physics engine.

[0058] Finally, the electronic device uses the constructed collision proxy as its core basis to detect whether virtual objects are experiencing collision events in the target game scene in real time. When a virtual object is detected to be in contact with other objects, physical feedback corresponding to the collision event is triggered, thereby realizing the physical interaction of the 3D Gaussian splash model virtual object in the game.

[0059] Thus, in this embodiment, three-dimensional Gaussian splash model data of virtual objects in the target game scene can be obtained. Based on the unit attribute parameters of each Gaussian basic unit in the three-dimensional Gaussian splash model data, the multiple Gaussian basic units in the three-dimensional Gaussian splash model data are divided into multiple Gaussian basic unit clusters. Based on the unit attribute parameters of each Gaussian basic unit in each Gaussian basic unit cluster, a collision proxy corresponding to each Gaussian basic unit cluster is constructed. Based on the collision proxy, collision events of virtual objects in the target game scene are detected, and corresponding physical feedback is triggered based on the collision events. Thus, by constructing corresponding collision proxies for virtual objects composed of three-dimensional Gaussian splash model data, the game physics engine can identify the collision range of different parts of the virtual object through the collision proxy. This enables the three-dimensional Gaussian splash model data, which could originally only be visually rendered, to achieve physical effects such as stepping, collision, and interaction, realizing the implementation of three-dimensional Gaussian splash assets in the game. Furthermore, without reconstructing the geometric mesh from 3D Gaussian splash model data, the adaptation of 3D Gaussian splash assets to game physics can be achieved directly through processing native data such as the covariance matrix parameters, opacity parameters, and mean vector of Gaussian basic units. This simplifies the adaptation process and reduces art production costs. Additionally, by clustering local regions using Gaussian basic units, overall collision detection is broken down into local proxy detection, which reduces computational load to some extent, ensuring real-time performance and smooth gameplay.

[0060] Please see Figure 2 In some embodiments provided in this application, the unit attribute parameters further include an opacity parameter, thus step 120 above includes: 121: Based on a predetermined opacity threshold and the opacity parameter of each Gaussian basic unit, multiple Gaussian basic units are filtered to obtain multiple active Gaussian basic units with opacity parameters greater than the opacity threshold. 122: Based on the cell attribute parameters of each active Gaussian basic cell, multiple active Gaussian basic cells are divided into multiple Gaussian basic cell clusters.

[0061] Specifically, if all Gaussian basic units in the 3D Gaussian splash model data are processed directly, the presence of a large number of low-opacity Gaussian basic units in the 3D Gaussian splash model will increase computational redundancy. This is because the 3D Gaussian splash model contains a large number of low-opacity Gaussian basic units, which correspond to areas of virtual objects such as smoke, halo, and semi-transparent effects that have no physical collision significance. Therefore, the participation of these units in the determination process of Gaussian basic unit clusters will also cause the Gaussian basic unit clusters to deviate from the real physical rigid body area of ​​the virtual object, ultimately reducing the accuracy of collision proxy construction and affecting the accuracy and smoothness of game physics interaction.

[0062] Based on this, in some embodiments provided in this application, the electronic device first removes low-opacity Gaussian basic units that have no collision significance by using a preset threshold, retains only the effective units with high opacity, and then performs clustering on the effective units to optimize the clustering data quality from the source and improve processing efficiency and result accuracy.

[0063] In some embodiments, the opacity parameter can be understood as one of the unit attribute parameters, representing the transparency of the Gaussian basic unit, and can distinguish between solid surfaces and semi-transparent effect areas.

[0064] In some embodiments, the opacity parameter is obtained during the training process of the three-dimensional Gaussian splash.

[0065] In some embodiments, Gaussian basic units with high opacity parameters correspond to the surfaces of entities in the scene, i.e., the locations where physical collisions occur. Gaussian basic units with low opacity parameters correspond to semi-transparent effects such as smoke and halos, i.e., locations without physical collision significance.

[0066] In some embodiments, the opacity threshold can be understood as a pre-set numerical standard used to determine whether Gaussian basic units possess entity collision properties, and is the main basis for screening active Gaussian basic units. The selection of the opacity threshold directly affects the size of the Gaussian basic unit cluster, and an opacity threshold that is too low may lead to the introduction of a large number of noisy Gaussians, while an opacity threshold that is too high will cause Gaussians on thin surfaces to be excessively removed.

[0067] In some embodiments, the opacity threshold ranges from [0.3, 0.8].

[0068] In some embodiments, the opacity threshold is determined by a user's threshold input operation.

[0069] In some embodiments, the opacity threshold is set based on the percentile of the opacity parameter value of each Gaussian basic unit in the 3D Gaussian splatter model data. For example, the opacity threshold may be the 75th percentile of the opacity parameter value of each Gaussian basic unit in the 3D Gaussian splatter model data.

[0070] In some embodiments, an active Gaussian basic unit can be understood as a Gaussian basic unit with an opacity parameter higher than a preset threshold, corresponding to the physical surface area of ​​a virtual object, and is a core processing unit with physical collision value.

[0071] In some embodiments, the filtering process can be understood as comparing and eliminating all Gaussian basic units based on an opacity threshold, retaining valid units and removing invalid interfering units.

[0072] To more clearly illustrate the screening process for active Gaussian fundamental units in the embodiments of this application, please refer to the following exemplary description: First, let the 3D Gaussian splash model data of the virtual objects in the target game scene be... G The 3D Gaussian splash model data includes N Gaussian basic unit g Furthermore, the three-dimensional Gaussian splash model data G It can be expressed as the following formula (1). G Medium Gaussian basic unit g This can be expressed as the following formula (2), namely: (1) (2) In the formula, μ i Indicates the first i The mean vector of Gaussian fundamental units, Σ i Indicates the first i The covariance matrix parameters of the Gaussian fundamental elements, α i Indicates the first i The opacity parameter of each Gaussian fundamental unit, c i Indicates the first i The spherical harmonic coefficients of a Gaussian fundamental element.

[0073] Finally, based on the pre-set opacity filtering threshold... θ ,right G Perform filtering to obtain the set of active Gaussian fundamental units. G * The screening process can be expressed by the following formula (3), namely: (3) Thus, in this embodiment, multiple Gaussian basic units (Gaussian basic units) can be filtered according to a predetermined opacity threshold and the opacity parameter of each Gaussian basic unit to obtain multiple active Gaussian basic units with opacity parameters greater than the opacity threshold. Based on the unit attribute parameters of each active Gaussian basic unit, these active Gaussian basic units are then divided into multiple Gaussian basic unit clusters. This eliminates low-opacity invalid Gaussian basic units, reducing the difficulty of Gaussian basic unit cluster division and meeting the performance requirements of real-time game operation. Furthermore, the division of Gaussian basic unit clusters can be performed on active units on the surface of virtual object entities, avoiding interference from semi-transparent effect units. This ensures a high degree of matching between the Gaussian basic unit clusters and the physical rigid body region, thereby guaranteeing the effectiveness of the collision proxy built based on the Gaussian basic unit clusters and reducing false positives and false negatives in collision detection.

[0074] Furthermore, the screening process only requires comparing the opacity parameter, without complex calculations, and is completed entirely at the Gaussian basic unit level, without the need to rebuild the geometric mesh, thus meeting the needs of rapid import of game assets.

[0075] Please see Figure 3 In some embodiments provided in this application, step 122 above includes: 1220: Based on the cell attribute parameters of each active Gaussian basic unit, multiple active Gaussian basic units are clustered to obtain multiple Gaussian basic unit clusters.

[0076] Specifically, the virtual objects constructed using the 3D Gaussian splash model consist of hundreds of thousands of Gaussian primitives. Even after filtering out semi-transparent Gaussians such as smoke and halos that have no physical collision significance through opacity filtering, the resulting active Gaussian primitives are still in a discrete and disordered state, and cannot be directly used to construct collision proxies that can be recognized by the game physics engine. At the same time, if Gaussian primitives are divided solely based on simple spatial location, the shape, scale, and other attributes of Gaussians themselves will be completely ignored, resulting in a serious mismatch between the division results and the actual physical rigid body regions of the virtual objects. This will not only significantly increase the computational load of subsequent collision proxy construction, but also cause problems such as insufficient collision detection accuracy and distorted physical interaction, failing to meet the requirements of real-time physical interaction in games.

[0077] Based on this, in some embodiments provided in this application, the electronic device can use the unit attribute parameters of the active Gaussian as a basis to organize the discrete and disordered active Gaussian into multiple Gaussian basic unit clusters through clustering processing, and split the virtual object into multiple local processing units that fit its own physical structure, so as to provide a reliable foundation for the subsequent accurate construction of collision proxy.

[0078] In some embodiments, clustering can be understood as taking the selected active Gaussian basic units as the processing object, calculating the similarity and distance between units based on the unit attribute parameters (mean vector, covariance matrix, etc.) of each unit, and automatically merging discrete Gaussian basic units that are spatially adjacent and match in shape / scale / orientation features into several sets of Gaussian basic units with unified internal features, mutual independence, and corresponding to local physical rigid body regions of virtual objects through automated algorithms.

[0079] For example, taking a virtual character in a game as an example, the character's virtual model consists of 500,000 Gaussian basic units, covering parts such as the head, torso, arms, hands, and legs. After filtering by an opacity threshold, active Gaussian basic units for the skin, equipment, and other physical surfaces are retained from the 500,000 Gaussian basic units. Then, based on these active Gaussian basic units, according to their position and shape characteristics, the head Gaussian units are grouped into a head cluster, the upper arm Gaussian units into an upper arm cluster, the hand Gaussian units into a hand cluster, and the thigh Gaussian units into a thigh cluster, ultimately forming multiple clusters of active Gaussian basic units that perfectly match the rigid body partitions of the human skeleton. Subsequently, a corresponding collider is generated for each cluster.

[0080] For example, in a virtual table and chair model composed of Gaussian basic units such as tabletops, table legs, chair backs, and chair legs, some Gaussian units are flat, such as the tabletop and chair back, while others are long and thin, such as the table legs / chair legs. Furthermore, flat, planar tabletop Gaussian units are grouped into a tabletop cluster, and the four long, vertically distributed table leg Gaussian units are grouped into four table leg clusters. The chair back and chair legs are similarly partitioned. This allows for precise separation of the rigid body components of the table and chair, preventing the tabletop and table legs from being incorrectly merged into a single cluster and ensuring that the collision proxy conforms to the shape of the table and chair.

[0081] In some embodiments, a Gaussian basic unit cluster can be understood as a collection of Gaussian basic units formed after clustering, and each collection contains at least one active Gaussian basic unit, corresponding to an independent local physical rigid body region of the virtual object.

[0082] Thus, in this embodiment, multiple active Gaussian basic units can be clustered according to the unit attribute parameters of each active Gaussian basic unit to obtain multiple Gaussian basic unit clusters. This transforms discrete active Gaussian basic units into ordered unit cluster structures, greatly simplifying the subsequent collision proxy construction process, reducing computational redundancy during game runtime, and ensuring the real-time performance of physical interactions.

[0083] Please see Figure 4 In some embodiments provided in this application, step 1220 includes: 1221: Determine the inter-cell distance between any two active Gaussian basic units based on the mean vector and covariance matrix parameters of each active Gaussian basic unit. 1222: Based on the inter-element distance between pairs of active Gaussian basic elements and the maximum principal axis radius of each Gaussian basic element, multiple active Gaussian basic elements are divided into multiple Gaussian basic element clusters. The maximum principal axis radius is obtained by eigenvalue decomposition of the covariance matrix parameters of the Gaussian basic elements.

[0084] Specifically, when clustering active Gaussian basic units of a 3D Gaussian splash model, if only the Euclidean distance at the center of the Gaussian unit is used to determine similarity, the shape differences of the Gaussian basic units will be ignored. This will cause Gaussian basic units with anisotropic geometric structures such as slender rods, thin plates, and flat walls to be incorrectly merged. The clustering results will not match the actual physical rigid body region of the virtual object. The collision proxy constructed subsequently will have problems such as shape distortion and collision range deviation, which will not meet the accuracy requirements of game physics interaction.

[0085] Based on this, in some embodiments provided in this application, the electronic device can calculate the distance between two units by using the mean vector and covariance matrix of the active Gaussian basic unit, and then combine the maximum principal axis radius obtained by the eigenvalue decomposition of the covariance matrix to complete the clustering of the active Gaussian basic unit, so that the clustering result fits the physical rigid body partition of the virtual object.

[0086] In some embodiments, the inter-cell distance can be understood as an anisotropic weighted distance combining the position and shape of the Gaussian fundamental cell, used to measure the spatial and shape similarity between two active Gaussian fundamental cells.

[0087] In some embodiments, the maximum principal axis radius can be understood as the radius value with the largest scale among the three principal axis directions obtained after performing eigenvalue decomposition on the covariance matrix of the Gaussian basic unit, representing the maximum coverage of the Gaussian basic unit.

[0088] In some embodiments, eigenvalue decomposition can be understood as a mathematical processing operation on the covariance matrix, which can decompose the covariance matrix into rotation matrix and scaling matrix, and then extract the principal axis orientation and radius parameters of each direction of the Gaussian basic unit.

[0089] To more clearly illustrate the clustering process in the embodiments of this application, please refer to the following exemplary description: For any Gaussian fundamental unit g i In terms of Gaussian fundamental units g i covariance matrix Σ i It is a symmetric positive definite matrix, and Σ i It can be decomposed into the case shown in the following formula (4), that is: (4) In the formula, Ri For the first i The rotation matrix of the nth Gaussian fundamental element, used to describe the nth Gaussian fundamental element. i The principal axis orientation of each Gaussian fundamental element. i For the first i The scaling matrix of the nth Gaussian fundamental unit, used to describe the nth i The radii of a Gaussian fundamental element in the three principal axis directions. s (max,i) For the first i The maximum principal axis radius of the Gaussian fundamental element is also used to describe the first Gaussian fundamental element. i The characteristic scale of the Gaussian coverage of a Gaussian fundamental unit. R i ∈ SO (3), SO (3) is a special orthogonal group in 3D. S i This can be expressed as the following formula (5), namely: (5) In the formula, s (x,i) , s (y,i) , s (z,i) They represent the first i The Gaussian fundamental unit in x Radius in the axial direction y Radius in the axial direction z The radius along the axial direction.

[0090] by G The first in i Gaussian basic unit g i and the j Gaussian basic unit g j For example, the first i Gaussian basic unit g i and the j Gaussian basic unit g j The inter-unit distance between the two can be calculated using formula (6). d Σ( g i , g j ),Right now: (6) In the formula, (Σ i +Σ j) -1 This can be understood as the first i Gaussian basic unit g i and the j Gaussian basic unit g j The inverse of the joint covariance matrix of these two Gaussian fundamental units, (Σ i +Σ j ) -1 A smaller penalty is applied to the positional difference in the common coverage direction of two Gaussian basic units so that the two Gaussian basic units can be merged together. At the same time, since the Gaussian basic units are geometrically separate, a larger penalty can be applied to the positional difference perpendicular to their coverage direction.

[0091] For example, suppose g i and g j For two flat Gaussian planes representing the walls, g i and g j Within the same wall surface, if there is a significant offset along the wall direction but no offset in the vertical direction, then d Σ( g i , g j The perceived distance will give a smaller value, tending to... g i and g j They cluster together in the same group. For example, suppose... g i and g j One represents the wall, and the other represents the floor; therefore, their principal axes of covariance are orthogonal. Even if... g i and g j The Euclidean distance between the element centers of these two Gaussian basic elements is close. d Σ( g i , g j It will also give a larger value, tending to g i and g j They were assigned to different clusters.

[0092] To accommodate the spatial non-uniformity at the Gaussian scale in the scene, the maximum principal axis length of each Gaussian basic unit can be used as a basis. s (max,i)Adaptively set the local clustering neighborhood radius of each Gaussian fundamental unit i , i It can be obtained through formula (7), that is: (7) In the formula, γ is a hyperparameter, which is also a global scaling factor used to control the clustering granularity.

[0093] Finally, based on the above i and inter-unit distance d Σ( g i , g j ), employing density-adaptive clustering strategies, such as the improved density-based spatial clustering of applications with noise (DBSCAN) variant, to d Σ( g i , g j Replace the standard Euclidean distance with i Replace the fixed neighborhood radius, and configure the minimum number of neighborhood samples (minPts), noise point removal strategy, and termination condition (such as no new effective clusters or iteration limit triggering) for the active Gaussian basic unit set obtained after screening. G * Clustering is performed to obtain a set of Gaussian fundamental unit clusters consisting of multiple Gaussian fundamental unit clusters. The system outputs a set of noise points for subsequent fault-tolerant processing. Each Gaussian basic unit cluster corresponds to a rigid body region in the virtual object, which is also an independent physical collision unit in the virtual object. The noise point set can be processed according to at least one of the following strategies: nearest cluster adsorption, guaranteed proxy generation, or threshold removal, before entering the subsequent convex decomposition step.

[0094] Gaussian fundamental unit cluster set Each cluster in the equation can be expressed as shown in equation (8), that is: (8) In some embodiments, the noise point set may be processed according to at least one of the following strategies: nearest cluster adsorption, guaranteed proxy generation, or threshold elimination before entering the subsequent convex decomposition step.

[0095] Thus, in this embodiment, the inter-unit distance between any two active Gaussian basic units can be determined based on the mean vector and covariance matrix parameters of each active Gaussian basic unit. Furthermore, based on the inter-unit distance between any two active Gaussian basic units and the maximum principal axis radius of each Gaussian basic unit, the multiple active Gaussian basic units are divided into multiple Gaussian basic unit clusters. The maximum principal axis radius is obtained by eigenvalue decomposition of the covariance matrix parameters of the Gaussian basic units.

[0096] In some embodiments provided in this application, there are multiple collision proxies, each with different precision. The higher the precision of the collision proxy, the closer the target range indicated by the collision proxy is to the outline of the virtual object.

[0097] Specifically, during game execution, virtual objects constructed using a 3D Gaussian splash model that rely solely on a single-precision collision proxy face a trade-off between collision detection accuracy and performance. For example, when virtual objects are at a distance in low-priority interaction scenarios, a high-precision collision proxy consumes unnecessary computational resources, leading to decreased frame rates and stuttering. Conversely, when virtual objects are at close range in high-interaction scenarios, a low-precision collision proxy cannot accurately match the actual shape of the virtual object, resulting in distorted collision ranges and incorrect interaction judgments, failing to meet the realism requirements of game physics interactions.

[0098] Based on this, in some embodiments provided in this application, multiple collision proxies with different precision levels can be constructed for virtual objects, and the collision proxy precision is positively correlated with the matching degree of the virtual object's shape contour. This allows the game physics engine to dynamically select the corresponding precision collision proxy according to the actual running scenario, balancing collision detection precision and game running performance.

[0099] In some embodiments, multiple collision proxies with different accuracies can be understood as multiple sets of collision detection geometric carriers with hierarchical differences in geometric approximation for the same virtual object or Gaussian basic unit cluster, with each set of proxies forming a hierarchy in terms of computational complexity and shape reproduction.

[0100] In some embodiments, collision proxy accuracy can be understood as the degree to which the collision space range defined by the collision proxy restores and matches the real outline of the virtual object. The higher the degree of restoration, the higher the accuracy level.

[0101] In some embodiments, the target range can be understood as the effective spatial area defined by the collision agent in the three-dimensional game space for the physics engine to determine whether a collision event has occurred.

[0102] In some embodiments, the outline of a virtual object can be understood as the three-dimensional external geometric boundary and overall shape of the virtual object as actually rendered in the game scene.

[0103] In some embodiments, the collision proxy includes three levels: a single convex hull collision proxy with the lowest accuracy that directly covers the entire virtual object; multiple coarse multi-convex body collision proxies with medium accuracy; and multiple fine multi-convex body collision proxies with the highest accuracy. Specifically, the number of fine multi-convex body collision proxies is greater than the number of coarse multi-convex body collision proxies, the number of coarse multi-convex body collision proxies is greater than the number of single convex hull collision proxies, the union of all fine multi-convex body collision proxies covers the entire virtual object, the union of all coarse multi-convex body collision proxies covers the entire virtual object, and the union of all single convex body collision proxies covers the entire virtual object.

[0104] In some examples, taking a virtual object like a prop gun in a game as an example, four levels of collision proxy can be generated for this prop: L0, L1, L2, and L3. L0 is an AABB cuboid that directly covers the entire gun body, ignoring gun body recesses, magazines, and stocks. L1 is a coarse-precision single convex bump that wraps around the entire gun body, filling the magazine and grip recesses. L2 is a medium-precision 5-convex combination, specifically composed of five recesses: the main body of the gun, magazine, grip, stock, and scope. L3 is a high-precision 15-convex group, specifically based on gun body segments, magazine details, grip curvature, stock recesses, and scope body divisions, ensuring that these 15 convex groups fit the complete details of the prop gun.

[0105] Specifically, L0 is obtained by calculating the maximum / minimum coordinates of the Gaussian fundamental element cluster of the gun and generating an axis-aligned bounding box. L1 is obtained by generating a single convex hull using a full Gaussian fundamental element cluster. L2 is obtained by performing spatial partitioning convex decomposition according to the gun components. L3 is obtained by performing fine convex decomposition according to the curved surfaces and grooves.

[0106] Thus, in this embodiment, precision proxies can be invoked as needed, avoiding unnecessary computational power consumption, achieving stable physical interaction of 3D Gaussian splash assets, and lowering the threshold for technology implementation.

[0107] In some embodiments provided in this application, step 130 above includes: constructing multiple collision proxies with different accuracies based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster.

[0108] Specifically, the Gaussian basic unit of the 3D Gaussian splash model has native parameters such as mean vector, covariance matrix, and opacity. Therefore, if these complex native parameters are used to construct the collision proxy, it will increase the computational overhead to a certain extent and cannot meet the real-time requirements of the game.

[0109] Based on this, in some embodiments provided in this application, the electronic device can use the mean vector of all units in the Gaussian basic unit cluster as the main basis to construct multiple collision agents with different precisions for each Gaussian basic unit cluster, and use the simplest spatial position parameters to achieve efficient generation of multi-precision collision agents, balancing game performance and collision accuracy requirements.

[0110] In some embodiments, the mean vector can be understood as the coordinates of the midpoint of the Gaussian basic unit in the three-dimensional game space, which is the most basic and core parameter representing the spatial position of the Gaussian unit.

[0111] In some embodiments, multiple collision proxies with different levels of precision can be understood as a combination of collision proxies with different levels of precision. The level of precision directly determines the degree to which the collision range fits the outline of the virtual object.

[0112] In some embodiments, a Gaussian basic unit cluster can be understood as a set of at least one Gaussian basic unit after clustering, corresponding to an independent local physical region of a virtual object.

[0113] In some examples, electronic devices can, after completing the clustering of Gaussian basic units, target the set of Gaussian basic unit clusters. Each Gaussian fundamental unit cluster C k Batch extraction of all Gaussian fundamental units within a cluster g i The mean vector μ i This forms the spatial location point set (or input point set) of the cluster. P k Among them, the Gaussian fundamental unit cluster set Each Gaussian fundamental unit cluster C k The set of spatial locations (or the set of input points) P k As shown in formula (9), that is: (9) Then, based on the set of location points P k It uses different geometric construction rules to generate multi-level precision collision proxies with different fits. The entire process only calls the mean vector and does not involve complex operations such as covariance matrix decomposition and opacity filtering, thus directly completing the construction of multi-precision collision proxies.

[0114] Thus, in this embodiment, multiple collision proxies with different accuracies can be constructed based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster. This achieves collision proxy construction using only the simplest parameter, the mean vector, eliminating the need to process complex data such as the covariance matrix, reducing data reading and computation steps, and adapting to the performance requirements of real-time game operation. Furthermore, the mean vector can completely reflect the spatial distribution of the Gaussian basic unit cluster, based on which high and low precision collision proxies can be flexibly generated to meet the hierarchical requirements of long-distance fast detection and close-range accurate interaction in games. In some embodiments provided in this application, the multiple collision agents include a first collision agent and a second collision agent, wherein the accuracy of the second collision agent is greater than that of the first collision agent.

[0115] Specifically, virtual objects built based on a 3D Gaussian splash model may face a dilemma if only a single-precision collision proxy is used, as it cannot balance interactive accuracy and runtime performance. For example, a low-precision collision proxy has poor alignment with the virtual object's outline, easily leading to collision detection errors and distorted interactive effects such as trampling and attacks. On the other hand, a high-precision collision proxy has high geometric complexity and computational demands, which can excessively consume hardware resources in long-distance, non-primary interaction scenarios, causing issues such as decreased game frame rates and stuttering.

[0116] Based on this, in some embodiments provided in this application, the multi-level collision agents constructed based on parameters such as the mean vector are divided into two categories: the first collision agent and the second collision agent, and the relationship between their accuracy is clearly defined, providing a standardized hierarchical basis for subsequent hierarchical construction of collision agents and dynamic selection of agents with different accuracy.

[0117] In some embodiments, the first collision proxy can be understood as a collision proxy with a lower accuracy level, which is a rough geometric approximation of the local region of the virtual object corresponding to the Gaussian basic unit cluster, with low computational cost and fast collision detection speed.

[0118] In some embodiments, the second collision proxy can be understood as a collision proxy with a high level of accuracy. It is a fine geometric approximation of the local region of the virtual object corresponding to the Gaussian basic unit cluster, with a very high degree of fit to the object's outline, and the collision detection results are accurate.

[0119] Thus, in this embodiment of the application, a first collision proxy with lower precision and a second collision proxy with higher precision can be constructed to achieve a two-way balance between the precision and performance of game physics interaction.

[0120] In some embodiments provided in this application, the step of constructing multiple collision proxies with different accuracies based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster includes: constructing a bounding box or convex hull capable of enclosing multiple Gaussian basic unit clusters based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster, thereby obtaining a first collision proxy.

[0121] Specifically, virtual objects constructed based on 3D Gaussian splashing lack traditional geometric meshes and cannot be directly identified by game physics engines regarding their collision range. Furthermore, the traditional coarse-precision collider construction relies on mesh reconstruction steps, which is cumbersome and time-consuming.

[0122] Based on this, in order to achieve efficient generation of low-precision collision proxies, in some embodiments provided in this application, a bounding box or convex hull that encloses the Gaussian basic unit cluster can be constructed by the mean vector of the cluster, and the constructed bounding box or convex hull can be used as the first collision proxy, so as to achieve the purpose of generating coarse-precision collision carriers at low cost without mesh reconstruction.

[0123] In some embodiments, a bounding box can be understood as a regular geometric box that can enclose a set of points in three-dimensional space, and is a simplified collision geometry commonly used in game physics engines.

[0124] In some embodiments, a convex hull can be understood as the smallest convex polyhedron containing the set of all mean vector points, which is a standard basic collision geometry unit commonly used in game physics engines.

[0125] In some examples, the generation process of the first collision agent includes: First, for each partitioned Gaussian basic unit cluster C k Extract all Gaussian fundamental units within the cluster. g i The mean vector μ i These mean vectors are used as the spatial location point set (or input point set) for constructing the collision proxy. P k This point set can accurately reflect the overall distribution and location range of Gaussian fundamental unit clusters in three-dimensional space.

[0126] Subsequently, based on the aforementioned mean vector point set P k The calculation can completely encapsulate the entire Gaussian fundamental unit cluster. C k The target bounding box can be obtained by using the axis-aligned bounding box (AABB); alternatively, the bounding box can be obtained by using this point set. P kPerform standard convex hull calculations, such as using the Quickhull algorithm, to generate a single convex hull that can wrap around the Gaussian fundamental unit cluster. Both of these methods generate geometric shapes that are coarse-precision wrapping structures that can completely cover the local area of ​​the virtual object corresponding to the Gaussian fundamental unit cluster.

[0127] Finally, the generated axis-aligned bounding box or single convex hull is directly identified as the first collision proxy corresponding to the Gaussian basic unit cluster, serving as a coarse-precision collision detection carrier that can be directly recognized by the game physics engine, thus completing the generation of the first collision proxy.

[0128] Thus, in this embodiment, a bounding box or convex hull that can wrap multiple Gaussian basic unit clusters can be constructed based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster to obtain a first collision proxy. In this way, geometry can be constructed through the mean vector to obtain the first collision proxy. There are no complex matrix operations, the generation speed is fast, the computational overhead is low, and it is suitable for the automated processing scenario of batch assets in games.

[0129] In some embodiments provided in this application, the second collision proxy includes multiple second collision proxies, each corresponding to at least one Gaussian basic unit cluster. Furthermore, the step of constructing multiple collision proxies with different accuracies based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster includes: performing an approximate convex decomposition on the Gaussian basic unit cluster based on the mean vector of each Gaussian basic unit within the cluster, thereby splitting the Gaussian basic unit cluster into multiple convex sub-bodies; and determining the multiple convex sub-bodies as the second collision proxies corresponding to the Gaussian basic unit cluster. The multiple convex sub-bodies are capable of enclosing the Gaussian basic unit cluster.

[0130] Specifically, for virtual objects constructed using a 3D Gaussian splash model, the Gaussian basic unit clusters in the model often have concave geometric structures, such as hollows, grooves, and frame-like shapes. Therefore, if only a single convex hull or bounding box-type first collision proxy is used, it will fill the concave areas, causing the collision range to deviate significantly from the actual shape of the virtual object, resulting in distorted physical interaction. Furthermore, games require high-precision collision proxies to adapt to close-range, precise interaction scenarios; a single-precision collision proxy cannot meet the requirements for balancing the accuracy and performance of physical interaction.

[0131] Based on this, in some embodiments provided in this application, the electronic device can use the mean vector of the Gaussian basic unit cluster as a basis to decompose the concave Gaussian basic unit cluster into multiple convex sub-bodies through approximate convex decomposition, and use the combination of multiple convex sub-bodies to form a high-precision second collision proxy to accurately match the real shape of the virtual object.

[0132] In some embodiments, approximate convex decomposition can be understood as an algorithm that splits a non-convex (concave) set of spatial points or a geometric region into multiple regular convex geometric sub-regions.

[0133] In some embodiments, a convex subbody can be understood as a convex geometric unit obtained after approximate convex decomposition, which has a regular geometric shape and can be directly recognized by most game physics engines and used for collision detection.

[0134] In some examples, the process of generating the second collision agent may include: First, for each Gaussian fundamental unit cluster that has been partitioned... C k Extract all Gaussian fundamental units within the cluster. g i The mean vector μ i The spatial locations of these mean vectors are aggregated to form the corresponding spatial point set. P k This yields the input data generated by the collision proxy.

[0135] Subsequently, using this set of spatial points P k For the object being processed, Gaussian fundamental unit clusters C k The corresponding spatial region undergoes an approximate convex decomposition operation, which decomposes the Gaussian fundamental unit cluster space, which may originally have a concave structure, into several regular convex sub-volumes, specifically expressed as {V k,1 V k,2 ,…,V k,m}, V k,1 Represents Gaussian fundamental unit clusters C k The corresponding first convex subbody, V k,2 Represents Gaussian fundamental unit clusters C k The corresponding second convex subbody, V k,m Represents Gaussian fundamental unit clusters C k The corresponding m-th convex sub-body. The spatial range of these convex sub-body cooperates with each other to completely enclose the local area of ​​the virtual object corresponding to the Gaussian basic unit cluster, with no collision detection blind spots and without exceeding the shape of the virtual object to generate invalid collision range.

[0136] Finally, all the convex sub-volumes obtained through approximate convex decomposition are integrated into a whole, and this combination of convex sub-volumes constitutes the current Gaussian fundamental unit cluster. C k The corresponding second collision agent, as a high-precision collision agent, can meet the needs of close-range, high-precision physical collision detection in games.

[0137] Thus, in this embodiment, the Gaussian basic unit cluster can be approximated by convex decomposition based on the mean vector of each Gaussian basic unit within the cluster. This decomposes the cluster into multiple convex sub-bodies, which are then designated as the second collision proxies corresponding to the Gaussian basic unit cluster. This accurately adapts to the collision range of concave virtual objects, avoiding distortion in single convex hull collision detection and improving the realism and accuracy of game physics interaction. Furthermore, the convex sub-bodies match the geometric primitive requirements of most game physics engines, allowing for direct serialization to the engine's native format without additional format conversion, reducing engineering integration complexity.

[0138] In some embodiments provided in this application, step 140 includes: when the distance between the virtual object and the virtual camera in the target game is greater than a first threshold, the display proportion of the virtual object in the display window of the target game is less than a second threshold, or the calculation time of the current physical frame of the target game is greater than a third threshold, detecting a virtual object collision event based on a first collision proxy of the virtual object, and triggering corresponding physical feedback based on the collision event; when the distance between the virtual object and the target object in the target game is less than a fourth threshold, the display proportion increases for several consecutive frames, or the virtual object is marked as a high interaction priority, detecting a virtual object collision event based on a second collision proxy of the virtual object, and triggering corresponding physical feedback based on the collision event, wherein the target object can perform virtual interaction with the virtual object.

[0139] Specifically, virtual objects constructed from 3DGS assets can not achieve a balance between accuracy and performance during game runtime. For example, if a high-precision collision proxy is used throughout, a large amount of redundant calculations will occur when dealing with distant objects or under performance pressure, resulting in excessive physics frame processing time and a sharp drop in game frame rate. If a low-precision collision proxy is used throughout, problems such as mismatch between collision range and visual shape and interaction distortion will occur during close-range interactions and interactions with key props, failing to meet the requirements for realism in game physical interactions.

[0140] Based on this, in some embodiments provided in this application, electronic devices can automatically select a performance-priority low-precision first collision agent or a precision-priority high-precision second collision agent to perform collision detection and response by combining dynamic parameters during game operation with conditions such as distance, display ratio, physical frame performance, and interaction priority, thus balancing game performance and interaction realism.

[0141] In some embodiments, a virtual camera can be understood as a virtual imaging device in a game engine used to render scenes and present the player's perspective, and is a reference object for determining the display status and spatial distance of virtual objects.

[0142] In some embodiments, the first threshold can be understood as a pre-set distance threshold between the virtual object and the virtual camera, used to divide long-distance and medium-to-short-distance interaction scenarios.

[0143] In some embodiments, the display window can be understood as a visual area that presents the screen to the player during game runtime, used to measure the screen display scale and importance of virtual objects.

[0144] In some embodiments, the second threshold can be understood as a pre-set critical value for the proportion of the area occupied by the virtual object in the display window, used to determine whether the object is a secondary display object.

[0145] In some embodiments, a physics frame can be understood as a unit of time period during which the game's physics engine performs physics calculations, collision detection, and rigid body updates. The computation time of a physics frame directly determines the game's frame rate.

[0146] In some embodiments, the third threshold can be understood as a pre-set physical frame calculation time threshold, used to identify whether the game is in a state of insufficient computing power or performance stress.

[0147] In some embodiments, the target object can be understood as an entity in the game scene that can engage in virtual interactive behaviors such as touching, attacking, or pushing the current virtual object, such as a controlled virtual character operated by the player.

[0148] In some embodiments, the fourth threshold can be understood as a pre-set distance threshold between the virtual object and the target object, used to determine whether to enter a close-range precise interaction scenario.

[0149] In some embodiments, high interaction priority can be understood as a marker assigned by the game system to virtual objects that require high-precision physical interaction, such as player-controlled characters, key plot items, and important interactive objects.

[0150] To more clearly illustrate the switching mechanism of the collision agent in the embodiments of this application, please refer to the following exemplary description: Electronic devices are pre-configured with four types of parameters: a first preset threshold (camera distance threshold), a second preset threshold (display ratio threshold), a third preset threshold (physical frame time threshold), and a fourth preset threshold (target object distance threshold), which serve as the criteria for determining collision proxy switching.

[0151] Furthermore, during game runtime, four types of dynamic data are collected in real time: the spatial distance between the virtual object and the virtual camera, the display ratio of the virtual object in the display window, the actual calculation time of the current physical frame, the distance between the virtual object and the target object, and the interaction priority marker. Based on these four types of parameters, condition judgments and proxy calls are performed.

[0152] When any of the following triggering conditions are met: the distance between the virtual object and the virtual camera exceeds the first preset threshold, the display ratio is less than the second preset threshold, or the physical frame calculation time exceeds the third threshold, the electronic device immediately calls the first collision agent. Using the agent's simple geometric structure, namely AABB or single convex hull, it quickly completes collision detection and triggers the corresponding physical feedback when a detected collision event is detected, greatly reducing computing power consumption.

[0153] When any of the following triggering conditions are met: the distance between the virtual object and the target object is less than the fourth threshold, the display ratio increases for multiple consecutive frames, or the object is marked as having high interaction priority, the electronic device automatically switches to the second collision agent. Collision detection is achieved through a high-precision structure composed of multiple convex bodies, and corresponding physical feedback is triggered when a collision event is detected, ensuring that the collision range is completely matched with the visual shape of the virtual object.

[0154] Thus, in this embodiment, when the distance between the virtual object and the virtual camera in the target game is greater than a first threshold, the display proportion of the virtual object in the display window of the target game is less than a second threshold, or the calculation time of the current physical frame of the target game is greater than a third threshold, a collision event of the virtual object is detected based on the first collision proxy of the virtual object, and corresponding physical feedback is triggered based on the collision event. Alternatively, when the distance between the virtual object and the target object in the target game is less than a fourth threshold, the display proportion increases for several consecutive frames, or the virtual object is marked as a high interaction priority, a collision event of the virtual object is detected based on the second collision proxy of the virtual object, and corresponding physical feedback is triggered based on the collision event. This allows for the use of a low-precision proxy to reduce computational overhead and ensure stable game frame rate in long-distance, performance-critical scenarios, and the use of a high-precision proxy in close-distance, high-priority interaction scenarios to improve collision distortion and enhance the realism of physical interaction.

[0155] Please see Figure 5 In some embodiments provided in this application, step 140 above includes: 141: Based on multiple collision proxies with different accuracies, generate collision proxy description data corresponding to each Gaussian basic unit cluster, wherein the collision proxy description data is used to indicate the collision proxy corresponding to the Gaussian basic unit cluster. 142: Convert the collision proxy description data corresponding to each Gaussian basic unit cluster into data in the target format to obtain collision proxy description conversion data, in which the physics engine of the target game can perform collision event detection and response through the target format data; 143: Load the collision proxy description conversion data into the target game's physics engine so that the target game's physics engine can perform virtual object collision event detection through the loaded collision proxy description conversion data and trigger corresponding physical feedback based on the collision events.

[0156] Specifically, the Gaussian metaset of the 3D Gaussian splash model cannot be directly recognized by the game physics engine. Even if a collision proxy with multi-level precision is generated, if the collision proxy data is incompatible with the physics engine format, it will cause runtime format conversion overhead and parsing delay, resulting in low collision detection efficiency and unstable game frame rate. At the same time, the additional intermediate conversion steps will increase the complexity of game engineering integration, making it impossible to quickly deploy 3D Gaussian splash assets in game physics interaction scenarios.

[0157] Based on this, in some embodiments provided in this application, after generating corresponding description data for multi-level precision collision agents, the description data can be converted into the native target format of the physics engine and then directly loaded into the physics engine, so that the physics engine can call the collision agent data without additional parsing to complete collision detection and response.

[0158] In some embodiments, collision proxy description data can be understood as structured data used to characterize the core attributes of the collision proxy corresponding to the Gaussian basic unit cluster, such as shape, size, accuracy level, and spatial range, and is a standardized description carrier of the collision proxy.

[0159] In some embodiments, the target format can be understood as a collision shape data format natively supported by the game physics engine and directly loaded without additional parsing, which is the standard format for the physics engine to identify colliders.

[0160] In some examples, the target format is binary.

[0161] In some embodiments, collision proxy description conversion data can be understood as standardized data that can be directly called by the physics engine after the collision proxy description data has been converted according to the target format.

[0162] In some embodiments, the physics engine of the target game can be understood as the core functional module in the game responsible for physics simulation, collision detection, and collision response, such as PhysX, Bullet, Havok, and other game physics engines.

[0163] To more clearly illustrate the process of loading the collision proxy into the game physics engine and the process of the physics engine detecting and responding to collision events through the loaded collision proxy in the embodiments of this application, please refer to the following exemplary description: Taking the aforementioned first and second collision proxies as examples, for each Gaussian basic unit cluster C k Generate custom collision proxy description data { D (k,0) , D (k,1)}, D (k,0) for C kThe corresponding first collision agent, D (k,1) for C k The corresponding second collision proxy. This data fully records the accuracy level, geometric profile, spatial location, coverage, and other attributes of the corresponding collision proxy, clearly defining the one-to-one correspondence between the collision proxy and the Gaussian basic unit cluster, and providing a standard data source for subsequent format conversion.

[0164] Then, each Gaussian fundamental unit cluster C k Corresponding collision proxy description data { D (k,0) , D (k,1) The data is serialized and converted according to the native collision descriptor specification of the target game's physics engine (such as PhysX, Bullet, or Havok) to generate collision proxy description conversion data that the physics engine can directly recognize. This conversion process directly matches the engine's underlying data standard, requiring no additional intermediate parsing or format adaptation steps. The specific target format data obtained after conversion is shown in Table 1, i.e.: Table 1

[0165] Next, the converted native format collision proxy data is loaded into the target game's physics engine. The physics engine directly reads and registers the collision proxies, incorporating them into its own collision detection system, thus completing the transformation of the collision proxies from data form to engine-usable colliders.

[0166] Therefore, during game runtime, the physics engine dynamically selects the appropriate type from the loaded multi-level precision collision proxies based on scene conditions such as the distance between virtual objects and the virtual camera, the proportion of virtual objects in the display window, and the time taken to calculate physics frames: a coarse-level collision proxy is used for fast calculation when the distance is far, the display area is small, or frame time is tight. Conversely, a fine-level collision proxy is used for precise detection when the distance is close, the display area is large, or there is a high priority for interaction.

[0167] Furthermore, based on the collision range defined by the selected collision agent, the physics engine uses its own collision detection algorithm to calculate in real time the spatial positional relationships between virtual objects in the game scene and between virtual objects and the scene environment, accurately determine whether a collision has occurred, the location of the collision, and the intensity of the collision, and complete the identification of collision events.

[0168] When a collision event is detected, the physics engine triggers the corresponding physical response logic based on the collision range parameters defined by the collision agent. This includes limiting the penetration displacement of virtual objects, generating collision bounce effects, triggering interactive actions or special effects feedback, and finally completing the full response to the collision event, enabling virtual objects constructed by the 3D Gaussian splash model to achieve realistic game physics interaction.

[0169] Thus, in this embodiment, collision proxy description data corresponding to each Gaussian basic unit cluster can be generated based on multiple collision proxies with different accuracies. This data is then converted to a target format to obtain collision proxy description conversion data. This converted data is loaded into the target game's physics engine, allowing the engine to detect virtual object collision events and trigger corresponding physical feedback based on the collision events. This converts the collision proxies to the physics engine's native format, eliminating the need for intermediate parsing and significantly reducing runtime data processing overhead. This ensures real-time collision detection in the game, and the physics engine directly calls the native format data, avoiding errors caused by format conversion. This results in more accurate and stable collision detection of virtual objects, meeting the needs of real-time game interaction. Furthermore, the physics engine can dynamically call upon data based on the game scene, balancing collision accuracy and performance. Additionally, no additional format conversion middleware needs to be developed, reducing the difficulty of integrating 3D Gaussian splash assets into the game's physics system and improving asset deployment efficiency.

[0170] Please see Figure 6 In some embodiments provided in this application, the three-dimensional Gaussian splash model further includes a skeletal model of a virtual object. The skeletal model includes multiple skeletal joints and the joint position of each skeletal joint. Furthermore, the data processing method in the game provided in this application also includes: 150: Based on the target position of each Gaussian basic unit cluster in the target game scene and the joint position of each skeletal joint, bind each Gaussian basic unit cluster to the nearest skeletal joint. 160: In response to the pose changes of the target joints in the skeletal model, the pose of the target collision agent is updated synchronously so that the pose of the target collision agent matches the pose of the target joints. The target joints are bound to the target Gaussian basic unit clusters, and the target Gaussian basic unit clusters correspond to the target collision agent.

[0171] Specifically, for 3D Gaussian splash virtual objects with skeletal animation in games, such as game characters and movable props, the collision proxies of these virtual objects are built based on static Gaussian basic unit clusters. These proxies cannot be updated synchronously with the pose changes of the skeletal joints, resulting in a severe disconnect between the collision proxy position and shape and the visual appearance of the virtual object. This leads to distorted physical collision detection results, preventing characters from achieving realistic physical feedback such as melee combat, pushing, and contact interactions, completely failing to meet the physical interaction requirements of skeletal animation assets in games.

[0172] Based on this, in some embodiments provided in this application, the electronic device can establish a binding relationship between the Gaussian basic unit cluster and the nearest bone joint for a 3D Gaussian splash model with skeleton, and synchronously drive the corresponding collision agent to update the pose when the bone joint changes posture, so that the collision agent always matches the skeletal animation shape of the virtual object.

[0173] In some embodiments, the skeletal model can be understood as the skeletal animation driving structure of virtual objects, which consists of multiple skeletal joints arranged in a hierarchical joint tree. The spatial state changes of the joints drive the virtual objects to produce animation effects, and it is also the animation carrier of virtual objects in games such as game characters and playable bodies.

[0174] In some embodiments, a skeletal joint can be understood as the basic control unit of a skeletal model. It is the smallest node in skeletal motion, carrying motion data such as the position and rotation of the joint. Multiple joints combine to form a complete skeletal motion system.

[0175] In some embodiments, the joint position can be understood as the coordinate data of the skeletal joint in the game's three-dimensional spatial coordinate system, which is the core calculation basis for the binding of the Gaussian basic unit cluster and the skeletal joint.

[0176] In some embodiments, the target location can be understood as the three-dimensional spatial center coordinates of the Gaussian basic unit cluster in the target game scene, representing the overall spatial location of the Gaussian basic unit cluster.

[0177] In some embodiments, binding can be understood as establishing a fixed association between Gaussian basic unit clusters and skeletal joints, so that when the joints move, they can directly drive the corresponding collision agents to move synchronously, forming a linkage between the skeleton and the collision agents.

[0178] In some embodiments, posture change can be understood as a change in the spatial state of the skeletal joints, such as position, rotation, and scaling. It is the triggering condition for the skeletal animation of the virtual object and also the start signal for the collision proxy update.

[0179] In some embodiments, the target joint can be understood as a skeletal joint that is bound to the target Gaussian basic unit cluster, and is the core node that drives the corresponding collision proxy update.

[0180] In some embodiments, the target collision proxy can be understood as a collision proxy corresponding to the target Gaussian basic unit cluster, which is a collision detection unit whose pose needs to be updated synchronously with the bound joints.

[0181] In some embodiments, pose can be understood as the position and rotational orientation of the collision agent in three-dimensional space. It is the main parameter for the physics engine to perform collision detection and directly determines the accuracy of collision detection.

[0182] To more clearly illustrate the pose synchronization update process in the embodiments of this application, please refer to the following exemplary description: The electronic device extracts the position data of all skeletal joints from the skeletal model in the 3D Gaussian splash model, and simultaneously determines the target position of each Gaussian basic unit cluster in the game scene. Specifically, the electronic device can calculate the spatial Euclidean distance between the Gaussian basic unit cluster and each skeletal joint, and accurately bind each Gaussian basic unit cluster to the nearest skeletal joint, thereby establishing a corresponding binding relationship of "skeletal joint - Gaussian basic unit cluster - collision proxy", laying the foundation for subsequent dynamic updates.

[0183] During game execution, the electronic device monitors the motion state of the skeletal model in real time. When it detects a joint that has changed its pose, that is, when it detects a target joint, the electronic device immediately responds to this animation event. Based on the previously established binding relationship, it locates the target Gaussian basic unit cluster and the target collision proxy corresponding to the target joint, and adjusts the pose of the target collision proxy synchronously to ensure that the position and rotation state of the collision proxy match the pose of the target joint, so that the spatial shape of the collision proxy fits the visual appearance of the virtual object.

[0184] Thus, in this embodiment, each Gaussian basic unit cluster can be bound to the nearest skeletal joint based on its target position in the target game scene and the joint position of each skeletal joint. In response to pose changes of the target joint in the skeletal model, the pose of the target collision proxy is synchronously updated to match the pose of the target joint. This ensures that the collision detection results remain consistent with the visual appearance of the virtual object, guaranteeing the realism and accuracy of physical interaction. Furthermore, the binding and updating process is fully automated, eliminating the need for manual annotation of colliders by artists. Moreover, updating only the collision proxy corresponding to joints with pose changes reduces runtime computational overhead and ensures stable game frame rates.

[0185] In some embodiments provided in this application, step 160 includes: in response to the pose change of the target joint in the skeletal model, determining the target Gaussian basic unit cluster bound to the target joint; marking each target collision agent corresponding to the target Gaussian basic unit cluster; and updating the pose of each marked target collision agent.

[0186] Specifically, if all collision proxies are updated directly when the pose of a joint changes, a large amount of invalid calculations unrelated to the pose change will be generated, significantly increasing the performance overhead of the game runtime and causing problems such as frame rate drops and stuttering, which cannot meet the real-time interaction requirements of the game. At the same time, the lack of a precise positioning and filtering mechanism can easily lead to the collision proxies of unchanged joints being updated incorrectly, while the collision proxies of changed joints are missed from being updated, ultimately causing the pose of the collision proxies to become disconnected from the visual form of the virtual object, resulting in distorted collision detection results.

[0187] Based on this, in some embodiments provided in this application, the electronic device may adopt a step-by-step execution mechanism of attitude change triggering, binding Gaussian cluster localization, collision proxy marking, and directional update. Only the collision proxy corresponding to the target Gaussian cluster bound to the target key point of the attitude change is marked and then directionally updated to achieve incremental collision proxy pose update.

[0188] In some embodiments, the flag can be understood as setting a Boolean dirty flag for the target collision agent to indicate that the pose data of the collision agent has expired, does not match the current skeleton pose, and needs to be updated.

[0189] In some embodiments, being marked can be understood as the target collision agent being given a dirty mark state and entering the queue to be updated, which is a prerequisite for performing pose update.

[0190] To more clearly illustrate the pose update process of the collision agent in the embodiments of this application, please refer to the following exemplary description: During game execution, the electronic device continuously monitors the motion state of the skeletal model. When a target joint is detected to have a positional shift, rotation, or other posture change, the device filters out the target Gaussian basic unit cluster that is uniquely bound to the target joint with the posture change based on the previously established binding relationship between the skeletal joint and the Gaussian basic unit cluster, and excludes all unrelated Gaussian clusters to narrow down the update range.

[0191] Then, a dirty flag is uniformly set for all target collision agents (including collision agents of different accuracy levels) corresponding to the above target Gaussian basic unit clusters to clearly indicate that these collision agents need to update their poses.

[0192] Finally, the electronic device only performs pose calculation and update operations on the tagged target collision agents. The untagged collision agents remain unchanged in their original poses and do not participate in any calculations. After the update is completed, the poses of the collision agents are matched with the poses of the target joints.

[0193] Thus, in this embodiment, in response to the pose change of the target joint in the skeletal model, the target Gaussian basic unit cluster bound to the target joint can be determined; each target collision agent corresponding to the target Gaussian basic unit cluster is marked; the pose of each marked target collision agent is updated, thereby adopting incremental update logic, processing only the collision agents affected by pose changes and marked, reducing invalid calculations, reducing hardware overhead during game runtime, ensuring stable frame rate, and fully meeting the real-time requirements of the game.

[0194] In some embodiments provided in this application, the information processing method in the game further includes: constructing position transformation data corresponding to each Gaussian basic unit cluster, wherein the position transformation data is used to indicate the position transformation relationship between the position of the key point bound to the Gaussian basic unit cluster and the target position of the collision agent corresponding to the Gaussian basic unit cluster.

[0195] Furthermore, the above-mentioned step of updating the pose of the target collision agent includes: updating the pose of the target collision agent based on the position transformation data corresponding to the Gaussian basic unit cluster and the pose of the target joint.

[0196] Specifically, to ensure the effectiveness of pose synchronization between the collision agent and the bound joint, in some embodiments provided in this application, the electronic device can construct corresponding position transformation data for each Gaussian basic unit cluster to solidify the position transformation relationship between the bound joint and the collision agent. Then, during game execution, based on the position transformation data and combined with the real-time pose of the target joint, the collision agent pose is updated through spatial transformation, thereby avoiding pose offset, calculation error and performance loss, and ensuring the effectiveness of pose synchronization between the collision agent and the bound joint.

[0197] In some embodiments, position transformation data can be understood as data used to describe the spatial transformation rules between the skeletal joint positions bound to a Gaussian basic unit cluster and the target position of the corresponding collision agent of that cluster.

[0198] In some embodiments, the position transformation relationship can be understood as the mapping, translation, rotation, and other transformation rules between the spatial coordinate system of the skeletal joints and the spatial coordinate system of the collision agent.

[0199] To more clearly illustrate the pose synchronization process in the embodiments of this application, please refer to the following exemplary description: First, for each Gaussian basic unit cluster that has completed skeletal joint binding, corresponding position transformation data is created.

[0200] Then, during game execution, when the target joint changes its posture, the electronic device no longer directly adjusts the collision agent's pose. Instead, it retrieves the position transformation data corresponding to the Gaussian cluster, combines it with the real-time pose of the target joint, such as its position and rotation state, and performs precise calculations according to the preset position transformation relationship to obtain the target pose that the collision agent should update before completing the pose adjustment.

[0201] Thus, in this embodiment, position transformation data corresponding to each Gaussian basic unit cluster can be constructed, and the pose of the target collision agent can be updated according to the position transformation data corresponding to the Gaussian basic unit cluster and the pose of the target joint. This can avoid spatial misalignment between the collision agent and the joint through position transformation relationship, ensure the fit between the collision agent pose and the visual form of the virtual object, and thus improve the accuracy of physical collision detection.

[0202] In some embodiments provided in this application, the step of constructing the position transformation data corresponding to each Gaussian basic unit cluster includes: determining the mean value of the mean vector of each Gaussian basic unit in the Gaussian basic unit cluster as the cluster center of the Gaussian basic unit cluster in the first spatial coordinate system; constructing the offset matrix corresponding to the Gaussian basic unit cluster based on the cluster center of the Gaussian basic unit cluster to obtain the position transformation relationship, wherein the offset matrix is ​​used to indicate the transformation relationship of the Gaussian basic unit cluster in the first spatial coordinate system to the target position of the joint point bound to the Gaussian basic unit cluster in the second spatial coordinate system.

[0203] Specifically, to ensure the validity of position transformation data, in some embodiments provided in this application, the cluster center of the Gaussian cluster can be calculated through standardization, and an offset matrix can be constructed based on the cluster center to form a precise cross-coordinate system position transformation relationship, thereby providing stable, unified, and accurate position transformation data for collision agent pose updates.

[0204] In some embodiments, the mean of the mean vector can be understood as the three-dimensional spatial coordinates obtained by calculating the arithmetic mean of the mean vectors of all Gaussian basic units within the Gaussian basic unit cluster, representing the overall position of the Gaussian cluster.

[0205] In some embodiments, the first spatial coordinate system can be understood as a three-dimensional coordinate system based on the global space of the game scene, used to describe the original spatial position of the Gaussian basic unit cluster itself.

[0206] In some embodiments, the cluster center can be understood as the geometric centroid of the Gaussian fundamental unit cluster in the first spatial coordinate system, representing the overall spatial position of the cluster.

[0207] In some embodiments, the offset matrix can be understood as a transformation matrix used to describe the position and rotation mapping relationship between two spatial coordinate systems, and is the specific carrier of position transformation data.

[0208] In some embodiments, the second spatial coordinate system can be understood as a local coordinate system with the skeletal joints bound to the Gaussian basic unit cluster as the origin, used to associate the spatial positions of the joints and the collision agent.

[0209] In some embodiments, the position transformation relationship can be understood as a spatial mapping rule that defines the position of a Gaussian basic unit cluster in the first spatial coordinate system and transforms it to the target position of its bound joint in the second spatial coordinate system.

[0210] To more clearly illustrate the pose synchronization process in the embodiments of this application, please refer to the following exemplary description: In a skeletal model, a bone joint tree can be used. B In the case of characterization, each joint b j World space position with initial bound attitude p j .in, B It can be expressed in the form shown in formula (10), that is: (10) in, M For the bone and joint tree B The total number of nodes. j The range of values ​​for is [1, ... M ].

[0211] For Gaussian fundamental unit clusters Each Gaussian fundamental unit cluster C k Calculate each Gaussian fundamental unit cluster C k center of gravity That is, Gaussian fundamental unit clusters C k The target location, or Gaussian fundamental unit cluster C k The cluster center. Among them, It can be obtained through formula (11), that is: (11) Based on each joint point b j World Space Position p j and each Gaussian fundamental unit cluster C k center of gravity Determine each Gaussian fundamental unit cluster C k nearest skeletal joint b k * This process can be expressed by formula (12), that is: (12) Each Gaussian fundamental unit cluster C k center of gravity As the translation component, and with the unit rotation matrix I3 as the rotation component, a Gaussian fundamental unit cluster is constructed. C k The collision proxy transforms the matrix in the initial world space (i.e., the first spatial coordinate system). , . This can be represented by formula (13), that is: (13) Then, based on each Gaussian fundamental unit cluster C k nearest skeletal joint b k * Generate each Gaussian fundamental unit cluster C k The offset matrix between the collision proxy and the joint coordinate system (i.e., the second spatial coordinate system) of the corresponding bound joint. That is, the positional transformation relationship, which can be expressed by formula (14), namely: (14) Subsequently, after each frame of animation is updated by the game engine, the skeletal animation system generates new skeletal pose data, which is the data for each joint. b k In the t Frame global transformation matrix According to the first t Frame global transformation matrix and the t -1 frame global transformation matrix It can be determined that the first t The joints that undergo pose changes in the frame are used to obtain the joint set Δ. B (t) .

[0212] Then, for Δ B (t) Each changing joint b jThe Gaussian fundamental unit cluster corresponding to this joint is marked as dirty data. This process can be characterized by formula (15), that is: (15) Finally, for all Gaussian fundamental unit clusters marked as dirty C c The corresponding collision agent performs pose updates, which can be represented by formula (16), i.e.: (16) Thus, in this embodiment, the mean value of the mean vector of each Gaussian basic unit in the Gaussian basic unit cluster can be determined as the cluster center of the Gaussian basic unit cluster in the first spatial coordinate system. Based on the cluster center, an offset matrix corresponding to the Gaussian basic unit cluster is constructed to obtain the position transformation relationship. This provides a unified basis for generating position transformation data, ensuring consistent accuracy of transformation data across different Gaussian clusters. Furthermore, the offset matrix constructed based on the cluster center enables spatial binding between the Gaussian cluster and the bound joint, matching the collision proxy pose with the joint pose and avoiding collision detection misalignment.

[0213] To more clearly illustrate the information processing method in the game provided in the embodiments of this application, please refer to... Figure 7-10 , Figure 7 This is a flowchart illustrating the data processing method in a game provided in an embodiment of this application. Figure 8 This is a schematic diagram of the collision proxy generation process provided in an embodiment of this application. Figure 9 This is a schematic diagram illustrating the process of binding collision proxy to skeletal joints as provided in an embodiment of this application. Figure 10 This is a schematic diagram of the collision proxy update process provided in an embodiment of this application.

[0214] like Figure 7 As shown, during the 3DGS asset import phase, the electronic device first receives two parts of data: one part is the trained 3D Gaussian splash model data. G Contains each Gaussian fundamental unit g The mean vector μ i Covariance matrix Σ i Opacity α i Color parameter c i The other part is the skeletal model information of the virtual object, that is, the joint tree structure composed of multiple skeletal joints, also known as the skeletal joint tree. B Record each key point b j initial position p j Hierarchical relationships.

[0215] Gaussian filtering: based on a preset opacity threshold θ For all Gaussian fundamental elements in the 3DGS model g Filter the data to keep only the opacity parameter. α i Greater than the threshold θ Geometrically active Gaussian cells are selected, and semi-transparent Gaussian cells without physical collision significance (such as Gaussian cells corresponding to smoke and halo effects) are removed to reduce the data scale of subsequent processing and ensure that the collision proxy fits the solid surface. This step can be characterized by the above formula (3).

[0216] Perceptual clustering (anisotropic distance): utilizing Gaussian fundamental units g covariance matrix Σ i Construct an anisotropic weighted distance metric, that is, calculate it using the above formula (6). d Σ( g i , g j ), combined with each Gaussian fundamental unit g Maximum spindle radius s (max,i) Adaptive setting of clustering neighborhood radius i For the selected active Gaussian units g Density-adaptive clustering is performed to divide Gaussian units that are spatially adjacent and have matching shape attributes into multiple Gaussian basic unit clusters. C k To form a set of Gaussian fundamental unit clusters Each Gaussian fundamental unit cluster C k This corresponds to an independent rigid body physical region of the virtual object. This step can be characterized by the above formulas (6) to (8).

[0217] Hierarchical convex decomposition (L0 single convex hull / L1 multiple convex bodies): for each Gaussian fundamental unit cluster C k Perform hierarchical convex decomposition to generate two levels of LOD collision proxies, namely the first collision proxy L0 and the second collision proxy L1. L0 is a coarse-precision proxy, using a wrapped Gaussian fundamental unit cluster. C k An axis-aligned bounding box or single convex hull is used for fast collision detection; L1 is a high-precision surrogate that decomposes Gaussian fundamental unit clusters through approximate convex decomposition. C k It is split into multiple convex sub-bodies to precisely match the concave contour of virtual objects, meeting the needs of close-range and precise interaction.

[0218] Engine Format Serialization (PhysX / Bullet / Havok): The generated multi-level collision proxy data is directly converted into the native format of mainstream game physics engines, including the collision descriptor formats of the three major engines: PhysX, Bullet, and Havok. The physics engine can directly load and use it without additional format conversion, eliminating runtime parsing overhead. For details of the conversion process, please refer to Table 1 above.

[0219] Skeletal joint rigging (nearest joint + offset matrix): For 3DGS assets with skeletons, calculate each Gaussian fundamental unit cluster. C k The cluster center will be the Gaussian fundamental unit cluster. C k The nearest skeletal joint b k * Bind, and simultaneously record the initial offset matrix of the collision proxy relative to the bound joint. This matrix is ​​a constant and is used for fast pose synchronization during runtime. This step can be characterized by the above formulas (10) to (14).

[0220] During game runtime, the collision proxy description data and bone-Gaussian cluster binding data generated during the asset import phase are loaded into the game runtime environment, providing a data foundation for real-time collision detection and bone-driven updates.

[0221] Skeletal animation system driven: During game runtime, the skeletal animation system updates the pose (rotation, displacement) of the skeletal joints every frame, outputting the real-time global transformation matrix of each joint point, that is, the transformation matrix of each joint point in the [frame number missing]. t Frame global transformation matrix This triggers the pose update requirement of the collision agent.

[0222] Dirty-flag incremental updates: Employ a dirty flag mechanism, only updating skeletal joints whose posture has changed. b j The bound Gaussian fundamental unit cluster C c When a collision proxy is marked as "pending update", only the pose of the marked collision proxy is updated; the skeletal joints remain unchanged. b j The corresponding agent remains in its original state, significantly reducing runtime computation.

[0223] Physics Engine Synchronization (KinematicRigidBody): The updated collision proxy pose is synchronized to the physics engine through the kinematic rigid body interface of the physics engine, ensuring that the pose of the collision proxy is completely matched with the skeletal animation and the appearance of the virtual object.

[0224] Collision response output: Based on the loaded collision proxy, the physics engine detects collision events of virtual objects in the game scene in real time and executes corresponding physical responses, such as collision blocking, object displacement, and interaction triggering, to realize the physical interaction capabilities of 3DGS assets.

[0225] To explain more clearly Figure 7 For details on Gaussian filtering, perceptual clustering, hierarchical convex decomposition, and engine format serialization during the 3DGS asset import period, please refer to [link to relevant documentation]. Figure 8 , that is Figure 8 As shown, the electronic device can receive fully trained 3D Gaussian splash model data. G The model G Depend on N Gaussian basic unit g i Composition, each unit g i Includes mean vector μ i Covariance matrix Σ i Opacity α i Color c i Attribute parameters are the original data foundation for building collision proxies.

[0226] Filtering based on opacity threshold ( α i >θ): Based on a pre-set opacity threshold θ ,right N Gaussian basic unit g i Filter the data and keep only the opacity parameter. α i Greater than the threshold θ Gaussian elements. Low opacity elements correspond to semi-transparent effects such as smoke and halos that have no physical collision significance. Removing them can reduce subsequent computational overhead and ensure that collision proxies fit the surface of virtual object entities.

[0227] Filter output geometrically active Gaussian G *( N 'indivual, N ' N): After filtering, the geometrically active Gaussian subset is obtained. G * This subset contains only the effective Gaussian cells of the corresponding entity surface, which is far fewer than the original full Gaussian cells. It can directly proceed to the subsequent clustering steps without performing mesh reconstruction, greatly reducing the computational cost during the asset import period.

[0228] Perceptual density adaptive clustering: from geometrically active Gaussian subsets G In *, the mean vector μ of each unit is extracted. i With covariance matrix Σi As the core parameter for clustering calculation, shape features can be incorporated into the clustering process to improve clustering accuracy.

[0229] Then, for the covariance matrix Σ i Perform eigenvalue decomposition to obtain the rotation matrix R. i With the maximum spindle radius s (max,i) Specifically, for the covariance matrix Σ i Eigenvalue decomposition yields the rotation matrix R describing the Gaussian orientation. i and the three principal axis scales describing the Gaussian coverage. s (x,i) , s (y,i) , s (z,i) And extract the maximum spindle radius. s (max,i) This is used for subsequent calculation of adaptive neighborhood radius, adapting to Gaussian units of different scales.

[0230] Calculate the anisotropic weighted sensing distance metric d Σ Based on the covariance matrix Σ i Construct anisotropic weighted Euclidean distance, which is the aforementioned inter-cell distance. d Σ( g i , g j This distance metric adjusts the weights based on the shape and orientation of the Gaussians, assigning smaller distances to Gaussians with the same orientation and shape, and larger distances to Gaussians with different orientations and shapes. This addresses the shortcomings of traditional Euclidean distance in ignoring shape information, making the clustering results more closely resemble physical rigid body partitions.

[0231] Calculate the adaptive neighborhood radius: based on the maximum principal axis radius of each Gaussian. s (max,i) The adaptive neighborhood radius is calculated by combining the global scaling factor γ, which is also the aforementioned local clustering neighborhood radius. i This allows for adaptation to Gaussian-scale spatial inhomogeneities in the scene, avoiding overly coarse or fine clustering issues caused by fixed radii, and flexibly dividing rigid body regions.

[0232] Perform density-adaptive clustering to obtain a set of Gaussian clusters { C 1… C K}: To perceive distance d Σ( g i , g j) as a metric, adaptive radius i To constrain this, density-adaptive clustering is performed, which sets the active Gaussian fundamental units together. G Divided into K A cluster of Gaussian fundamental units C k Each cluster C k This corresponds to an independent physical collision rigid body region of the virtual object. Therefore, based on the Gaussian cluster set { C 1… C K Perform hierarchical convex decomposition. Extracting the mean location set from a Gaussian cluster P k For each Gaussian fundamental unit cluster C k Extract all Gaussian fundamental units within the cluster. g i The mean vector μ i To form a point set P k Let this point set represent the Gaussian variety. C k The spatial distribution of the data serves as the input data for hierarchical convex decomposition, eliminating the need to reconstruct the triangular mesh throughout the process.

[0233] Generating Level 0: Pair Set P k The Quickhull convex hull algorithm is executed to generate a coarse-precision first collision proxy L0 (Level 0). The entire Gaussian cluster is wrapped with a single convex hull or an axis-aligned bounding box, which has extremely high computational efficiency and is suitable for fast collision detection in long-distance, low-performance budget scenarios.

[0234] Generating Level 1: Considering that voxelized convex decomposition algorithms such as Volumetric Hierarchical Approximate Convex Decomposition (VHACD) typically use topologically-based triangular meshes as standard input, to generate the second collision proxy L1 (Level 1), we can first process the point set... P k Perform convex hull calculation (Quickhull) to obtain an initial convex hull mesh, and then use the initial convex hull mesh as a reference boundary for the point set. P k Spatial partitioning, such as binary splitting along the PCA principal axis or K-Means sub-clustering, thereby... P kThe process recursively decomposes the data into several subsets of points, and then performs Quickhull convex hull calculations on each subset to obtain a combination of multiple convex bodies, which is the second collision proxy L1 (Level 1). It's understandable that this generation method operates entirely on the point set, eliminating the need for complete triangular mesh reconstruction steps such as Poisson reconstruction. Furthermore, an approximate convex decomposition tool that supports direct input of point clouds, such as the point set mode of VHACDv4 or similar algorithms, is used to generate the second collision proxy L1.

[0235] Determine the target physics engine type: Based on the physics engine used in the game project, select the corresponding serialization target. It supports the three major game physics engines: PhysX, Bullet, and Havok, achieving multi-engine compatibility through conditional compilation. For example, to adapt to the PhysX engine, it can output the PxConvexMesh format, which converts the multi-level collision proxy into the PhysX engine's native collision description format, PxConvexMesh. The physics engine can directly load and use this format without additional format parsing.

[0236] For example, to adapt to the Bullet engine, the btConvexHullShape format can be output, which means serializing the collision proxy data into the Bullet engine's native btConvexHullShape format. The high-precision proxy is encapsulated in a composite shape to adapt to Bullet's collision detection logic.

[0237] For example, to adapt to the Havok engine, it can output the hkpConvexVerticesShape format, which is to convert the collision proxy data into the native hkpConvexVerticesShape format of the Havok engine, eliminate the intermediate conversion layer, reduce runtime performance overhead, and achieve seamless integration between 3DGS assets and the game physics system.

[0238] To explain more clearly Figure 7 For details on the skeletal joint rigging process during the 3DGS asset import phase, please refer to [link / reference]. Figure 9 , that is Figure 9 As shown, the electronic device first calculates the cluster centroid, which is the spatial center position of the Gaussian fundamental unit cluster. Specifically, it first extracts all Gaussian fundamental units within the cluster. g i The mean vector μ i Then for these mean vectors μ i The geometric center of the cluster in three-dimensional space is obtained by taking the arithmetic mean. That is, the cluster centroid.

[0239] Then, each Gaussian fundamental unit cluster C k nearest skeletal joint bk * Specifically, with the cluster centroid Using the reference point, traverse all joints of the virtual object's skeletal model. b k Calculate the cluster centroid b k With each joint b k The Euclidean distance is used to mark the keypoint with the smallest distance as... b k * This completes the automatic binding of Gaussian clusters to bone joints.

[0240] Finally, construct the initial offset matrix. Specifically, based on cluster centroid b k With binding joints b k * The initial pose is used to construct a fixed offset matrix. This matrix records the position transformation relationship of the collision agent relative to the bound joint coordinate system and remains unchanged during runtime. When the skeleton pose changes, this matrix and the joint transformation matrix are used to calculate and quickly update the collision agent pose synchronously, ensuring that the collision shape is consistent with the visual model.

[0241] To explain more clearly Figure 7 For the incremental update of dirty-flag, please refer to [link / reference]. Figure 10 , that is Figure 10 As shown, the details are as follows: Skeletal animation frame output joint transformation During game runtime, each frame, the skeletal animation system completes the bone pose calculation for the current frame and outputs the global transformation matrix for all joints in the skeletal joint tree. This matrix contains the rotation and displacement parameters of the joints.

[0242] Change joint set Δ B (t) The system compares the global transformation matrix of the current frame with that of the previous frame. Filter out the set of joints that have undergone displacement / rotation Δ B (t) It only locks the joints whose posture actually changes, rather than traversing all joints.

[0243] dirty-flag flags affected collision agents: based on the variable joint set Δ B (t) The 3DGS Gaussian cluster collision proxies that are bound to this joint will be uniformly marked as dirty, indicating that the pose of this type of collision proxy has expired and needs to be recalculated and updated.

[0244] The system performs a dirty status check on each collision proxy. If the check is positive, it indicates that the joints bound to the collision proxy have undergone an attitude change and their poses need to be updated. If the check is negative, the joints bound to the collision proxy have not undergone an attitude change and do not need to be updated.

[0245] Update pose: For dirty state collision proxy, based on the constant offset matrix pre-calculated during asset import. Combined with the current frame joint global transformation matrix The latest pose of the collision agent is calculated by matrix multiplication. This ensures that the relative position of the collision agent and the skeletal joints remains constant, matching the visual form of the 3DGS assets.

[0246] Preserve Pose (Skip): For collision proxies that are not in a dirty state, directly retain the pose data of the previous frame, without performing any matrix calculations or data modifications, minimizing invalid calculations and ensuring stable frame rate during game runtime.

[0247] Physics engine synchronization PxRigidDynamic / btRigidBody: updates collision proxy pose data The target physics engine synchronizes its native kinematic rigid body with the physics engine. For example, for the PhysX engine, the target is pre-set to kinematic mode using `setRigidBodyFlag(PxRigidBodyFlag::eKINEMATIC, true)`, and then the `PxRigidDynamic::setKinematicTarget()` interface is called for synchronization. For the Bullet engine, `btRigidBody::setWorldTransform()` is called, along with the kinematic rigid body interface marked with `CF_KINEMATIC_OBJECT` for synchronization. For the Havok engine, `hkpKeyframedRigidBody::setPositionAndRotation()` is called for synchronization. It's important to note that these interface calls must be executed within a safe window between the completion of the physics engine's `simulate()` function and the start of the next frame's `simulate()` function to avoid data races. Furthermore, synchronization with the physics engine allows it to acquire the latest collision shape and pose, providing valuable data for collision detection.

[0248] Clear dirty-flag: After completing the update / skip processing of all collision proxies in the current frame, clear the dirty flag of all collision proxies in a unified manner, reset the state to wait for the bone pose change in the next frame to trigger, forming a closed-loop update mechanism.

[0249] To facilitate better implementation of the game data processing method of this application embodiment, this application embodiment also provides a game data processing apparatus. Please refer to... Figure 11 , Figure 11 A schematic diagram of the structure of a data processing device in a game provided in an embodiment of this application. The data processing device 200 in the game includes: The acquisition module 210 is used to acquire three-dimensional Gaussian splash model data of virtual objects in the target game scene. The three-dimensional Gaussian splash model data includes multiple Gaussian basic units and unit attribute parameters of each Gaussian basic unit. The unit attribute parameters include at least a covariance matrix parameter and a mean vector. The covariance matrix parameter is used to indicate the shape of the Gaussian basic unit, and the mean vector is used to indicate the position of the midpoint of the Gaussian basic unit. The partitioning module 220 is used to partition multiple Gaussian basic units into multiple Gaussian basic unit clusters according to the unit attribute parameters of each Gaussian basic unit, wherein each Gaussian basic unit cluster includes at least one Gaussian basic unit. The construction module 230 is used to construct a collision proxy corresponding to each Gaussian basic unit cluster based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster. The collision proxy is used to indicate the collision range of some virtual objects in the target game scene. Some virtual objects are constructed by Gaussian basic units within the Gaussian basic unit cluster. The detection module 240 is used to detect collision events of virtual objects in the target game scene based on collision proxy, and trigger corresponding physical feedback based on the collision events.

[0250] In some embodiments, the cell attribute parameters further include an opacity parameter. The partitioning module 220 is further configured to perform a filtering process on multiple Gaussian basic cells according to a predetermined opacity threshold and the opacity parameter of each Gaussian basic cell to obtain multiple active Gaussian basic cells with opacity parameters greater than the opacity threshold, and to partition the multiple active Gaussian basic cells into multiple Gaussian basic cell clusters according to the cell attribute parameters of each active Gaussian basic cell.

[0251] In some embodiments, the partitioning module 220 is further configured to perform clustering processing on multiple active Gaussian basic units according to the unit attribute parameters of each active Gaussian basic unit to obtain multiple Gaussian basic unit clusters.

[0252] In some embodiments, the partitioning module 220 is further configured to determine the inter-unit distance between pairs of active Gaussian basic units in the plurality of active Gaussian basic units based on the mean vector and covariance matrix parameters of each active Gaussian basic unit, and to partition the plurality of active Gaussian basic units into a plurality of Gaussian basic unit clusters based on the inter-unit distance between pairs of active Gaussian basic units and the maximum principal axis radius of each Gaussian basic unit, wherein the maximum principal axis radius is obtained by performing eigenvalue decomposition on the covariance matrix parameters of the Gaussian basic units.

[0253] In some embodiments, collision proxies include multiple collision proxies, each with a different level of precision; the higher the precision of the collision proxies, the closer the target range indicated by the collision proxies is to the outline of the virtual object.

[0254] In some embodiments, the construction module 230 is further configured to construct multiple collision proxies with different accuracies based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster.

[0255] In some embodiments, the plurality of collision proxies includes a first collision proxy and a second collision proxy, wherein the accuracy of the second collision proxy is greater than that of the first collision proxy.

[0256] In some embodiments, the construction module 230 is further configured to construct a bounding box or convex hull capable of wrapping multiple Gaussian basic unit clusters based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster, thereby obtaining a first collision proxy.

[0257] In some embodiments, the second collision agent includes multiple second collision agents, each corresponding to at least one Gaussian basic unit cluster. The construction module 230 is further configured to perform an approximate convex decomposition on the Gaussian basic unit cluster based on the mean vector of each Gaussian basic unit within the cluster, thereby splitting the Gaussian basic unit cluster into multiple convex sub-bodies, and determining the multiple convex sub-bodies as the second collision agents corresponding to the Gaussian basic unit cluster. The multiple convex sub-bodies are capable of enclosing the Gaussian basic unit cluster.

[0258] In some embodiments, the detection module 240 is further configured to detect and respond to virtual object collision events based on a first collision proxy when the distance between the virtual object and the virtual camera in the target game is greater than a first threshold, the display proportion of the virtual object in the display window of the target game is less than a second threshold, or the calculation time of the current physical frame of the target game is greater than a third threshold; and to detect and respond to virtual object collision events based on a second collision proxy when the distance between the virtual object and the target object in the target game is less than a fourth threshold, the display proportion increases for multiple consecutive frames, or the virtual object is marked as a high interaction priority, wherein the target object is able to perform virtual interaction with the virtual object.

[0259] In some embodiments, the detection module 240 is further configured to generate collision proxy description data corresponding to each Gaussian basic unit cluster based on multiple collision proxies with different accuracies, convert the collision proxy description data corresponding to each Gaussian basic unit cluster into data in a target format to obtain collision proxy description conversion data, and load the collision proxy description conversion data into the physics engine of the target game, so that the physics engine of the target game can perform the detection and response to virtual object collision events through the loaded collision proxy description conversion data. The collision proxy description data is used to indicate the collision proxies corresponding to the Gaussian basic unit clusters, and the physics engine of the target game can perform collision event detection and response through the data in the target format.

[0260] In some embodiments, the three-dimensional Gaussian splash model further includes a skeletal model of a virtual object, the skeletal model including multiple skeletal joints and the joint position of each skeletal joint, and the processing device 200 further includes: The binding module is used to bind each Gaussian basic unit cluster to the nearest bone joint based on the target position of each Gaussian basic unit cluster in the target game scene and the joint position of each bone joint. The update module is used to respond to the pose changes of the target joints in the skeletal model and synchronously update the pose of the target collision agent so that the pose of the target collision agent matches the pose of the target joints. The target joints are bound to the target Gaussian basic unit clusters, and the target Gaussian basic unit clusters correspond to the target collision agent.

[0261] In some embodiments, the update module is further configured to, in response to the pose change of the target joint in the skeletal model, determine the target Gaussian basic unit cluster bound to the target joint, mark each target collision agent corresponding to the target Gaussian basic unit cluster, and update the pose of each marked target collision agent.

[0262] In some embodiments, the processing apparatus 200 further includes a data construction module 230. The data construction module 230 is used to construct position transformation data corresponding to each Gaussian basic unit cluster, wherein the position transformation data is used to indicate the position transformation relationship between the position of the joints bound to the Gaussian basic unit cluster and the target position of the collision agent corresponding to the Gaussian basic unit cluster. Furthermore, the update module is also used to update the pose of the target collision agent based on the position transformation data corresponding to the Gaussian basic unit cluster and the pose of the target joints.

[0263] In some embodiments, the data construction module 230 is further configured to determine the mean value of the mean vector of each Gaussian basic unit in the Gaussian basic unit cluster as the cluster center of the Gaussian basic unit cluster in the first spatial coordinate system, and construct the offset matrix corresponding to the Gaussian basic unit cluster based on the cluster center of the Gaussian basic unit cluster to obtain the position transformation relationship, wherein the offset matrix is ​​used to indicate the transformation relationship of the target position of the Gaussian basic unit cluster in the first spatial coordinate system to the joint point bound to the Gaussian basic unit cluster in the second spatial coordinate system.

[0264] The various units in the data processing device of the aforementioned game can be implemented entirely or partially through software, hardware, or a combination thereof. These units can be embedded in or independent of the processor in the electronic device in hardware form, or stored in the memory of the electronic device in software form, so that the processor can call and execute the operations corresponding to these units.

[0265] The data processing device 200 in the game can be integrated into a terminal or server that has storage and a processor and thus computing power, or the data processing device 200 in the game can be that terminal or server.

[0266] Optionally, this application also provides an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the above-described method embodiments.

[0267] Figure 12 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. The electronic device may be a terminal or a server. Figure 12 As shown, the electronic device 300 includes a processor 301 with one or more processing cores, a memory 302 with one or more computer-readable storage media, and a computer program stored in the memory 302 and executable on the processor. The processor 301 and the memory 302 are electrically connected. Those skilled in the art will understand that the electronic device structure shown in the figures does not constitute a limitation on the electronic device, and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0268] The processor 301 is the control center of the electronic device 300. It connects various parts of the electronic device 300 through various interfaces and lines. By running or loading software programs and / or modules stored in the memory 302, and calling data stored in the memory 302, it executes various functions of the electronic device 300 and processes data, thereby performing overall processing of the electronic device 300.

[0269] In this embodiment, the processor 301 in the electronic device 300 loads the instructions corresponding to the processes of one or more computer programs into the memory 302 according to the following steps, and the processor 301 runs the computer programs stored in the memory 302 to realize various functions: Obtain the 3D Gaussian splash model data of virtual objects in the target game scene. The 3D Gaussian splash model data includes multiple Gaussian basic units and unit attribute parameters for each Gaussian basic unit. The unit attribute parameters include at least the covariance matrix parameter and the mean vector. The covariance matrix parameter is used to indicate the shape of the Gaussian basic unit, and the mean vector is used to indicate the position of the midpoint of the Gaussian basic unit. Based on the element attribute parameters of each Gaussian element, multiple Gaussian elements are divided into multiple Gaussian element clusters, wherein each Gaussian element cluster includes at least one Gaussian element. Based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster, a collision proxy is constructed for each Gaussian basic unit cluster. The collision proxy is used to indicate the collision range of some virtual objects in the target game scene. Some virtual objects are constructed from Gaussian basic units within the Gaussian basic unit cluster. Based on collision proxy, collision events of virtual objects in the target game scene are detected, and corresponding physical feedback is triggered based on the collision events.

[0270] For details on the implementation of each of the above operations, please refer to the previous examples, which will not be repeated here.

[0271] Optional, such as Figure 12 As shown, the electronic device 300 also includes: a display screen 303, a radio frequency circuit 304, an audio circuit 305, an input unit 306, and a power supply 307. The processor 301 is electrically connected to the display screen 303, the radio frequency circuit 304, the audio circuit 305, the input unit 306, and the power supply 307. Those skilled in the art will understand that... Figure 12 The electronic device structure shown does not constitute a limitation on the electronic device and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0272] The display screen 303 can be used to display a graphical user interface (GUI) and receive operation commands generated by the user interacting with the GUI. The display screen 303 may include a display panel and a touch panel. The display panel can be used to display information input by the user or information provided to the user, as well as various graphical user interfaces of the electronic device. These graphical user interfaces can be composed of graphics, text, icons, video, and any combination thereof. The touch panel can be used to collect touch operations performed by the user on or near it (such as operations performed by the user using a finger, stylus, or any suitable object or accessory on or near the touch panel), generate corresponding operation commands, and execute the corresponding program. Optionally, the touch panel may include a touch detection device and a touch controller. The touch detection device detects the user's touch location and the signal generated by the touch operation, and transmits the signal to the touch controller. The touch controller receives touch information from the touch detection device, converts it into touch point coordinates, sends it to the processor 301, and can receive and execute commands from the processor 301. The touch panel can cover the display panel. When the touch panel detects a touch operation on or near it, it transmits the information to the processor 301 to determine the type of touch event. Subsequently, the processor 301 provides corresponding visual output on the display panel according to the type of touch event. In this embodiment, the touch panel and the display panel can be integrated into the display screen 303 to achieve input and output functions. However, in some embodiments, the touch panel and the display screen 303 can be implemented as two independent components to achieve input and output functions. That is, the display screen 303 can also be used as part of the input unit 306 to achieve input functions.

[0273] The radio frequency circuit 304 can be used to transmit and receive radio frequency signals to establish wireless communication with network devices or other electronic devices, and to transmit and receive signals with network devices or other electronic devices.

[0274] Audio circuitry 305 can be used to provide an audio interface between a user and an electronic device via a speaker and a microphone. Audio circuitry 305 converts received audio data into electrical signals, transmits them to the speaker, and the speaker converts them into sound signals for output. Conversely, the microphone converts collected sound signals into electrical signals, which are then received by audio circuitry 305, converted back into audio data, and then processed by processor 301 before being transmitted via radio frequency circuitry 304 to, for example, another electronic device, or output to memory 302 for further processing. Audio circuitry 305 may also include an earphone jack to facilitate communication between peripheral headphones and electronic devices.

[0275] The input unit 306 can be used to receive input numbers, characters, or object feature information (such as fingerprints, irises, facial information, etc.), and to generate keyboard, mouse, joystick, optical, or trackball signal inputs related to user settings and function control.

[0276] Power supply 307 is used to supply power to various components of electronic device 300. Optionally, power supply 307 can be logically connected to processor 301 through a power management system, thereby enabling functions such as charging, discharging, and power consumption management through the power management system. Power supply 307 may also include one or more DC or AC power supplies, recharging systems, power fault detection circuits, power converters or inverters, power status indicators, and other arbitrary components.

[0277] although Figure 12 As not shown in the diagram, the electronic device 300 may also include a camera, sensor, wireless fidelity module, Bluetooth module, etc., which will not be described in detail here.

[0278] This application also provides a computer-readable storage medium for storing a computer program. This computer-readable storage medium can be applied to a computer device, and the computer program causes the computer device to execute the corresponding flow in the data processing method of the game in the embodiments of this application; for the sake of brevity, further details are omitted here.

[0279] This application also provides a computer program product including computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the corresponding flow in the data processing method of the game in the embodiments of this application. For simplicity, further details are omitted here.

[0280] This application also provides a computer program comprising computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the corresponding flow in the data processing method of the game described in this application. For brevity, further details are omitted here.

[0281] It should be understood that the processor in this application may be an integrated circuit chip with signal processing capabilities. In implementation, the steps of the above method embodiments can be completed by integrated logic circuits in the processor's hardware or by instructions in software form. The processor described above can be a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. It can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of this application. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the methods disclosed in the embodiments of this application can be directly embodied in the execution of a hardware decoding processor, or executed by a combination of hardware and software modules in the decoding processor. The software modules can be located in random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, registers, or other mature storage media in the art. This storage medium is located in memory, and the processor reads information from the memory and, in conjunction with its hardware, completes the steps of the above method.

[0282] It is understood that the memory in the embodiments of this application can be volatile memory or non-volatile memory, or may include both volatile and non-volatile memory. The non-volatile memory can be read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or flash memory. The volatile memory can be random access memory (RAM), which is used as an external cache. By way of example, but not limitation, many forms of RAM are available, such as Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), Synchronous DRAM (SDRAM), Double Data Rate SDRAM (DDR SDRAM), Enhanced Synchronous DRAM (ESDRAM), Synchlink DRAM (SLDRAM), and Direct Rambus RAM (DR RAM). It should be noted that the memory used in the systems and methods described herein is intended to include, but is not limited to, these and any other suitable types of memory.

[0283] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0284] 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.

[0285] In the embodiments of this application, the terms "module" or "unit" refer to a computer program or part of a computer program that has a predetermined function and works with other related parts to achieve a predetermined goal, and can be implemented wholly or partially using software, hardware (such as processing circuitry or memory), or a combination thereof. Similarly, a processor (or multiple processors or memory) can be used to implement one or more modules or units. Furthermore, each module or unit can be part of an overall module or unit that includes the functionality of that module or unit.

[0286] 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. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or units may be electrical, mechanical, or other forms.

[0287] 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.

[0288] In addition, the functional units in 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.

[0289] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a 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 or a server) 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, ROM, RAM, magnetic disks, or optical disks.

[0290] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included 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 data processing method in a game, characterized by, The method includes: Obtain three-dimensional Gaussian splash model data of virtual objects in the target game scene, wherein the three-dimensional Gaussian splash model data includes multiple Gaussian basic units and unit attribute parameters of each Gaussian basic unit. The unit attribute parameters include at least a covariance matrix parameter and a mean vector. The covariance matrix parameter is used to indicate the shape of the Gaussian basic unit, and the mean vector is used to indicate the position of the midpoint of the Gaussian basic unit. Based on the unit attribute parameters of each Gaussian basic unit, the plurality of Gaussian basic units are divided into a plurality of Gaussian basic unit clusters, wherein each Gaussian basic unit cluster includes at least one Gaussian basic unit. Based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster, a collision proxy is constructed corresponding to each Gaussian basic unit cluster. The collision proxy is used to indicate the collision range of a portion of virtual objects in the target game scene. The portion of virtual objects is constructed by the Gaussian basic units within the Gaussian basic unit cluster. Based on the collision proxy, collision events of the virtual objects in the target game scene are detected, and corresponding physical feedback is triggered based on the collision events.

2. The data processing method in a game according to claim 1, wherein, The unit attribute parameters also include an opacity parameter. Dividing the plurality of Gaussian basic units into plurality of Gaussian basic unit clusters based on the unit attribute parameters of each Gaussian basic unit includes: Based on a predetermined opacity threshold and the opacity parameter of each Gaussian basic unit, the plurality of Gaussian basic units are filtered to obtain a plurality of active Gaussian basic units whose opacity parameter is greater than the opacity threshold. Based on the unit attribute parameters of each active Gaussian basic unit, the plurality of active Gaussian basic units are divided into the plurality of Gaussian basic unit clusters.

3. The data processing method in a game according to claim 2, wherein, The step of dividing the plurality of active Gaussian basic units into the plurality of Gaussian basic unit clusters according to the unit attribute parameters of each active Gaussian basic unit includes: Based on the unit attribute parameters of each active Gaussian basic unit, the plurality of active Gaussian basic units are clustered to obtain the plurality of Gaussian basic unit clusters.

4. The data processing method in a game according to claim 3, wherein, The step of clustering the multiple active Gaussian basic units according to the unit attribute parameters of each active Gaussian basic unit to obtain the multiple Gaussian basic unit clusters includes: Based on the mean vector and covariance matrix parameters of each active Gaussian basic unit, the inter-unit distance between each pair of active Gaussian basic units is determined. Based on the inter-unit distance between each pair of active Gaussian basic units and the maximum principal axis radius of each Gaussian basic unit, the plurality of active Gaussian basic units are divided into a plurality of Gaussian basic unit clusters, wherein the maximum principal axis radius is obtained by eigenvalue decomposition of the covariance matrix parameters of the Gaussian basic units.

5. The data processing method in a game according to Claim 1, wherein The collision proxy includes multiple collision proxies, each with a different level of precision; the higher the precision of the collision proxy, the closer the target range indicated by the collision proxy is to the outline of the virtual object.

6. The data processing method in the game according to claim 5, characterized in that, The step of constructing a collision proxy corresponding to each Gaussian basic unit cluster based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster includes: Based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster, multiple collision proxies with different accuracies are constructed.

7. The data processing method in the game according to claim 6, characterized in that, The plurality of collision proxies includes a first collision proxy and a second collision proxy, wherein the accuracy of the second collision proxy is greater than that of the first collision proxy.

8. The data processing method in the game according to claim 7, characterized in that, The step of constructing multiple collision proxies with different accuracies based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster includes: Based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster, a bounding box or convex hull capable of enclosing the plurality of Gaussian basic unit clusters is constructed to obtain the first collision proxy.

9. The data processing method in the game according to claim 7, characterized in that, The second collision proxy includes multiple proxies, each of which corresponds to at least one Gaussian basic unit cluster. The step of constructing multiple collision proxies with different precisions based on the mean vector of each Gaussian basic unit within each Gaussian basic unit cluster includes: Based on the mean vector of each Gaussian basic unit within the Gaussian basic unit cluster, an approximate convex decomposition is performed on the Gaussian basic unit cluster to split the Gaussian basic unit cluster into multiple convex sub-bodies, wherein the multiple convex sub-bodies can enclose the Gaussian basic unit cluster. The plurality of convex subbodies are identified as the second collision agents corresponding to the Gaussian basic unit cluster.

10. The data processing method in the game according to claim 7, characterized in that, The step of detecting collision events of virtual objects in the target game scene based on the collision proxy, and triggering corresponding physical feedback based on the collision events, includes: When the distance between the virtual object and the virtual camera in the target game is greater than a first threshold, the display area of ​​the virtual object in the display window of the target game is less than a second threshold, or the calculation time of the current physical frame of the target game is greater than a third threshold, the first collision proxy of the virtual object detects the collision event of the virtual object and triggers the corresponding physical feedback based on the collision event. When the distance between the virtual object and the target object in the target game is less than a fourth threshold, the display ratio increases for multiple consecutive frames, or the virtual object is marked as having high interaction priority, the second collision proxy based on the virtual object detects the collision event of the virtual object and triggers corresponding physical feedback based on the collision event, wherein the target object is able to perform virtual interaction with the virtual object.

11. The data processing method in the game according to claim 5, characterized in that, The step of detecting collision events of virtual objects in the target game scene based on the collision proxy, and triggering corresponding physical feedback based on the collision events, includes: Based on the multiple collision proxies with different accuracies, collision proxy description data is generated for each Gaussian basic unit cluster, wherein the collision proxy description data is used to indicate the collision proxy corresponding to the Gaussian basic unit cluster; The collision proxy description data corresponding to each Gaussian basic unit cluster is converted into data in the target format to obtain collision proxy description conversion data, wherein the physics engine of the target game can perform collision event detection and response through the data in the target format; The collision proxy description conversion data is loaded into the physics engine of the target game, so that the physics engine of the target game can perform the detection of the virtual object collision event through the loaded collision proxy description conversion data, and trigger the corresponding physical feedback based on the collision event.

12. The data processing method in the game according to claim 1, characterized in that, The three-dimensional Gaussian splash model also includes a skeletal model of the virtual object, the skeletal model including multiple skeletal joints and the joint position of each skeletal joint, and the method further includes: Based on the target position of each Gaussian basic unit cluster in the target game scene and the joint position of each skeletal joint, each Gaussian basic unit cluster is bound to the nearest skeletal joint. In response to the pose change of the target joint in the skeletal model, the pose of the target collision agent is updated synchronously so that the pose of the target collision agent matches the pose of the target joint, wherein the target joint is bound to the target Gaussian basic unit cluster, and the target Gaussian basic unit cluster corresponds to the target collision agent.

13. The data processing method in the game according to claim 12, characterized in that, The step of synchronously updating the pose of the target collision agent in response to pose changes of the target joints in the skeletal model, so that the pose of the target collision agent matches the pose of the target joints, includes: In response to the pose change of the target joint in the skeleton model, the target Gaussian basic unit cluster bound to the target joint is determined; Each of the target collision agents corresponding to the target Gaussian basic unit cluster is marked; Update the pose of each of the labeled target collision agents.

14. The data processing method in the game according to claim 12, characterized in that, The method further includes: Construct position transformation data for each Gaussian basic unit cluster, wherein the position transformation data is used to indicate the position transformation relationship between the position of the joint bound to the Gaussian basic unit cluster and the target position of the collision agent corresponding to the Gaussian basic unit cluster; The pose of the updated target collision agent includes: The pose of the target collision agent is updated based on the position transformation data corresponding to the Gaussian basic unit cluster and the pose of the target joint.

15. The data processing method in the game according to claim 14, characterized in that, The construction of position transformation data corresponding to each Gaussian basic unit cluster includes: The mean value of the mean vector of each Gaussian basic unit in the Gaussian basic unit cluster is determined as the cluster center of the Gaussian basic unit cluster in the first spatial coordinate system; Based on the cluster center of the Gaussian basic unit cluster, an offset matrix corresponding to the Gaussian basic unit cluster is constructed to obtain the position transformation relationship. The offset matrix is ​​used to indicate the transformation relationship of the target position of the Gaussian basic unit cluster in the first spatial coordinate system to the joint point bound to the Gaussian basic unit cluster in the second spatial coordinate system.

16. A data processing device for a game, characterized in that, The device includes: The acquisition module is used to acquire three-dimensional Gaussian splash model data of virtual objects in the target game scene. The three-dimensional Gaussian splash model data includes multiple Gaussian basic units and unit attribute parameters of each Gaussian basic unit. The unit attribute parameters include at least a covariance matrix parameter and a mean vector. The covariance matrix parameter is used to indicate the shape of the Gaussian basic unit, and the mean vector is used to indicate the position of the midpoint of the Gaussian basic unit. A partitioning module is used to partition the plurality of Gaussian basic units into a plurality of Gaussian basic unit clusters according to the unit attribute parameters of each Gaussian basic unit, wherein each Gaussian basic unit cluster includes at least one Gaussian basic unit. A construction module is used to construct a collision proxy corresponding to each Gaussian basic unit cluster based on the unit attribute parameters of each Gaussian basic unit within each Gaussian basic unit cluster. The collision proxy is used to indicate the collision range of a portion of virtual objects in the target game scene. The portion of virtual objects is constructed by the Gaussian basic units within the Gaussian basic unit cluster. The detection module is used to detect collision events of the virtual objects in the target game scene based on the collision proxy, and trigger corresponding physical feedback based on the collision events.

17. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program adapted for loading by a processor to perform the data processing method in a game according to any one of claims 1-15.

18. An electronic device, characterized in that, The electronic device includes a processor and a memory, the memory storing a computer program, and the processor executing the data processing method in the game according to any one of claims 1-15 by calling the computer program stored in the memory.

Images