Method and device for realizing high-performance particle effect rendering

Abstract

The invention provides a method and a device for realizing high-performance particle effect rendering, computing equipment and a computer readable storage medium, and the method comprises the steps: processing the initialization work of a particle system at a CPU end, and simplifying the complex functions of the particle system, so that the calculation is completed in advance at the initialization stage; meanwhile, a plurality of particle characteristic modules are created at the CPU end, and complex movement of particles is refined. The particle instance and the particle characteristic module instance are uploaded to a GPU together, a particle system is updated in a vertex shader of the GPU according to the particle instance and the particle characteristic module instance, and therefore rendering data are output to a fragment shader of the GPU to complete final rendering of the particle effect. According to the embodiment of the invention, the calculation method of the particle system is simplified, so that the calculation method can be transplanted to the vertex shader of the GPU to complete the updating of the particles, the overall rendering efficiency of the system is improved, and the method is particularly suitable for a small game platform of a mobile terminal.

Description

Technical Field

[0001] This application relates to the field of computer graphics rendering technology, and particularly to a method and device for implementing high-performance particle special effect rendering, a computing device, and a computer-readable storage medium. Background Art

[0002] The particle system is a computer graphics technology used to simulate natural phenomena such as fire, smoke, clouds, dust, starlight, water flow, etc. These phenomena are difficult to represent through traditional geometric modeling methods. Therefore, the particle system introduces a large number of tiny particles, and simulates complex dynamic effects through the collective behavior of the particles. In the traditional particle system, the position, velocity, acceleration, life cycle, etc. of the particles are managed and updated by the CPU. The state of each particle is processed by the CPU in each frame, and the movement of the particles is simulated by updating the attributes of each particle one by one. However, with the improvement of GPU computing power, the particle special effect system increasingly turns to the GPU for parallel computing. For example, by using the Compute Shader of the GPU, the behavior of millions of particles can be simulated very efficiently. However, on various small game platforms, such as the WeChat mini-game platform, the Compute Shader is not supported. Therefore, the operating efficiency of the particle system on these platforms is relatively low. Summary of the Invention

[0003] In view of this, embodiments of the present application provide a method and device for implementing high-performance particle special effect rendering, a computing device, and a computer-readable storage medium to solve the technical defects existing in the prior art.

[0004] According to the first aspect of the embodiments of the present application, a method for implementing high-performance particle special effect rendering is provided, including:

[0005] Initializing the particle system in the CPU to generate multiple particle instances;

[0006] Creating multiple particle characteristic modules in the CPU, each of the particle characteristic modules being used to describe different particle motion characteristics;

[0007] Transmitting the initialized particle instances and particle characteristic module instances to the GPU; and completing the rendering of the particle special effects after calculating the target attributes of the particle instances according to the particle characteristic module instances in the GPU.

[0008] According to the second aspect of the embodiments of the present application, a device for implementing high-performance particle special effect rendering is provided, including:

[0009] An initialization unit for initializing the particle system in the CPU to generate multiple particle instances;

[0010] A creation unit, configured to create multiple particle feature modules in a CPU, where each of the particle feature modules is used to describe different particle motion characteristics;

[0011] An upload unit, configured to transfer the initialized particle instances and particle feature module instances to a GPU;

[0012] A rendering unit, configured to complete the rendering of particle special effects after calculating the target attributes of the particle instances according to the particle feature module instances in the GPU.

[0013] According to a third aspect of the embodiments of the present application, a computing device is provided, including a memory, a processor, and computer instructions stored on the memory and executable on the processor. When the processor executes the instructions, the steps of the method for realizing high-performance particle special effect rendering are implemented.

[0014] According to a fourth aspect of the embodiments of the present application, a computer-readable storage medium is provided, which stores computer instructions that, when executed by a processor, implement the steps of the method for realizing high-performance particle special effect rendering.

[0015] Through the method provided by the embodiments of the present application, the initialization work of the particle system is processed at the CPU side, and the complex functions of the particle system are simplified, supporting uniform speed particle emission, so that the calculation is completed in advance at the initialization stage. At the same time, multiple particle feature modules are created at the CPU side to refine the complex motion of the particles. Then, the particle instances and particle feature module instances are uploaded to the GPU together, and the particle system is updated according to the particle instances and particle feature module instances in the vertex shader of the GPU, so as to output rendering data to the fragment shader of the GPU to complete the final rendering of the particle special effects. The embodiments of the present application simplify the calculation method of the particle system, enabling it to be transplanted to the vertex shader of the GPU to complete the update of the particles, improving the overall rendering efficiency of the system, and being particularly applicable to mobile game platforms and low-end mobile devices that do not support Compute Shader. Description of the Drawings

[0016] Figure 1 is a structural block diagram of the computing device provided by the embodiments of the present application;

[0017] Figure 2 is a schematic flowchart of a method for realizing high-performance particle special effect rendering provided by the embodiments of the present application;

[0018] Figure 3 is a schematic structural diagram of a device for realizing high-performance particle special effect rendering provided by the embodiments of the present application. Detailed Embodiments

[0019] In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present application. However, the present application can be implemented in many other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the present application. Therefore, the present application is not limited by the specific implementations disclosed below.

[0020] The terms used in one or more embodiments of the present application are for the purpose of describing specific embodiments only and are not intended to limit one or more embodiments of the present application. The singular forms "a", "the", and "said" used in one or more embodiments of the present application and the appended claims are also intended to include the plural forms unless the context clearly dictates otherwise. It should also be understood that the term "and / or" used in one or more embodiments of the present application refers to and encompasses any or all possible combinations of one or more of the associated listed items.

[0021] It should be understood that although the terms first, second, etc. may be used in one or more embodiments of the present application to describe various information, such information should not be limited to these terms. These terms are only used to distinguish information of the same type from each other. For example, without departing from the scope of one or more embodiments of the present application, the first may also be referred to as the second, and similarly, the second may also be referred to as the first. Depending on the context, the word "if" as used herein may be interpreted as "in response to determining".

[0022] In the present application, a method and apparatus for implementing high-performance particle effect rendering, a computing device, and a computer-readable storage medium are provided, which will be described in detail one by one in the following embodiments.

[0023] Figure 1 A structural block diagram of a computing device 100 according to an embodiment of the present application is shown. The components of the computing device 100 include, but are not limited to, a memory 110 and a processor 120. The processor 120 is connected to the memory 110 through a bus 130, and a database 150 is used to store data.

[0024] The computing device 100 further includes an access device 140, which enables the computing device 100 to communicate via one or more networks 160. Examples of such networks include the Public Switched Telephone Network (PSTN), Local Area Network (LAN), Wide Area Network (WAN), Personal Area Network (PAN), or a combination of communication networks such as the Internet. The access device 140 may include one or more of any type of wired or wireless network interface (e.g., Network Interface Card (NIC)), such as an IEEE802.11 Wireless Local Area Network (WLAN) wireless interface, Worldwide Interoperability for Microwave Access (Wi-MAX) interface, Ethernet interface, Universal Serial Bus (USB) interface, cellular network interface, Bluetooth interface, Near Field Communication (NFC) interface, and so on.

[0025] In one embodiment of the present application, the above components of the computing device 100 and Figure 1 other components not shown therein may also be connected to each other, for example, via a bus. It should be understood that Figure 1 the block diagram of the computing device shown is for illustrative purposes only and is not a limitation on the scope of the present application. Those skilled in the art may add or replace other components as needed.

[0026] The computing device 100 can be any type of stationary or mobile computing device, including mobile computers or mobile computing devices (e.g., tablet computers, personal digital assistants, laptop computers, notebook computers, netbooks, etc.), mobile phones (e.g., smartphones), wearable computing devices (e.g., smartwatches, smart glasses, etc.) or other types of mobile devices, or stationary computing devices such as desktop computers or PCs.

[0027] In the prior art, the position, velocity, acceleration, life cycle, etc. of particles in a particle system are all managed and updated by the CPU. The state of each particle is processed by the CPU in each frame, and its motion is simulated by updating the attributes of each particle one by one. The advantages are strong flexibility, and it can easily implement complex particle behaviors; it supports complex particle logic and can add more non-linear and complex physical effects, such as interactions between particles and collisions with the scene. The disadvantage is that for the calculation of a large number of particles, the performance of the CPU often becomes a bottleneck, especially when the state of each particle needs to be updated. Calculating the behavior of each particle consumes a large amount of time, resulting in a drop in the frame rate.

[0028] Therefore, in the prior art, there are solutions that combine the CPU and GPU. For example, in CN117058304A, the CPU is used to calculate the target attribute values of each particle, and then these target attribute values are passed to the GPU. The GPU is used to perform particle rendering on each particle object respectively to obtain the final particle special effects. However, in this solution, the CPU is still used to calculate the target attribute values of the particles, which consumes a large amount of resources and has a performance bottleneck. It is not suitable for the large-scale particle systems required in large-scale battles. Especially when the combat units and skill effects are intensive, it is required that the particle special effects must be presented efficiently to avoid affecting the game fluency due to performance issues.

[0029] Therefore, in the embodiments of the present application, in order to solve the above problems, a method for implementing high-performance particle special effect rendering is proposed. Refer to Figure 2 , Figure 2 FIG. shows a flowchart of a method for implementing high-performance particle special effect rendering according to an embodiment of the present application, including steps 202 to 206.

[0030] Step 202: Complete the initialization of the particle system in the CPU and generate multiple particle instances.

[0031] In this step, the initialization of the particle system is completed, and multiple particles required for the particle special effects are generated, including but not limited to: the total number of particles, the current position of the particles, the initial velocity of the particles, the initial rotation of the particles, the initial size of the particles, the lifespan of the particles, etc. For example, when initializing the particle system in the CPU, it includes pre-generating a batch of particles and setting the initial attributes for each particle:

[0032]

[0033] In the above step, when initializing the particle system, the time interval of particle emission can be uniform, so each particle is evenly distributed throughout the duration; other simplified methods can also be used to implement particle emission, such as emitting n particles in the first second and 2n particles in the second second, etc. By adopting the simplified emission method, the initial attributes of all particles can be calculated once in the initialization stage, rather than dynamically calculating during the lifespan of the particles. By simplifying the functions of the particle system, complex attribute changes and calculations are removed. According to the characteristics of the rendering scene, adopting the simplified emission method can make the initial attributes of all particles be calculated once in the initialization stage and stored in the particle array. This method reduces the computational amount during operation and improves the operation efficiency, and is suitable for scenarios that require quick initialization and operation.

[0034] Step 204: Create multiple particle feature modules in the CPU, and each particle feature module is used to describe the particle target attributes related to time.

[0035] In this step, at least one particle property module is created for the particle system, and each particle property module corresponds to a different particle target property, which is a property value related to time variation and is used to describe the characteristics of each particle in the particle special effect.

[0036] In a feasible implementation, one particle property module is used to describe the movement trajectory of the particle. For example, the curve movement of the particle over time is described by multiple position keyframe information included in a particle property module ParticleModule:

[0037] class ParticleModule{

[0038] public keyFrames:Array <keyframe>();

[0039] public maxKeyFrameCount: number = 4;

[0040] public shaderName: string = "";

[0041] }

[0042] Among them, the keyFrames object array is used to store the information of multiple position key frames of the particle on the time axis. It defines the value of a certain attribute of the particle and the tangent information at a specific time point, which is used for curve interpolation calculation; maxKeyFrameCount represents the maximum number of key frames that can be stored; shaderName represents the name of the corresponding shader.

[0043] Furthermore, in a feasible implementation, the position key frame object may include the following attributes:

[0044] public time: number; / / The time point of the key frame

[0045] public leftTangent: Vec2; / / The left tangent, used for curve interpolation

[0046] public rightTangent: Vec2; / / The right tangent, used for curve interpolation

[0047] public value: number; / / The value of a certain attribute of the particle at the key frame (such as size, speed, etc.)

[0048] In another feasible implementation, another particle characteristic module is used to describe the color change characteristics of the particle. Similarly, the keyFrames object array is used to store the information of multiple color key frames of the particle on the time axis. It defines the color attribute value of the particle at a specific time point, which is used for color interpolation calculation; maxKeyFrameCount represents the maximum number of key frames that can be stored; shaderName represents the name of the corresponding shader.

[0049] Furthermore, the color key frame object includes the following attributes:

[0050] public time: number; / / The time point of the key frame

[0051] public value: number; / / The color attribute value of the particle at the key frame

[0052] Through these key-frame object instances, multiple target attributes of the particles can be controlled, such as the shape of the curvilinear motion, the color and size of the particles, etc., preparing for rendering the motion characteristics of the particles in the GPU.

[0053] Those skilled in the art should be aware that the above particle property module supports multiple target attributes, not limited to the positions and colors listed in the above embodiments, and will not be elaborated here.

[0054] Step 206: Transmit the initialized particles and the instance of the particle property module to the GPU; after calculating the target attributes of the particle instances according to the instance of the particle property module in the GPU, complete the rendering of the particle special effects.

[0055] In this step, the particles initialized in the CPU and the instance of the particle property module are transmitted to the GPU, enabling the GPU to calculate the target attributes of the particles according to the above content, and then complete the rendering of the particle special effects.

[0056] In a feasible implementation manner, an upload function is executed in the CPU, and the upload function includes:

[0057] Collect particle property data: Extract the properties from the initialized particle instance object and store them in a memory array.

[0058] Create a buffer object: Create a buffer object on the GPU, for example, by calling WebGL / OpenGL API instructions on the CPU to request the GPU to create a buffer.

[0059] Upload data to the GPU buffer: Upload the particle property data from the CPU side to the buffer of the GPU. Transmit the data to the GPU through the instructions on the CPU side.

[0060] Create and compile shaders: Write and compile vertex shaders, and create a shader program on the GPU. These compilation and linking operations request the GPU to execute through the instructions on the CPU side.

[0061] Associate the buffer and shader attributes: Through the instructions on the CPU side, associate the data in the buffer with the attribute variables in the shader. This includes calling API functions to bind the buffer and set the vertex attribute pointer, informing the GPU how to read the data from the buffer and pass it to the shader.

[0062] Furthermore, traverse the instance of the particle property module in the CPU and transmit it to the corresponding shader in the GPU. As shown in the following code, the instance of the particle property module can be transmitted to the shader of the GPU through the setUniform method in WebGL:

[0063] for (let ii = 0; ii < this.particleModules.length; ii++) {

[0064] let curModule = this.particleModules[ii];

[0065] this.mat.setUniform(curModule.shaderName + "_time",....);

[0066] this.mat.setUniform(curModule.shaderName + "_letfTangent",....);

[0067] this.mat.setUniform(curModule.shaderName + "_rightTangent",....);

[0068] this.mat.setUniform(curModule.shaderName + "_value",....);

[0069] }

[0070] }

[0071] Furthermore, in the vertex shader of the GPU, the target attributes are calculated based on the uploaded initialized particle instances and particle property module instances, and the actual particle property interpolation and rendering operations are performed in each frame update.

[0072] In a feasible implementation, the calculation of the target attributes of the particle, such as the vertex position, includes:

[0073] (1) Linear interpolation of particle properties:

[0074] if (isAlive)

[0075] {

[0076] float lerpV = (curTime - bornTime) / startLifetime; / / If the particle is within the valid lifetime, calculate the ratio of the current time in the particle's lifetime for interpolation

[0077] }

[0078] (2) Determination of key frame index:

[0079] timeIndex = step(size_time[1], lerpV) + step(size_time[2], lerpV); / / Determine which keyframe to use for interpolation based on the current time ratio

[0080] (3) Curve interpolation:

[0081] float value = bezierInterpolate(size_time[timeIndex], size_time[timeIndex + 1.0],

[0082] size_value[timeIndex], size_value[timeIndex + 1.0],

[0083] size_rightTangent[timeIndex], size_letfTangent[timeIndex + 1.0]); / / For example, use the Bezier interpolation function to calculate the interpolation result at the current time point according to the particle property module instance

[0084] (4) Vertex position calculation:

[0085] vec3 outpos = positon + partileSize * 0.5 * cameraUp + partileSize * 0.5 * cameraRight;

[0086] vec4 clippos = matMVP * vec4(outpos.xyz, 1.0); / / Get the coordinates of the particle in the clip space

[0087] In another possible implementation, the calculation of the target properties of the particle, such as the color of the particle, includes:

[0088] (1) Linear interpolation of particle properties:

[0089] if (isAlive)

[0090] {

[0091] float lerpV = (curTime - bornTime) / startLifetime; / / If the particle is within the valid lifetime, calculate the ratio of the current time in the particle's lifetime for interpolation

[0092] }

[0093] (2) Keyframe index determination:

[0094] Determine which key frame to use for interpolation based on the current time ratio.

[0095] (3) Interpolate the color

[0096] Perform linear interpolation on the color value of the particle based on the current time to generate a dynamically changing color.

[0097] Preferably, other target attributes of the particle, such as size, speed, force, UV coordinates, etc., can also be updated in the vertex shader according to the change of the particle life cycle. These target attributes can all be implemented according to the particle instance uploaded by the CPU and the particle characteristic module instance; and combined with the characteristics of the life cycle, the particles to be displayed are updated, and the particles that do not need to be displayed are set to positions outside the screen and not sent to the rendering process.

[0098] Furthermore, transfer the particle target attributes calculated by the vertex shader to the pixel shader or fragment shader, and use the pixel shader or fragment shader to render each particle to obtain the final rendering result of the particle.

[0099] In the above embodiments of the present application, in order to efficiently implement particle effects on the mobile device and avoid performance issues affecting the smoothness of the game, the initialization work of the particle system is processed on the CPU side, including initializing the information of each particle according to the emission parameters of the emitter, and simplifying the complex functions of the particle system to support uniform speed particle emission, so that the calculation is completed in advance during the initialization stage; at the same time, multiple particle characteristic modules are created on the CPU side to simplify the complex movement of the particles. Then, the particle instance and the particle characteristic module instance are uploaded to the GPU together, and multiple target attributes of the particle are calculated in the vertex shader of the GPU according to the particle instance and the particle characteristic module instance, so as to output the rendering data to the fragment shader of the GPU to complete the final rendering of the particle effect. The embodiments of the present application simplify the calculation method of the particle system, enabling it to be transplanted to the vertex shader of the GPU to complete the update of the particle, improving the overall rendering efficiency of the system, especially suitable for small game platforms on mobile devices, and also suitable for low-end mobile devices that do not support Compute Shader.

[0100] Corresponding to the above method embodiments, the present application also provides an embodiment of a device for implementing high-performance particle effect rendering, as Figure 3 shown, the device includes:

[0101] An initialization unit for completing the initialization of the particle system in the CPU;

[0102] A creation unit for creating multiple particle characteristic modules in the CPU, each of the particle characteristic modules being used to describe different particle motion characteristics;

[0103] An upload unit for transmitting the initialized particle instances and particle characteristic module instances to the GPU;

[0104] A rendering unit for rendering particle special effects after calculating the target attributes of the particle instances according to the particle characteristic module instances in the GPU.

[0105] The above is a schematic solution of a device for implementing high-performance particle special effect rendering in this embodiment. It should be noted that the technical solution of this device for implementing high-performance particle special effect rendering belongs to the same concept as the technical solution of the above method for implementing high-performance particle special effect rendering. For the details not described in detail in the technical solution of this device for implementing high-performance particle special effect rendering, reference can be made to the description of the technical solution of the above method for implementing high-performance particle special effect rendering.

[0106] In an embodiment of the present application, a computing device is further provided, including a memory, a processor, and computer instructions stored on the memory and executable on the processor. When the processor executes the instructions, the steps of the method for implementing high-performance particle special effect rendering are implemented.

[0107] The above is a schematic solution of a computing device in this embodiment. It should be noted that the technical solution of this computing device belongs to the same concept as the technical solution of the above method for implementing high-performance particle special effect rendering. For the details not described in detail in the technical solution of this computing device, reference can be made to the description of the technical solution of the above method for implementing high-performance particle special effect rendering.

[0108] In an embodiment of the present application, a computer-readable storage medium is further provided, which stores computer instructions. When the instructions are executed by a processor, the steps of the method for implementing high-performance particle special effect rendering as described above are implemented.

[0109] The above is a schematic solution of a computer-readable storage medium in this embodiment. It should be noted that the technical solution of this storage medium belongs to the same concept as the technical solution of the above method for implementing high-performance particle special effect rendering. For the details not described in detail in the technical solution of this storage medium, reference can be made to the description of the technical solution of the above method for implementing high-performance particle special effect rendering.

[0110] The above describes specific embodiments of the present application. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than in the embodiments and still achieve the desired result. Additionally, the processes depicted in the figures do not necessarily require the particular order or sequential order shown to achieve the desired result. In certain implementations, multitasking and parallel processing are also possible or may be advantageous.

[0111] The computer instructions include computer program code, which may be in the form of source code, object code, executable files or some intermediate forms, etc. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording media, USB flash drives, mobile hard disks, magnetic disks, optical disks, computer memories, read-only memories (ROMs), random access memories (RAMs), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium may be appropriately increased or decreased according to the requirements of legislation and patent practice within the jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, the computer-readable medium does not include electrical carrier signals and telecommunication signals.

[0112] It should be noted that for the foregoing method embodiments, for the sake of simplicity of description, they are all expressed as a series of action combinations. However, those skilled in the art should know that this application is not limited by the described action sequence, because according to this application, certain steps may be performed in other sequences or simultaneously. Secondly, those skilled in the art should also know that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily all essential to this application.

[0113] In the above embodiments, the descriptions of the respective embodiments have their own focuses. For the parts not detailed in a certain embodiment, reference may be made to the relevant descriptions of other embodiments.

[0114] The preferred embodiments of the present application disclosed above are only used to help explain the present application. The alternative embodiments do not describe all the details in detail, nor do they limit the invention to the specific embodiments described. Obviously, many modifications and variations can be made according to the content of this application. The present application selects and specifically describes these embodiments to better explain the principle and practical application of the present application, so that those skilled in the art can understand and utilize the present application well. The present application is only limited by the claims and their full scope and equivalents.< / keyframe>

Claims

1. A method for achieving high-performance particle special effects rendering, characterized in that: The method includes: Complete the initialization of the particle system in the CPU and generate multiple particle instances; Creating a plurality of particle characteristic modules in the CPU, each of the particle characteristic modules being used to describe a particle target attribute related to time; The initialized particle instance and the particle characteristic module instance are passed to the GPU; after the target attribute of the particle instance is calculated in the GPU according to the particle characteristic module instance, the rendering of the particle special effect is completed.

2. The method according to claim 1, wherein: The initialization of the particle system is completed in the CPU, and the generation of multiple particle instances includes: The particles of the particle system are emitted in a simplified manner so that the initial properties of the particles are calculated once in an initialization phase.

3. The method according to claim 2, wherein: Each particle property module is used to describe the time-related particle target properties including: The particle characteristic module includes a plurality of key frame information of the particle in its life cycle.

4. The method according to claim 3, wherein: The key frame information includes: tangent information of the particle at a specific time point and a value of a certain attribute of the particle at a specific time point; or a value of a certain attribute of the particle at a specific time point.

5. The method according to claim 1, wherein: Passing the initialized particle instance and particle feature module instance to the GPU includes: Collect initialized particle instances and upload them to the GPU buffer; The particle property module instance is passed to the corresponding shader of the GPU through the setUniform method in WebGL.

6. The method according to claim 1, wherein: After the target attribute of the particle instance is obtained by calculation according to the particle characteristic module instance in the GPU, the rendering of the particle special effect is completed, including: In the vertex shader of the GPU, target attributes are calculated according to the initialized particle instance and the particle property module instance, and the calculation result is passed to the fragment shader.

7. The method according to claim 6, wherein: Calculating the target attribute in the vertex shader of the GPU according to the initialized particle instance and the particle property module instance includes: In the vertex shader of the GPU, interpolation calculation is performed according to the key frame information in the particle characteristic module instance to obtain the target attribute value of the particle.

8. The method according to claim 1, wherein: The method further includes: In the vertex shader, multiple target attributes of the particles are calculated according to changes in the life cycle of the particles, and the particles are displayed or hidden according to the life cycle.

9. A device for realizing high-performance particle special effects rendering, characterized in that: include: The initialization unit is used to complete the initialization of the particle system in the CPU and generate multiple particle instances; A creation unit, used for creating a plurality of particle characteristic modules in the CPU, each of which is used for describing different particle motion characteristics; The upload unit is used to pass the initialized particle instance and particle feature module instance to the GPU; The rendering unit is used to complete the rendering of particle special effects after calculating the target attribute of the particle instance according to the particle characteristic module instance in the GPU.

10. A computing device comprising a memory, a processor, and computer instructions stored in the memory and executable on the processor, characterized in that: When the processor executes the instructions, the steps of the method according to any one of claims 1 to 8 are implemented.

11. A computer-readable storage medium storing computer instructions, characterized in that: When the instruction is executed by a processor, the steps of the method described in any one of claims 1 to 8 are implemented.

Images