Particle object rendering processing method, related device and medium

Abstract

The invention provides a particle object rendering processing method, a related device and a medium. The method comprises the following steps: if a first resource file for rendering a target particle object does not exist in a current rendering engine, obtaining a plurality of candidate resource files for rendering the target particle object outside the current rendering engine; determining a content difference degree between the candidate resource file and the first resource file; determining the conversion complexity between the second format and the first format of the candidate resource file; determining a second resource file in the plurality of candidate resource files based on the content difference degree and the conversion complexity; and converting the second format of the candidate resource file into the first format to obtain a converted resource file, and importing the converted resource file into the current rendering engine to render the target particle object. According to the method and the device, the particle object rendering performance can be improved when the current rendering engine lacks the resource file required by particle object rendering. The method can be applied to various scenes such as artificial intelligence, cloud technology and game design.

Description

Technical Field

[0001] This disclosure relates to the field of computer technology, and in particular to a particle object rendering processing method, related apparatus and medium. Background Technology

[0002] Particle objects refer to dynamically changing objects rendered using particles, such as fireworks, water bubbles, and gunshots. Due to their cool appearance, particle objects are widely used in various scenarios. Currently, particle object rendering typically involves inputting a resource file for particle object rendering into a particle emitter. The emitter then emits particles based on this resource file, thus rendering the corresponding particle objects. This resource file defines the dispersion period, number of particles, emission delay, particle shape, size, color, and emission position. If the current rendering engine does not have the resource file for particle object rendering, the rendering of the particle object cannot be completed. Although some similar resources that can be used for particle object rendering can be obtained from outside the current rendering engine, these resources are often incompatible with the current rendering engine, resulting in poor rendering performance. Summary of the Invention

[0003] This disclosure provides a particle object rendering method, related apparatus, and medium that can improve particle object rendering performance when the current rendering engine lacks the resource files required for particle object rendering.

[0004] According to one aspect of this disclosure, a particle object rendering processing method is provided for a current rendering engine, the method comprising:

[0005] If there is no first resource file for rendering the target particle object in the current rendering engine, multiple candidate resource files for rendering the target particle object are obtained outside the current rendering engine, wherein the first resource file has a first format and the candidate resource files have a second format.

[0006] Determine the content difference between the candidate resource file and the first resource file;

[0007] Determine the conversion complexity between the second format and the first format of the candidate resource files;

[0008] Based on the content difference and the conversion complexity, a second resource file is determined from the plurality of candidate resource files;

[0009] The candidate resource file is converted from its second format to its first format to obtain a converted resource file. The converted resource file is then imported into the current rendering engine to render the target particle object.

[0010] According to one aspect of this disclosure, a particle object rendering processing apparatus is provided for a current rendering engine, the apparatus comprising:

[0011] The acquisition unit is configured to acquire, outside the current rendering engine, a plurality of candidate resource files for rendering the target particle object if no first resource file for rendering the target particle object exists in the current rendering engine, wherein the first resource file has a first format and the candidate resource files have a second format.

[0012] The first determining unit is used to determine the content difference between the candidate resource file and the first resource file;

[0013] The second determining unit is used to determine the conversion complexity between the second format and the first format of the candidate resource file;

[0014] The third determining unit is used to determine the second resource file from the plurality of candidate resource files based on the content difference degree and the conversion complexity.

[0015] The processing unit is configured to convert the second format of the candidate resource file into the first format to obtain the converted resource file, and import the converted resource file into the current rendering engine to render the target particle object.

[0016] Optionally, the acquisition unit includes:

[0017] The first acquisition module is used to acquire, outside the current rendering engine, multiple resource files to be examined for rendering the target particle object;

[0018] The second acquisition module is used to acquire the frequency of the resource file to be examined being used for rendering the target particle object;

[0019] The third acquisition module is used to acquire the rendering accuracy of the resource file to be examined for rendering the target particle object;

[0020] A determination module is used to determine the plurality of candidate resource files based on the frequency and the rendering accuracy among the plurality of resource files to be examined.

[0021] Optionally, the first acquisition module is used to:

[0022] Obtain multiple rendering engines to be examined, other than the current rendering engine, wherein the number of multiple rendering engines to be examined is equal to the number of multiple resource files to be examined;

[0023] From each of the rendering engines to be examined, obtain one resource file to be examined for rendering the target particle object, so as to form the plurality of resource files to be examined.

[0024] Optionally, the first determining unit is used to:

[0025] Extract the first attribute value of multiple target rendering attributes from the first resource file;

[0026] Extract the second attribute values ​​of the plurality of target rendering attributes from the candidate resource files;

[0027] For each of the target rendering attributes, determine the difference between the first attribute value and the second attribute value;

[0028] The content difference is determined based on the difference in each of the target rendering attributes.

[0029] Optionally, the second determining unit includes:

[0030] The comparison module is used to compare the second format and the first format to obtain multiple differences.

[0031] The input module is used to input the multiple differences into the transformation complexity prediction model to obtain the transformation complexity.

[0032] Optionally, the first resource file includes a plurality of first sub-files, and the candidate resource file includes a plurality of candidate sub-files; the first format includes a first sub-format of each of the first sub-files, and the second format includes a second sub-format of each of the candidate sub-files;

[0033] Optionally, the comparison module is used to:

[0034] Based on the correspondence between the first sub-file and the candidate sub-file, the mapping relationship between the first sub-format and the second sub-format is determined, wherein each first sub-format corresponds to one second sub-format;

[0035] A difference comparison is performed on the first sub-format and the second sub-format that have the aforementioned mapping relationship to obtain multiple sub-difference points;

[0036] The multiple sub-difference points are integrated into the multiple difference points.

[0037] Optionally, the third determining unit is used to:

[0038] Candidate resource files whose content difference is greater than a first threshold are filtered out to obtain multiple filtered resource files;

[0039] The second resource file is determined from among the multiple filtered resource files based on the conversion complexity of each of the filtered resource files.

[0040] Optionally, the third determining unit is used to:

[0041] A first score is determined based on the content differences of the candidate resource files;

[0042] A second score is determined based on the conversion complexity of the candidate resource files;

[0043] Based on the first score and the second score, determine the total score of the candidate resource file;

[0044] The second resource file is determined from the plurality of candidate resource files based on the total score of each candidate resource file.

[0045] Optionally, the converted resource file includes an emitter configuration parameter file, a rendering location file, and a rendering background file;

[0046] The processing unit is used for:

[0047] Import the converted resource file into the current rendering engine;

[0048] The background of the target particle object is rendered using the current rendering engine, based on the rendering background file.

[0049] Based on the rendered location file, determine the emitter position in the background;

[0050] At the emitter location, the target particle object is rendered using the emitter, based on the emitter configuration parameter file.

[0051] Optionally, the candidate resource files include particle system resource files with a second format, skeleton network resource files with a second format, and particle blueprint files with a second format;

[0052] The processing unit includes:

[0053] The import module is used to import the converted resource file into the preset particle generation system of the current rendering engine;

[0054] A creation module is used to create a particle emitter in the preset particle generation system based on the emitter configuration file.

[0055] The generation module is used to generate target particles based on the particle model file and the particle attribute file, through the particle emitter.

[0056] The rendering module is used to render the target particle object based on the target particle.

[0057] Optionally, the generation module is used for:

[0058] For each target particle, obtain the particle configuration parameters of the target particle from the particle model file and the particle attribute file;

[0059] Determine the number of target particles to be generated;

[0060] Based on the particle configuration parameters and the number of particles, particles are generated through the particle emitter to obtain initial particles;

[0061] The initial particle is configured with a failure time to obtain the target particle.

[0062] Optionally, the particle object rendering processing apparatus further includes an update unit, the update unit being used for:

[0063] Get the current cumulative time value of the preset timer;

[0064] If it is determined that the current cumulative time value has reached the preset trigger condition, then the updated configuration information of the target particle is obtained;

[0065] Based on the updated configuration information, the target particle's attributes are updated via the particle emitter.

[0066] Optionally, the particle object rendering processing apparatus further includes a recycling unit, the recycling unit being used for:

[0067] For the target particle, determine the particle failure time;

[0068] If it is determined that the current time has reached the particle's expiration time, the target particle will be recovered.

[0069] Optionally, the rendering module includes:

[0070] The determination submodule is used to determine the target rendering method for rendering the target particle object from multiple candidate rendering methods;

[0071] The rendering submodule is used to render the target particles into target particle objects in a pre-determined target texture map based on the target rendering method.

[0072] Optionally, the rendering submodule is used for:

[0073] If the target rendering method is the first method, then obtain the particle attribute information of the target particle, and render the target particle as a point element based on the particle attribute information;

[0074] Obtain the target texture map required for rendering;

[0075] The target particle object is rendered based on the target texture map and the point elements.

[0076] Optionally, rendering the target particle object based on the target texture map and the point elements includes:

[0077] The target texture map is divided into equal-area segments to obtain multiple animation frame images;

[0078] Determine the initial rendering coordinates of the point element in each of the animation frame images;

[0079] The initial rendering coordinates are updated based on the particle attribute information to obtain the target rendering coordinates;

[0080] Based on the target rendering coordinates, the point elements are rendered into the target particle objects in each of the animation frame images.

[0081] Optionally, the rendering submodule is used for:

[0082] If the target rendering method is the second method, then obtain the particle attribute information of the target particle, and render the target particle as a triangular primitive element based on the particle attribute information;

[0083] Obtain the target texture map required for rendering;

[0084] The target particle object is rendered based on the target texture map and the triangular primitive element.

[0085] Optionally, rendering the target particle object based on the target texture map and the triangular primitive element includes:

[0086] The target texture map is divided into equal-area segments to obtain multiple animation frame images;

[0087] Determine the initial rendering coordinate group of the triangular primitive element in each of the animation frame images;

[0088] The initial rendering coordinate group is updated based on the particle attribute information to obtain the target rendering coordinate group;

[0089] Based on the target rendering coordinate set, the triangular primitive elements are transformed into target particle objects in each of the animation frame images.

[0090] Optionally, the rendering submodule is used for:

[0091] If the target rendering method is the third method, then obtain the mesh configuration file and particle attribute information of the target particles;

[0092] Based on the mesh configuration file and the particle attribute information, the target particle is rendered as a mesh model element;

[0093] Obtain the target texture map required for rendering;

[0094] The target particle object is rendered based on the target texture map and the mesh model elements.

[0095] According to one aspect of this disclosure, an electronic device is provided, including a memory and a processor, the memory storing a computer program, the processor executing the computer program to implement the particle object rendering processing method as described above.

[0096] According to one aspect of this disclosure, a computer-readable storage medium is provided, the storage medium storing a computer program that, when executed by a processor, implements the particle object rendering processing method as described above.

[0097] According to one aspect of this disclosure, a computer program product is provided, the computer program product including a computer program that is read and executed by a processor of a computer device, causing the computer device to perform the particle object rendering processing method as described above.

[0098] In this embodiment, when a first resource file for rendering the target particle object does not exist in the current rendering engine, multiple candidate resource files are obtained externally. These candidate resource files contain similar resources that can be used to render the target particle object. Since the candidate resource files (having a second format) may have format incompatibility issues with the current rendering engine (which can only recognize the first format), and the specific resources in the candidate resource files are not entirely identical to those used for rendering the target particle object, this disclosure considers determining the content difference between the candidate resource file and the first resource file, as well as the conversion complexity between the second and first formats of the candidate resource file. Based on the content difference and conversion complexity, a second resource file for rendering the target particle object is determined from among the multiple candidate resource files. This facilitates the selection of a candidate resource file with smaller content differences and lower format conversion complexity as the second resource file. Finally, the second resource file is converted into a format recognizable by the current rendering engine (from the second format to the first format), and then the converted resource file is imported into the current rendering engine, thus enabling the rendering of the target particle object using the current rendering engine. This approach can improve particle object rendering performance when the current rendering engine lacks the resource files required for particle object rendering.

[0099] Other features and advantages of this disclosure will be set forth in the following description and will be apparent in part from the description or may be learned by practicing the disclosure. The objectives and other advantages of this disclosure may be realized and obtained by means of the structures particularly pointed out in the description, claims and drawings. Attached Figure Description

[0100] The accompanying drawings are provided to further understand the technical solutions of this disclosure and constitute a part of the specification. They are used together with the embodiments of this disclosure to explain the technical solutions of this disclosure and do not constitute a limitation on the technical solutions of this disclosure.

[0101] Figure 1 This is a system architecture diagram of the particle object rendering processing method applied according to the embodiments of this disclosure;

[0102] Figures 2A-2F A schematic diagram is shown illustrating the application of a particle object rendering processing method according to an embodiment of the present disclosure in a virtual character rendering scene;

[0103] Figure 3 This is a flowchart of a particle object rendering process according to an embodiment of the present disclosure;

[0104] Figure 4 This is a flowchart illustrating the acquisition of multiple candidate resource files according to an embodiment of the present disclosure;

[0105] Figure 5 This is a schematic diagram illustrating the implementation process of obtaining multiple resource files to be examined according to an embodiment of this disclosure;

[0106] Figure 6 This is a schematic diagram illustrating the implementation process of obtaining multiple candidate resource files according to an embodiment of the present disclosure;

[0107] Figure 7 This is a flowchart of determining the content difference degree according to an embodiment of the present disclosure;

[0108] Figure 8 This is a schematic diagram illustrating the implementation process of comparing the differences between a candidate resource file and a first resource file according to an embodiment of this disclosure;

[0109] Figure 9 This is a flowchart of determining conversion complexity according to an embodiment of the present disclosure;

[0110] Figure 10 This is a flowchart of determining multiple degrees of difference according to an embodiment of the present disclosure;

[0111] Figure 11 This is a flowchart of determining a second resource file according to an embodiment of the present disclosure;

[0112] Figure 12 This is a flowchart of determining a second resource file according to another embodiment of the present disclosure;

[0113] Figures 13A-13B This is a schematic diagram illustrating the implementation process of determining a second resource file according to an embodiment of the present disclosure;

[0114] Figure 14 This is a flowchart of format conversion of a second resource file according to an embodiment of the present disclosure;

[0115] Figure 15 This is a schematic diagram illustrating the implementation process of format conversion of a second resource file according to an embodiment of the present disclosure;

[0116] Figure 16 This is a flowchart of rendering a target particle object according to an embodiment of the present disclosure;

[0117] Figure 17 This is a flowchart of rendering a target particle object according to another embodiment of the present disclosure;

[0118] Figure 18 This is a flowchart illustrating the generation of target particles via a particle emitter according to an embodiment of the present disclosure;

[0119] Figure 19This is a flowchart of rendering a target particle into a target particle object according to an embodiment of the present disclosure;

[0120] Figure 20 This is a flowchart of updating the properties of a target particle according to an embodiment of the present disclosure;

[0121] Figure 21 This is a flowchart of the recovery of target particles according to an embodiment of the present disclosure;

[0122] Figures 22A-22C This is a schematic diagram illustrating the implementation details of a particle object rendering processing method according to an embodiment of the present disclosure;

[0123] Figure 23 This is a block diagram of a particle object rendering processing apparatus according to an embodiment of the present disclosure;

[0124] Figure 24 This is a terminal structure diagram of a particle object rendering processing method according to an embodiment of the present disclosure;

[0125] Figure 25 This is a server structure diagram of a particle object rendering processing method according to an embodiment of the present disclosure. Detailed Implementation

[0126] To make the objectives, technical solutions, and advantages of this disclosure clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and are not intended to limit the scope of this disclosure.

[0127] The system architecture and scenarios in which this disclosure is applied are described below.

[0128] Figure 1 This is a system architecture diagram of the particle object rendering processing method according to an embodiment of the present disclosure. It includes an object terminal 140, an Internet 130, a gateway 120, a current rendering engine server 110, a candidate rendering engine server 150, and an export resource file database 160, etc.

[0129] The object terminal 140 can take various forms, including desktop computers, laptops, PDAs (personal digital assistants), mobile phones, in-vehicle terminals, home theater terminals, and dedicated terminals. Furthermore, it can be a single device or a collection of multiple devices. The object terminal 140 can communicate with the Internet 130 via wired or wireless means to exchange data. The object terminal 140 includes a rendering processing platform, which submits particle rendering requests for a specific virtual character or scene, and displays the final rendered virtual character or scene with particle object effects.

[0130] The current rendering engine server 110 and the candidate rendering engine server 150 refer to computer systems that can provide certain services to the object terminal 140. Compared to the ordinary object terminal 140, the current rendering engine server 110 and the candidate rendering engine server 150 have higher requirements in terms of stability, security, and performance. The current rendering engine server 110 and the candidate rendering engine server 150 can be a single high-performance computer in a network platform, a cluster of multiple high-performance computers, a portion of a single high-performance computer (e.g., a virtual machine), or a combination of portions of multiple high-performance computers (e.g., virtual machines). The current rendering engine server 110 and the candidate rendering engine server 150 contain various types of services. The implementation of each service of the current rendering engine server 110 and the candidate rendering engine server 150 is often associated with some intermediate databases or storage media. The candidate rendering engine server 150 is used to provide resource files related to the rendered particle objects, and the exported resource file database 160 is used to store the resource files related to the rendered particle objects exported from the candidate rendering engine server 150. The current rendering engine server 110 is used to load the relevant resource files that have been converted from the exported resource file database 160, and to render particle objects using the relevant resource files that have been converted from the exported resource files.

[0131] Gateway 120, also known as an internetwork connector or protocol converter, is a computer system or device that acts as a translator, enabling network interconnection at the transport layer. It bridges the gap between two systems using different communication protocols, data formats, languages, or even completely different architectures. Gateways can also provide filtering and security functions. Messages sent from object terminal 140 to the current rendering engine server 110 are forwarded to the corresponding current rendering engine server 110 via gateway 120. Messages sent from the current rendering engine server 110 to object terminal 140 are also forwarded to the corresponding object terminal 140 via gateway 120.

[0132] The embodiments disclosed herein can be applied in various scenarios, such as Figures 2A-2F The virtual avatar rendering scene shown.

[0133] like Figure 2AAs shown, when an object needs to render a particle object, it triggers the rendering process on the particle rendering platform. At this point, a prompt field appears on the page: "Please enter the particle resource type and particle rendering requirements for the particle object to be rendered," providing editing areas for entering the particle resource type and for entering the particle rendering requirements. Based on this, the object enters "surrounding object of the virtual avatar" in the particle resource type editing area and "Xxxxxxx, configuration xxxx" in the particle rendering requirements editing area, then clicks the "Confirm" button.

[0134] like Figure 2B As shown, after the object clicks the "Confirm" button, a prompt field will be displayed on the page: "According to the query, the data sources that can provide the rendering engine with the surrounding objects of the virtual image include," along with the specific data sources and resource files. Specifically, the resource files that can be used to render the surrounding objects of the virtual image include resource file 1 from the virtual engine (UE), resource file 2 from the game engine (Unity), and resource file 3 from the resource asset library K.

[0135] like Figure 2C As shown, after displaying all the resource files used to render the virtual image's surrounding objects, a prompt field appears on the page: "Since resource file 1 has the smallest difference from the particle rendering requirements and the format conversion of resource file 1 is relatively easy, resource file 1 will be used as the rendering resource file. Resource file 1 is being exported. Please wait patiently..." This indicates that the most suitable resource file 1 has been selected and is being exported.

[0136] like Figure 2D As shown, after the export is complete, a prompt field will be displayed on the page: "Resource file 1 has been exported. The exported rendering resource file contains two resource packages. The storage path of the resource packages is xxxxx". The prompt indicates that the exported resource file used to render the surrounding objects of the virtual image has two kinds of particle resources.

[0137] like Figure 2E As shown, the page will display the prompt field "The virtual image with particle object surround effect rendered using the first resource pack is as follows", and show the rendered virtual image with particle object surround effect, which includes many light spots and several cranes.

[0138] like Figure 2FAs shown, the page will display the prompt field "The virtual image with particle object surround effect rendered using the second resource pack is as follows", and show the rendered virtual image with particle object surround effect, which includes a large blooming flower.

[0139] The embodiments of this disclosure are described in general below.

[0140] According to one embodiment of this disclosure, a particle object rendering processing method is provided.

[0141] This particle object rendering method is generally used in business scenarios such as game development, film and animation production, where various special effects need to be simulated. Figures 2A-2F The virtual avatar rendering scene is shown. This disclosure provides a scheme for rendering particle objects within the current rendering engine based on candidate resource files external to the current rendering engine. This improves particle object rendering performance when the current rendering engine lacks the resource files required for particle object rendering.

[0142] The object rendering processing method of this disclosure embodiment can be executed by the current rendering engine, which can be a real-time rendering engine (Film engine), suitable for rendering needs on various mobile devices and desktop applications.

[0143] like Figure 3 As shown, a particle object rendering method according to an embodiment of this disclosure may include:

[0144] Step 310: If there is no first resource file for rendering the target particle object in the current rendering engine, obtain multiple candidate resource files for rendering the target particle object from outside the current rendering engine.

[0145] Step 320: Determine the content differences between the candidate resource file and the first resource file;

[0146] Step 330: Determine the conversion complexity between the second and first formats of the candidate resource files;

[0147] Step 340: Based on the content difference and conversion complexity, determine the second resource file from multiple candidate resource files;

[0148] Step 350: Convert the second format of the candidate resource file into the first format to obtain the converted resource file. Import the converted resource file into the current rendering engine to render the target particle object.

[0149] Steps 310-350 are described in detail below.

[0150] In step 310, if there is no first resource file for rendering the target particle object in the current rendering engine, multiple candidate resource files for rendering the target particle object are obtained outside the current rendering engine.

[0151] Target particle objects refer to graphical elements rendered on a page that represent a specific effect. For example, target particle objects include, but are not limited to, flames, smoke, raindrops, etc., rendered on a page.

[0152] The first resource file is used to specify the specific resource materials needed to render the target particle object. For example, the first resource file can specify the type, specific attributes, etc. of the target particle object.

[0153] The first resource file has a first format, which indicates the specific file format of the first resource file. The first format is a file format that the current rendering engine can recognize.

[0154] Candidate resource files are used to indicate the actual resource data of the target particle object to be rendered, as well as the configuration information corresponding to the actual resource data. The candidate resource file has a second format, which is used to indicate the specific file format of the candidate resource file. The second format is a file format that is incompatible with the current rendering engine and cannot be recognized by the current rendering engine.

[0155] For example, when the target particle object is a flame, the candidate resource file contains resource data 1 for configuring the color of the target particle object as red; and resource data 2 for configuring the height of the target particle object as 5mm.

[0156] In the specific implementation of this embodiment, when a target particle object needs to be rendered using the current rendering engine, if the current rendering engine does not have a first resource file for rendering the target particle object, then it is necessary to obtain multiple candidate resource files for rendering the target particle object from a preset resource library or other rendering engines outside the current rendering engine.

[0157] To save space, the specific implementation process of obtaining multiple candidate resource files for rendering the target particle object outside the current rendering engine, as described in this embodiment of the disclosure, will be described in detail below. It will not be repeated here.

[0158] In step 320, the content difference between the candidate resource file and the first resource file is determined.

[0159] Content difference is used to indicate the magnitude of the difference in file content between the candidate resource file and the first resource file.

[0160] In the specific implementation of this embodiment, since the candidate resource files and the first resource file are from different sources, and the first resource file often only records the resource requirements for rendering the target particle object without containing specific file data, the resource requirements in the obtained candidate resource files and the first resource file often differ to some extent. Therefore, for each candidate resource file, the file data of the candidate resource file is compared with the resource requirements indicated in the first resource file to determine the degree of content difference between the candidate resource file and the first resource file.

[0161] For example, the first resource file records the configuration data for the target particle object "Flame" to be rendered, and this configuration data is set to red. The candidate resource file, however, contains the actual configuration data for the target particle object "Flame" in yellow. Therefore, there is a content difference between the candidate resource file and the first resource file.

[0162] To save space, the specific implementation process of determining the content difference between the candidate resource file and the first resource file in this embodiment will be described in detail below. It will not be repeated here.

[0163] In step 330, the conversion complexity between the second format and the first format of the candidate resource file is determined.

[0164] Conversion complexity is used to indicate the complexity of converting a candidate resource file from a second format to a first format.

[0165] To save space, the specific implementation process for determining the conversion complexity between the second and first formats of candidate resource files in this embodiment will be described in detail below. It will not be repeated here.

[0166] In step 340, a second resource file is determined from multiple candidate resource files based on content differences and conversion complexity.

[0167] In the specific implementation of this embodiment, there are certain differences in content differences and conversion complexity between each candidate resource file and the first resource file. Based on this, a candidate resource file with smaller content differences and lower conversion complexity can be selected as the second resource file from among multiple candidate resource files to reduce conversion difficulty and improve the rendering quality of the target particle object.

[0168] To save space, the specific implementation process of determining the second resource file from multiple candidate resource files based on content differences and conversion complexity in this embodiment will be described in detail below. It will not be repeated here.

[0169] In step 350, the second format of the candidate resource file is converted into the first format to obtain the converted resource file, and the converted resource file is imported into the current rendering engine to render the target particle object.

[0170] The converted resource file and the candidate resource file have basically the same file content and resource data. However, the file format of the converted resource file is a format category that the current rendering engine can recognize.

[0171] In this specific implementation, firstly, the second format of the candidate resource file is converted into the first format, so that the file data in the candidate resource file becomes a format category that the current rendering engine can recognize, resulting in a converted resource file. Next, the converted resource file is imported into the current rendering engine, and the current rendering engine renders the target particle object based on the resource data in the converted resource file.

[0172] To save space, the specific process of converting the second format of the candidate resource file into the first format, and the specific implementation process of importing the converted resource file into the current rendering engine to render the target particle object, according to the embodiments of this disclosure, will be described in detail below. They will not be repeated here.

[0173] Through steps 310-350 above, in this embodiment of the disclosure, when there is no first resource file for rendering the target particle object in the current rendering engine, multiple candidate resource files are obtained externally to the current rendering engine. These candidate resource files contain similar resources that can be used to render the target particle object. Since the candidate resource files (having a second format) may have format incompatibility issues with the current rendering engine (which can recognize the first format), and the specific resources in the candidate resource files are not entirely identical to those used for rendering the target particle object, this disclosure considers determining the content difference between the candidate resource file and the first resource file, as well as the conversion complexity between the second and first formats of the candidate resource file. Based on the content difference and conversion complexity, a second resource file for rendering the target particle object is determined from among the multiple candidate resource files. This facilitates the selection of a candidate resource file with a smaller content difference and lower format conversion complexity as the second resource file. Finally, the second resource file is converted into a format recognizable by the current rendering engine (from the second format to the first format), and then the converted resource file is imported into the current rendering engine, thus enabling the rendering of the target particle object using the current rendering engine. This approach can improve particle object rendering performance when the current rendering engine lacks the resource files required for particle object rendering.

[0174] The above is a general description of steps 310-350. The following will provide a detailed description of the specific implementation of steps 310-350.

[0175] Step 310 will be described in detail below.

[0176] In step 310, if there is no first resource file for rendering the target particle object in the current rendering engine, multiple candidate resource files for rendering the target particle object are obtained outside the current rendering engine, wherein the first resource file has a first format and the candidate resource files have a second format.

[0177] Please refer to Figure 4 In one embodiment, step 310 specifically includes, but is not limited to, the following steps 410-440:

[0178] Step 410: Outside the current rendering engine, obtain multiple resource files to be examined for rendering the target particle object;

[0179] Step 420: Obtain the frequency with which the resource file to be examined is used for rendering the target particle object;

[0180] Step 430: Obtain the rendering accuracy of the resource file to be examined for rendering the target particle object;

[0181] Step 440: Based on frequency and rendering accuracy, identify multiple candidate resource files from among the multiple resource files to be examined.

[0182] Steps 410-440 are described in detail below.

[0183] In step 410, outside the current rendering engine, multiple resource files to be examined for rendering the target particle object are obtained.

[0184] Resource files to be examined refer to resource files that can be used for rendering the target particle object, but require further screening and evaluation to determine whether they can be considered as candidate resource files.

[0185] In the specific implementation of this embodiment, since other rendering engines besides the current rendering engine and the preset resource library often contain a relatively rich collection of resource files for rendering, with authorization, various resource files from other rendering engines besides the current rendering engine and the preset resource library can be exported and used as resource files to be examined. This method can obtain a sufficiently large number of resource files with comprehensive content to be examined.

[0186] Because exporting all the resource files from rendering engines other than the current one, as well as from the preset resource library, often takes a considerable amount of time, the following method can be used to obtain multiple resource files for rendering the target particle object:

[0187] Obtain multiple rendering engines to be examined, in addition to the current rendering engine;

[0188] From each rendering engine to be examined, obtain one resource file for rendering the target particle object to be examined, so as to form multiple resource files to be examined.

[0189] The rendering engine to be examined is any rendering engine other than the current one. For example, if the current rendering engine is Frame, the rendering engine to be examined could be Unreal Engine (UE engine), a game engine (Unity engine), etc.

[0190] The number of rendering engines to be examined is equal to the number of resource files to be examined.

[0191] Specifically, firstly, with authorization, based on the current rendering engine type, other rendering engines besides that type are obtained, resulting in multiple rendering engines to be examined. Next, for each rendering engine to be examined, the resource files used for rendering the target particle objects are obtained, and the number of times each resource file is used within the same time period is determined. The resource file with the highest usage frequency is selected as the resource file to be examined. Finally, the resource files from each rendering engine to be examined are combined into multiple resource files to be examined, so that the number of obtained resource files to be examined equals the number of rendering engines to be examined.

[0192] like Figure 5The diagram illustrates the process of obtaining multiple resource files for evaluation. Specifically, the rendering engines under evaluation include Rendering Engine 1, Rendering Engine 2, and Rendering Engine 3. Rendering Engine 1 contains resource file 1 (used 7 times), resource file 2 (used 5 times), and resource file 3 (used 8 times). Rendering Engine 2 contains resource file 4 (used 10 times) and resource file 5 (used 3 times). Rendering Engine 3 contains resource file 6 (used 2 times), resource file 7 (used 12 times), and resource file 8 (used 17 times). Based on this, the resource file with the highest usage frequency from each of the three rendering engines is selected to form multiple resource files for evaluation. Therefore, three resource files are ultimately determined: Resource File 1 (i.e., Resource File 3), Resource File 2 (i.e., Resource File 4), and Resource File 3 (i.e., Resource File 8). The usage frequency of each resource file refers to the total number of times each resource file is used for rendering within a fixed time period.

[0193] The advantage of this embodiment is that when acquiring multiple resource files to be examined, it is not necessary to export all resource files from each of the rendering engines to be examined. For each rendering engine to be examined, the resource file used most frequently for rendering the target particle object in that rendering engine is selected as the resource file to be examined, which can effectively save the time of acquiring resource files. At the same time, selecting one resource file for each rendering engine to be examined can achieve uniform selection of resource files, thereby improving the efficiency and objectivity of acquiring resource files to be examined.

[0194] In step 420, the frequency of the resource file to be examined being used for rendering the target particle object is obtained.

[0195] Frequency is used to indicate the frequency at which the resource file under examination is used to render the target particle object in a practical application.

[0196] In the specific implementation of this embodiment, for each resource file to be examined, the total number of times the resource file to be examined is used to render the target particle object within a predetermined time period is obtained, and the total number of times is used as the frequency of the resource file to be examined for rendering the target particle object.

[0197] It should be noted that the frequency of each resource file under examination refers to the total number of times each resource file is used to render the target particle object within the same time period. For example, the total number of times each resource file is used to render the target particle object on the same day is taken as the frequency of each resource file under examination.

[0198] In step 430, the rendering accuracy of the resource file to be examined for rendering the target particle object is obtained.

[0199] Render accuracy indicates the degree of difference between the target particle object generated from the rendered resource file under examination and the expected target particle object. A higher rendering accuracy indicates a smaller difference between the generated target particle object and the expected target particle object.

[0200] In the specific implementation of this embodiment, firstly, the actual rendering image of the target particle object based on the resource file to be examined is obtained. Next, the actual rendering image is compared with a preset expected rendering image to obtain image similarity, which is then used as the rendering accuracy of the resource file to be examined.

[0201] It should be noted that when calculating the similarity between the actual effect image and the preset expected effect image, the actual effect image and the preset expected effect image can first be mapped to a latent vector space. In the latent vector space, the cosine similarity algorithm is used to calculate the similarity between the vector form of the actual effect image and the vector form of the expected effect image, thereby obtaining the image similarity.

[0202] In step 440, multiple candidate resource files are determined from multiple resource files to be examined based on frequency and rendering accuracy.

[0203] In a specific implementation of this embodiment, step 440 may include, but is not limited to, the following steps:

[0204] Frequency scores are obtained based on the frequency of the resource files to be examined;

[0205] An accuracy score is obtained based on the rendering accuracy of the resource file under examination.

[0206] Based on frequency score and accuracy score, determine the priority score of the resource file to be examined;

[0207] Based on priority scores, multiple candidate resource files are identified from among multiple resource files to be examined.

[0208] Frequency score is used to indicate the contribution of the frequency of the resource file being examined to the resource file screening process.

[0209] The accuracy score is used to indicate the contribution of the rendering accuracy of the resource file under examination to the resource file selection.

[0210] The priority score is used to indicate the likelihood that the resource file under consideration will be selected in the resource file filtering process.

[0211] Specifically, firstly, the frequency of the files to be examined is input into a preset first function, and the output of the first function is used as the frequency score. The first function is an increasing function with frequency as the independent variable and the frequency score as the dependent variable. Next, the rendering accuracy of the files to be examined is input into a preset second function, and the output of the second function is used as the accuracy score. The second function is also an increasing function with rendering accuracy as the independent variable and the accuracy score as the dependent variable. Further, a first weight and a second weight are obtained. The first weight indicates the importance of the frequency score in selecting the files to be examined, and the second weight indicates the importance of the accuracy score. The sum of the first weight and the second weight is 1. Then, the product of the first weight and the frequency score, and the product of the second weight and the accuracy score are added together to obtain the priority score of the files to be examined. Finally, a predetermined number of files with higher priority scores are selected as candidate files. The predetermined number limits the number of candidate files, and its specific value is set according to actual business needs and is not restricted.

[0212] like Figure 6The diagram illustrates the specific implementation process for identifying multiple candidate resource files from a pool of resource files to be examined. Specifically, there are six resource files to be examined: resource file 1 (frequency 15, rendering precision 0.9); resource file 3 (frequency 10, rendering precision 0.88); resource file 6 (frequency 23, rendering precision 0.92); resource file 7 (frequency 7, rendering precision 0.75); resource file 13 (frequency 2, rendering precision 0.68); and resource file 22 (frequency 8, rendering precision 0.84). Based on this, when calculating the frequency score, the frequencies of all resource files to be examined are first summed to obtain the total frequency. Then, the proportion of each resource file's frequency in the total frequency is multiplied by 100 to obtain the frequency score for each resource file. The precision score is calculated using the same method as the frequency score. Based on this, when both the first and second weights are 0.5, resource file 1 has a frequency score of 24, a precision score of 18, and a priority score of 21; resource file 3 has a frequency score of 15, a precision score of 17.7, and a priority score of 16.35; resource file 6 has a frequency score of 36, a precision score of 18.5, and a priority score of 27.25; resource file 7 has a frequency score of 10, a precision score of 15.1, and a priority score of 12.55; resource file 13 has a frequency score of 3, a precision score of 13.7, and a priority score of 8.35; and resource file 22 has a frequency score of 12, a precision score of 16.9, and a priority score of 14.45. Therefore, the top three priority scores among the resource files to be examined are selected as candidate resource files. Thus, the candidate resource files are resource file 1, resource file 3, and resource file 6.

[0213] The advantage of this embodiment is that when acquiring multiple candidate resource files, it takes into account other rendering engines outside the current rendering engine and selectable resource files in the preset resource material library, i.e., the resource files to be examined. At the same time, for each resource file to be examined, the resource file is screened by combining two aspects: the frequency and accuracy of the resource file used for rendering the target particle object. It can prioritize the selection of resource files to be examined with better frequency and rendering accuracy as candidate resource files, thereby improving the resource quality of candidate resource files while ensuring the number of candidate resource files.

[0214] Step 320 will be described in detail below.

[0215] In step 320, the content difference between the candidate resource file and the first resource file is determined.

[0216] Please refer to Figure 7 In one embodiment, step 320 specifically includes, but is not limited to, the following steps 710-740:

[0217] Step 710: Extract the first attribute values ​​of multiple target rendering attributes from the first resource file;

[0218] Step 720: Extract the second attribute values ​​of multiple target rendering attributes from the candidate resource files;

[0219] Step 730: For each target rendering attribute, determine the difference between the first attribute value and the second attribute value;

[0220] Step 740: Determine the content difference based on the difference in each target rendering attribute.

[0221] Steps 710-740 are described in detail below.

[0222] In step 710, the first attribute values ​​of multiple target rendering attributes are extracted from the first resource file.

[0223] Target rendering properties are used to indicate the types of attributes possessed by the rendered target particle object. For example, target rendering properties include, but are not limited to, the shape, velocity, initial position, size, etc. of the target particle object.

[0224] The first attribute value indicates the expected parameters corresponding to the target rendering attribute of the target particle object. For example, when the target rendering attribute is shape, the first attribute value can be a sphere or a cone.

[0225] In the specific implementation of this embodiment, firstly, with authorization, the configuration information representing the attribute type of the target particle object is searched in the first resource file, and each configuration item in the configuration information is used as a target rendering attribute. Next, the configuration parameters corresponding to each configuration item are extracted. For configuration items with numerical configuration parameters, the configuration parameters are directly used as the first attribute value of the target rendering attribute (configuration item); for configuration items with non-numerical configuration parameters, a lookup table method is used to convert the non-numerical configuration parameters into numerical form, and the numerical configuration parameters are used as the first attribute value of the target rendering attribute (configuration item).

[0226] It should be noted that the parameter types of different target rendering attributes may vary. For example, some target rendering attributes have numerical parameters, while others do not. For non-numerical target rendering attributes, a pre-defined attribute value lookup table can be used. This table includes candidate values ​​for each candidate attribute parameter. The specific attribute parameter of the target rendering attribute is compared with the candidate attribute parameters in the lookup table, and the candidate value corresponding to the candidate attribute parameter that matches the specific attribute parameter is taken as the attribute value of the target rendering attribute. For example, when the target rendering attribute is a shape, the candidate values ​​corresponding to a sphere and a cone shape are different in the attribute value lookup table.

[0227] In step 720, the second attribute values ​​of multiple target rendering attributes are extracted from the candidate resource files.

[0228] The second attribute value indicates the actual parameters corresponding to the target rendering attributes of the target particle object rendered based on the candidate resource file.

[0229] In the specific implementation of this embodiment, the process of step 720 is similar to that of step 710 described above. To save space, it will not be described again.

[0230] In step 730, for each target rendering attribute, the difference between the first attribute value and the second attribute value is determined.

[0231] In this specific implementation, for each target rendering attribute of the candidate resource file, the second attribute value is subtracted from the first attribute value to obtain the difference between the first and second attribute values. This difference indicates the degree of difference between the candidate resource file and the first resource file in this target rendering attribute.

[0232] In step 740, the content difference is determined based on the difference in each target rendering attribute.

[0233] In the specific implementation of this embodiment, the units of measurement for the differences between different target rendering attributes will differ (for example, when the target rendering attribute is speed, the unit is m / s; when the target rendering attribute is transparency, the unit is percentage). Therefore, when determining the content difference degree, firstly, for each target rendering attribute difference, the absolute value of the difference is imported into a preset function. The output of the preset function is used as the difference degree corresponding to that target rendering attribute. The preset function is an increasing function with the absolute value of the difference between the target rendering attributes as the independent variable and the difference degree as the dependent variable; the larger the absolute value of the difference, the greater the difference degree. Next, the difference degrees corresponding to each target rendering attribute are averaged to obtain the content difference degree between the candidate resource file and the first resource file.

[0234] like Figure 8 The diagram illustrates the specific calculation of differences for a candidate resource file. Specifically, the target rendering attributes of the first resource file used for rendering the target particle object include target particle type, shape, size, color, transparency, and speed. The first attribute value corresponding to the target particle type is raindrop; the first attribute value corresponding to the shape is sphere; the first attribute value corresponding to the size is a radius of 5mm; the first attribute value corresponding to the color is white; the first attribute value corresponding to the transparency is 60%; and the first attribute value corresponding to the speed is 5m / s. In the candidate resource file used for rendering the target particle object, the second attribute value corresponding to the target particle type is raindrop; the second attribute value corresponding to the shape is sphere; the second attribute value corresponding to the size is a radius of 8mm; the second attribute value corresponding to the color is white; the second attribute value corresponding to the transparency is 80%; and the second attribute value corresponding to the speed is 10m / s. Based on this, the differences in each target rendering attribute between the first resource file and the candidate resource file are compared. Among them, the first resource file and the candidate resource file have no difference in target particle type, shape and color, the difference in size is 3mm, the difference in transparency is 20%, and the difference in speed is 5m / s.

[0235] The advantage of this embodiment is that by comparing the first and second attribute values ​​for each target rendering attribute, the comprehensiveness of the difference calculation is improved. Simultaneously, when determining the content difference degree based on multiple differences, the different units of measurement for the differences of different target rendering attributes are considered. A corresponding preset function is introduced for each target rendering attribute to convert the differences, ensuring that the differences between the candidate resource file and the first resource file on different target rendering attributes (the degree of difference corresponding to the difference) can be represented using the same unit. Furthermore, integrating the degree of difference corresponding to multiple target rendering attributes into a content difference degree improves the accuracy of content difference degree determination. In addition, this disclosure also considers that not all specific parameters of target rendering attributes are numerical. For non-numerical target rendering attributes, an attribute lookup table is introduced to convert attribute parameters, enabling all attribute parameters of target rendering attributes to be represented numerically, which helps reduce the computational complexity of content difference degree.

[0236] Step 330 will be described in detail below.

[0237] In step 330, the conversion complexity between the second format and the first format of the candidate resource file is determined.

[0238] Please refer to Figure 9 In one embodiment, step 330 specifically includes, but is not limited to, the following steps 910-920:

[0239] Step 910: Compare the second format and the first format to obtain multiple differences;

[0240] Step 920: Input multiple differences into the transformation complexity prediction model to obtain the transformation complexity.

[0241] Steps 910-920 are described in detail below.

[0242] In step 910, the second format and the first format are compared to obtain multiple differences.

[0243] Differences are used to indicate the differences between the second and first formats across different dimensions. For example, differences include variations between the second and first formats in terms of compatibility, compression algorithms, metadata, etc.

[0244] In the specific implementation of this embodiment, firstly, the comparison dimensions of the second format and the first format are determined. Next, for each comparison dimension, the differences between the second format and the first format are compared to obtain the difference points for that comparison dimension. Finally, the difference points of each comparison dimension are integrated to obtain multiple difference points.

[0245] For example, when the comparison dimension is the compression algorithm, first determine the compression algorithm used by the second format and the compression algorithm used by the first format, and then compare the compression algorithm used by the second format and the compression algorithm used by the first format to obtain the differences between the second format and the first format in terms of compression algorithm.

[0246] In step 920, multiple differences are input into the transformation complexity prediction model to obtain the transformation complexity.

[0247] A transformation complexity prediction model is a neural network model that takes the difference point as input and the transformation complexity as output, and has the function of predicting the transformation complexity between the second format and the first format.

[0248] In this embodiment of the disclosure, the transformation complexity prediction model may include an embedding layer, a concatenation layer, and a prediction layer. The embedding layer maps the difference points to a latent vector space, the concatenation layer concatenates the mapped difference points into features, and the prediction layer predicts the transformation complexity based on the concatenated features.

[0249] In this specific implementation, firstly, multiple difference points are input into the transformation complexity prediction model. Next, for each difference point, an embedding layer is used to perform feature mapping, mapping the difference points to a latent vector space to obtain the difference features corresponding to each difference point. Further, a concatenation layer is used to concatenate multiple difference features to obtain a longer feature vector, which is used as the target format difference feature. Finally, the target format difference feature is input into the prediction layer for complexity prediction, obtaining the transformation complexity between the second and first formats.

[0250] The advantage of this embodiment is that, when determining the transformation complexity, it takes into account the comparison between the second format and the first format, obtains multiple difference points, and introduces a transformation complexity prediction model to perform feature mapping and prediction on the difference points, which helps to improve the automation level and prediction accuracy in determining the transformation complexity.

[0251] Since the first resource file and candidate resource files often contain various types of configuration files, conversion often requires converting configuration files of the same type in both files. Simply identifying the differences between the first and candidate resource files at a coarse-grained level leads to inaccurate conversion complexity. Therefore, this disclosure provides a scheme for determining conversion complexity based on a comparison of differences between various types of configuration files. This allows for fine-grained comparison of the first and second formats, improving the comprehensiveness and accuracy of identifying differences.

[0252] In this embodiment of the disclosure, the first resource file includes a plurality of first sub-files, and the candidate resource file includes a plurality of candidate sub-files. The first format includes the first sub-format of each first sub-file, and the second format includes the second sub-format of each candidate sub-file.

[0253] The first subfile refers to a configuration file of a certain type within the first resource file. For example, the first subfile is a configuration file related to the particle emitter.

[0254] The first sub-format refers to the file format of a configuration file of a certain type in the first resource file. For example, when the first sub-file is a configuration file related to a particle emitter, the first sub-format is in JSON code format.

[0255] Candidate subfiles refer to a configuration file of a certain type within the candidate resource files. For example, a candidate subfile is a configuration file related to the properties of the target particle object.

[0256] The second sub-format refers to the file format of a certain type of configuration file in the candidate resource files. For example, when the candidate sub-file is a configuration file related to the attributes of the target particle object (used to describe the geometric mesh data and skeletal animation data of the particle model), the candidate sub-format is in binary format.

[0257] Please refer to Figure 10 In one embodiment, step 910 specifically includes, but is not limited to, the following steps 1010-1030:

[0258] Step 1010: Based on the correspondence between the first sub-file and the candidate sub-file, determine the mapping relationship between the first sub-format and the second sub-format;

[0259] Step 1020: Compare the differences between the first and second sub-formats that have a mapping relationship to obtain multiple sub-difference points;

[0260] Step 1030: Integrate multiple sub-difference points into multiple difference points.

[0261] Steps 1010-1030 are described in detail below.

[0262] In step 1010, the mapping relationship is used to indicate which first subfile of the first resource file corresponds to each candidate subfile of the candidate resource file. For candidate subfiles and first subfiles with a mapping relationship, the file information represented by the candidate subfiles and the first subfiles is basically the same, but their file formats are different.

[0263] Each first sub-format corresponds to a second sub-format. For example, when the candidate sub-file of the candidate resource file is the particle system resource file, the first sub-file of the first resource file mapped to it is the particle system configuration file, where the particle system configuration file is in JOSN format (first sub-format) and the particle system resource file is in uasset format (second sub-format).

[0264] In the specific implementation of this embodiment, since the conversion between each first sub-file in the first resource file and each candidate sub-file in the candidate resource file is fixed, that is, the correspondence between the first sub-file and the candidate sub-file is known. Based on this, with authorization, for the first sub-file and candidate sub-file that have a correspondence, the second sub-format of the candidate sub-file is bound and paired with the first sub-format of the first sub-file to obtain the mapping relationship between the first sub-format and the second sub-format.

[0265] In step 1020, sub-difference points are used to indicate specific differences between the second sub-format and the first sub-format with which it has a mapping relationship.

[0266] In the specific implementation of this embodiment, the specific process of step 1020 is basically the same as the specific implementation process of step 910 described above. To save space, it will not be repeated.

[0267] In step 1030, multiple sub-difference points are aggregated into a set, and all sub-difference points in this set are used as the final determined multiple difference points.

[0268] For example, candidate sub-files in the candidate resource file include particle system resource files in UASSET format and particle attribute configuration files in binary format that describe the geometric mesh data and skeletal animation data of the particle model. In the first resource file, the first sub-file includes a particle model configuration file (required to be in GL TF format) and an emitter configuration file (required to be in JSON format). Therefore, since the particle system resource file needs to be converted into an emitter configuration file, the differences between the UASSET and JSON formats are compared to obtain a set of sub-difference points; similarly, since the particle attribute configuration file needs to be converted into a particle model configuration file, the differences between the binary and GL TF formats are compared to obtain another set of sub-difference points. Finally, the two sets of sub-difference points are merged into multiple difference points that are ultimately input into the transformation complexity prediction model.

[0269] The advantage of this embodiment is that it takes into account that there are multiple types of sub-files in both the first resource file and the candidate resource file. Based on the mapping relationship of each type of sub-file, the second sub-format of the candidate sub-file and the first sub-format of the corresponding first sub-file are compared to obtain the sub-difference points of multiple sub-file pairs (candidate sub-files and first sub-files with mapping relationship). Thus, multiple sub-difference points are integrated into a single difference point to determine the conversion complexity. This enables fine-grained comparison of the differences between the first format and the second format, which helps to improve the comprehensiveness and accuracy of obtaining the difference points, thereby improving the accuracy of determining the conversion complexity.

[0270] Step 340 will be described in detail below.

[0271] In step 340, a second resource file is determined from multiple candidate resource files based on content differences and conversion complexity.

[0272] Please refer to Figure 11 In one embodiment, step 340 specifically includes, but is not limited to, the following steps 1110-1120:

[0273] Step 1110: Filter out candidate resource files whose content difference is greater than the first threshold to obtain multiple filtered resource files;

[0274] Step 1120: Based on the conversion complexity of each filtered resource file, determine the second resource file from among the multiple filtered resource files.

[0275] Steps 1110-1120 are described in detail below.

[0276] In step 1110, candidate resource files with content differences greater than the first threshold are filtered out to obtain multiple filtered resource files.

[0277] The first threshold is used to measure whether the content differences of candidate resource files meet the screening requirements.

[0278] The filtered resource files are used to indicate candidate resource files whose content differences from the first resource file meet the filtering requirements.

[0279] In this specific implementation, firstly, for each candidate resource file, the content difference of the candidate resource file is compared with a first threshold. Next, if the content difference of the candidate resource file is less than or equal to the first threshold, the candidate resource file is retained; if the content difference of the candidate resource file is greater than the first threshold, the candidate resource file is filtered out. Finally, each retained candidate resource file is used as a filtered resource file.

[0280] In step 1120, a second resource file is determined from among the multiple filtered resource files based on the conversion complexity of each filtered resource file.

[0281] In the specific implementation of this embodiment, firstly, the filtered resource files are sorted in ascending order of conversion complexity. Then, since the filtered resource files ranked earlier in the sorting have lower conversion complexity, the first filtered resource file is designated as the second resource file.

[0282] like Figure 13AThe diagram illustrates a specific implementation process for determining the second resource file from multiple candidate resource files. Specifically, there are six candidate resource files: resource file 1 (content difference score of 0.11, conversion complexity of 0.4); resource file 2 (content difference score of 0.05, conversion complexity of 0.33); resource file 3 (content difference score of 0.23, conversion complexity of 0.15); resource file 4 (content difference score of 0.17, conversion complexity of 0.67); resource file 5 (content difference score of 0.2, conversion complexity of 0.28); and resource file 6 (content difference score of 0.31, conversion complexity of 0.37). Based on this, when the first threshold is 0.2, candidate resource files with a content difference score greater than 0.2 are filtered out, leaving resource file 1, resource file 2, resource file 4, and resource file 5. Furthermore, since the four filtered resource files are sorted in ascending order of conversion complexity as [resource file 5, resource file 2, resource file 1, resource file 4], resource file 5, which has the lowest conversion complexity, is selected as the second resource file.

[0283] The advantage of this embodiment is that, when determining the second resource file from multiple candidate resource files, the content difference between the candidate resource file and the first resource file is given priority. Candidate resource files with excessively large content differences from the first resource file (content difference greater than a first threshold) are first filtered out. Then, to reduce resource consumption during conversion, among the remaining candidate resource files (multiple filtered resource files), the filtered resource file with lower conversion complexity between the second and first formats is selected as the second resource file. This approach effectively reduces the format conversion difficulty and resource consumption of the second resource file from the second format to the first format while improving rendering accuracy.

[0284] Please refer to Figure 12 In another embodiment, step 340 specifically includes, but is not limited to, the following steps 1210-1240:

[0285] Step 1210: Determine the first score based on the content differences of the candidate resource files;

[0286] Step 1220: Determine the second score based on the conversion complexity of the candidate resource files;

[0287] Step 1230: Determine the total score of the candidate resource files based on the first score and the second score;

[0288] Step 1240: Based on the total score of each candidate resource file, determine the second resource file from among the multiple candidate resource files.

[0289] Steps 1210-1240 are described in detail below.

[0290] In step 1210, the first score is used to indicate the contribution of the content difference of the candidate resource files to the screening of candidate resource files. The larger the first score, the smaller the content difference between the candidate resource file and the first resource file, and the more suitable the candidate resource file is as the second resource file when considering content differences.

[0291] In the specific implementation of this embodiment, the specific process of step 1210 is similar to the specific process of determining the frequency score based on frequency in step 440 above. To save space, it will not be described again.

[0292] In step 1220, the second score is used to indicate the contribution of the conversion complexity of the candidate resource file to the screening of candidate resource files. A larger second score indicates that the candidate resource file has a smaller difference in format conversion compared to the first resource file, and considering the format conversion complexity, the candidate resource file is more suitable as the second resource file.

[0293] In this specific implementation, the process of step 1220 is similar to the process of determining the frequency score based on frequency in step 440 above. To save space, it will not be described again.

[0294] In step 1230, the total score indicates the likelihood that a candidate resource file will be selected as the second resource file after comprehensively considering content differences and the complexity of format conversion. A higher total score indicates a greater likelihood that the candidate resource file will be selected as the second resource file.

[0295] In the specific implementation of this embodiment, the specific process of step 1230 is similar to the specific process of determining the priority score based on the frequency score and accuracy score in step 440 above. To save space, it will not be described again.

[0296] The specific process of step 1240 is similar to that of step 440 above, which involves determining multiple candidate resource files based on priority scores among multiple resource files to be examined. To save space, it will not be described in detail here.

[0297] like Figure 13BThe diagram illustrates a specific implementation process for determining the second resource file from multiple candidate resource files. Specifically, there are six candidate resource files: resource file 1 (content difference score 0.11, conversion complexity 0.4); resource file 2 (content difference score 0.05, conversion complexity 0.33); resource file 3 (content difference score 0.23, conversion complexity 0.15); resource file 4 (content difference score 0.17, conversion complexity 0.67); resource file 5 (content difference score 0.2, conversion complexity 0.28); and resource file 6 (content difference score 0.31, conversion complexity 0.37). Based on this, when calculating the first score, for each candidate resource file, the product of 1 minus the content difference score and 100 is used as the first score. The second score is calculated using the same method as the first score. Based on this, when both the first and second weights are 0.5, resource file 1 has a first score of 24, a second score of 18, and a total score of 21; resource file 2 has a first score of 95, a second score of 67, and a total score of 81; resource file 3 has a first score of 77, a second score of 85, and a total score of 81; resource file 4 has a first score of 83, a second score of 33, and a total score of 58; resource file 5 has a first score of 80, a second score of 72, and a total score of 76; and resource file 6 has a first score of 69, a second score of 63, and a total score of 66. Therefore, the resource file with the highest total score among the candidate resource files is selected as the second resource file. Thus, either resource file 2 or resource file 3 can be randomly selected as the second resource file, or resource file 2 can be selected as the second resource file if the content difference is smaller, and resource file 3 can be selected as the second resource file if the conversion complexity is smaller.

[0298] The advantage of this embodiment is that, when determining the second resource file from multiple candidate resource files, it simultaneously considers the content differences and conversion complexity between the candidate resource files and the first resource file. By using a score calculation method, the content differences and conversion complexity of each candidate resource file are quantified as scores. Under the same dimension, the first score corresponding to content differences and the second score corresponding to conversion complexity are weighted and calculated to obtain the total score of each candidate resource file. This integrates the two influencing factors (content differences and conversion complexity), thus prioritizing the selection of the candidate resource file with the higher total score as the second resource file, thereby improving the accuracy of the second resource file determination. Furthermore, since the consideration of content differences and conversion complexity is not prioritized, this method is beneficial for selecting the candidate resource file with the best overall performance in both content differences and conversion complexity as the second resource file.

[0299] Step 350 will be described in detail below.

[0300] In step 350, the second format of the candidate resource file is converted into the first format to obtain the converted resource file, and the converted resource file is imported into the current rendering engine to render the target particle object.

[0301] Since candidate resource files often contain various types of sub-files, and the conversion methods and rules for different types of sub-files often differ, converting all sub-files in the same way may result in conversion errors or incomplete resource conversion. Therefore, this disclosure provides a scheme for format conversion of candidate resource files based on predetermined export rules, which can improve the reliability and accuracy of format conversion for candidate resource files.

[0302] In this embodiment of the disclosure, the candidate resource files include a particle system resource file with a second format, a skeleton network resource file with a second format, and a particle blueprint file with a second format.

[0303] The particle system resource file describes all the settings information of the particle emitter, such as parameters like particle generation, lifespan, color, size, and velocity.

[0304] The skeleton network resource file is used to describe the geometric mesh data and skeletal animation data associated with the target particle object.

[0305] Particle blueprint files are used to describe information such as the position, rotation, and scaling of target particle objects within the associated geometric mesh and skeletal animation.

[0306] Please refer to Figure 14 In one embodiment, the specific process of converting the second format of the candidate resource file into the first format may include, but is not limited to, the following steps 1410-1440:

[0307] Step 1410: Based on the predetermined export rules, convert the second format of the particle system resource file into the first format to obtain the emitter configuration file;

[0308] Step 1420: Convert the second format of the skeleton network resource file into the first format to obtain the particle model file;

[0309] Step 1430: Convert the second format of the particle blueprint file to the first format to obtain the particle attribute file;

[0310] Step 1440: Integrate the emitter configuration file, particle model file, and particle attribute file into a converted resource file.

[0311] Steps 1410-1440 are described in detail below.

[0312] In step 1410, the emitter configuration file is used to describe all the settings information of the particle emitter.

[0313] In the specific implementation of this embodiment, based on the predetermined export rules, the unreal python program is used to load and parse the particle system resource file, and export the particle system resource file in the second format (uasset format) into an emitter configuration file in JSON format that the current rendering engine can recognize.

[0314] In step 1420, the particle model file is used to describe the geometric model associated with the target particle object and the configuration information of the skeletal animation.

[0315] In this specific implementation, based on predetermined export rules, the Unreal Python program loads and parses the skeleton network resource file, exporting the second format (UASET / binary format) skeleton network resource file into a GLTF format particle model file that the current rendering engine can recognize. Furthermore, a series of usable material and texture images in image formats (e.g., PNG format) can also be exported from the skeleton network resource file.

[0316] In step 1430, the particle attribute file is used to describe the basic attribute parameters of the target particle corresponding to the target particle object.

[0317] In the specific implementation of this embodiment, the process of step 1430 is similar to that of step 1420 described above. To save space, it will not be described again.

[0318] In step 1440, the emitter configuration file, particle model file, and particle attribute file are integrated into a whole to obtain a complete file package, which is used as the converted resource file.

[0319] like Figure 15The diagram illustrates the specific process of exporting candidate resource files into converted resource files based on predetermined export rules. Specifically, the candidate resource files in the second format include candidate sub-files of three resource types: particle system resource files (resource type: emitter configuration), skeleton network resource files (resource type: material and texture configuration), and particle blueprint files (resource type: particle system mounting configuration). Therefore, when converting the candidate resource files from the second format to the first format, according to the predetermined export rules, the particle system resource files are converted into emitter configuration JSON files; the skeleton network resource files are converted into particle model GLTF files, specifying the materials and textures used; and the particle blueprint files are converted into particle attribute files (mounted model GLTF). Thus, the converted resource files include particle attribute files, emitter configuration JSON files, particle model GLTF files, and specified material and texture images.

[0320] The advantage of this embodiment is that it converts the format of various types of candidate sub-files in the candidate resource files based on predetermined export rules, and exports different types of candidate sub-files into resource file formats that the current rendering engine can recognize according to different export rules, resulting in converted resource files containing emitter configuration files, particle model files, and particle attribute files. This method can improve the reliability and accuracy of the format conversion of candidate resource files, reduce conversion errors when converting candidate resource files from the second format to the first format, and also export the resource materials in the candidate resource files more comprehensively, thereby improving the content integrity of the converted resource files.

[0321] In this embodiment of the disclosure, the converted resource file includes an emitter configuration parameter file, a rendering location file, and a rendering background file.

[0322] The emitter configuration parameter file is used to indicate parameters related to setting various properties of the particle emitter in the current rendering engine.

[0323] The rendering location file is used to indicate the specific location of the target particle object in the virtual scene.

[0324] The rendering background file is used to indicate the environment texture, lighting conditions, and other configuration information of the background where the target particle object is located.

[0325] Please refer to Figure 16 In one embodiment, the specific process of importing the converted resource file into the current rendering engine to render the target particle object may include, but is not limited to, the following steps 1610-1640:

[0326] Step 1610: Import the converted resource files into the current rendering engine;

[0327] Step 1620: Using the current rendering engine, render the background of the target particle object based on the background file;

[0328] Step 1630: Determine the emitter position in the background based on the rendered position file;

[0329] Step 1640: At the emitter location, render the target particle object using the emitter and based on the emitter configuration parameter file.

[0330] Steps 1610-1640 are described in detail below.

[0331] In step 1610, the converted resource files are imported into the preset particle generation system of the current rendering engine using a preset transmission protocol. The preset transmission protocol can be selected based on the current network status, which includes, but is not limited to, current network latency, current routing information, and current protocol statistics.

[0332] In step 1620, firstly, background texture information and lighting condition information are extracted from the rendered background file. Then, a seamless initial background is rendered using the current rendering engine based on the background texture information, and the lighting characteristics of the initial background are optimized based on the lighting condition information. The optimized background is then used as the background for the target particle object.

[0333] In step 1630, the emitter position is used to indicate the initial position of the target particle when it is displayed on the page during rendering.

[0334] In this specific implementation, firstly, the initial position configuration information of the target particle object is extracted from the rendering position file. Next, the specific position indicated by the initial position configuration information is determined in the background, and this specific position is designated as the emitter position.

[0335] In step 1640, firstly, the emitter is set at the emitter position, and according to the configuration parameters in the emitter configuration parameter file, the emitter generates target particles that conform to the configuration parameters, and the target particles are rendered into target particle objects.

[0336] The advantages of this embodiment are: dynamically selecting the transmission protocol based on network conditions improves the efficient loading and transmission of converted resource files when imported into the current rendering engine; simultaneously, after importing the converted resource files into the current rendering engine, the background is rendered first based on the background rendering file, and the emitter position is determined in the background based on the rendering position file, enabling precise control over the generation of particle effects on the background. Finally, the emitter is set at the emitter position, and the target particle object is rendered according to the emitter configuration parameter file, improving the rendering performance of the particle object. Furthermore, this method steps through background rendering and particle generation, increasing the flexibility of the entire rendering process and facilitating adjustments and optimizations to each stage of particle object rendering.

[0337] Please refer to Figure 17 In another embodiment, the specific process of importing the converted resource file into the current rendering engine to render the target particle object may include, but is not limited to, the following steps 1710-1740:

[0338] Step 1710: Import the converted resource files into the preset particle generation system of the current rendering engine;

[0339] Step 1720: Based on the emitter configuration file, create a particle emitter in the preset particle generation system;

[0340] Step 1730: Based on the particle model file and particle attribute file, generate particles using a particle emitter to obtain the target particles;

[0341] Step 1740: Render the target particle object based on the target particle.

[0342] Steps 1710-1740 are described in detail below.

[0343] In step 1710, the preset particle generation system refers to the current rendering engine that can use computer technology to simulate the specific structure of various tiny objects. These tiny objects include, but are not limited to, flames, smoke, and raindrops. These tiny objects can be collectively referred to as target particles.

[0344] In the specific implementation of this embodiment, the specific process of step 1710 is similar to that of step 1610 described above. To save space, it will not be described again.

[0345] In step 1720, the particle emitter refers to the core component in the current rendering engine's preset particle generation system used to generate and manage particles.

[0346] In this specific implementation, firstly, the emitter configuration file is parsed to obtain the construction parameters of the particle emitter. Then, the example system manager in the preset particle generation system creates the emitter based on the construction parameters, thus obtaining the particle emitter.

[0347] In step 1730, firstly, the particle model file and particle attribute file are imported into the particle emitter. The particle emitter then categorizes the configuration information related to the target particle object based on the particle model file and particle attribute file, obtaining categorized configuration information. Next, the particle emitter transmits each categorized configuration information to the corresponding configuration module. Each configuration module configures the particle attributes according to the categorized configuration information, and after the attributes of all configuration modules are configured, the target particle is generated.

[0348] The configuration modules include, but are not limited to, particle initial position configuration modules, particle shape configuration modules, and particle velocity configuration modules. The categorized configuration information includes, but is not limited to, particle shape information, particle initial position information, and particle velocity information.

[0349] In step 1740, firstly, the particle renderer in the current rendering engine is invoked. Then, the target particle is input into the particle renderer, which renders the target particle onto the predetermined scene page, thereby rendering the target particle object on the scene page.

[0350] The advantage of this embodiment is that after importing the converted resource files into the preset particle generation system generated by the current rendering, and constructing a particle emitter according to the emitter configuration file, the various attributes of the particle emitter can meet the requirements for generating target particles related to the target particle object. Furthermore, importing the particle model file and particle attribute file into the particle emitter, and configuring the particle attributes through the various configuration modules of the particle emitter, can improve the efficiency of generating target particles and the accuracy of target particle attribute configuration. Finally, the current rendering engine renders the target particle object based on the target particles, improving particle object rendering performance when the current rendering engine lacks the resource files required for particle object rendering.

[0351] Please refer to Figure 18 In one embodiment, step 1730 specifically includes, but is not limited to, the following steps 1810-1840:

[0352] Step 1810: For each target particle, obtain the particle configuration parameters of the target particle from the particle model file and particle attribute file;

[0353] Step 1820: Determine the number of target particles to be generated;

[0354] Step 1830: Based on the particle configuration parameters and the number of particles, generate particles through the particle emitter to obtain initial particles;

[0355] Step 1840: Configure the failure time of the initial particles to obtain the target particles.

[0356] Steps 1810-1840 are described in detail below.

[0357] In step 1810, the particle configuration parameters are used to indicate various attribute information of the target particles to be generated, such as particle shape, particle size, particle velocity, initial particle position, and particle color.

[0358] In the specific implementation of this embodiment, for each target particle, configuration information related to the target particle object is obtained from the particle model file and particle attribute file, and the obtained configuration information is used as the particle configuration parameters of the target particle.

[0359] In step 1820, the particle number is used to indicate the total number of target particles to be generated.

[0360] In this specific implementation, the attribute information indicating the total number of target particles to be generated is obtained from the particle attribute file, and this attribute information is used as the number of target particles to be generated.

[0361] In step 1830, the initial particle is used to indicate the particles generated by the particle emitter according to the particle configuration parameters.

[0362] In this specific implementation, the number of target particles to be generated is input into the particle emitter. The particle emitter configures the attributes of each initial particle, so that the configuration parameters of each particle are associated with the corresponding initial particle, thereby obtaining the number of initial particles.

[0363] The particle attributes of each initial particle can be the same or different, and the particle attributes of each initial particle depend on the configuration requirements in the particle configuration parameters.

[0364] In step 1840, firstly, attribute information indicating the lifecycle of the particles is obtained from the particle attribute file. Next, based on the obtained attribute information and the current time, the failure time of the initial particle is determined, and the failure time is configured for the initial particle according to the determined failure time, thus obtaining the target particle.

[0365] The advantage of this embodiment is that by extracting the configuration information related to the target particle object from the particle model file and particle attribute file into particle configuration parameters, it can effectively eliminate the interference of other unrelated information on particle generation. At the same time, by generating particles through a pre-constructed particle emitter and assigning a life cycle to the generated initial particles, it can improve the generation efficiency of target particles and the accuracy of particle attribute settings for each target particle.

[0366] Please refer to Figure 19 In one embodiment, step 1730 specifically includes, but is not limited to, the following steps 1910-1920:

[0367] Step 1910: Among multiple candidate rendering methods, determine the target rendering method for the target particle object;

[0368] Step 1920: Based on the target rendering method, render the target particles into target particle objects in the pre-determined target texture map.

[0369] Steps 1910-1920 are described in detail below.

[0370] In step 1910, among multiple candidate rendering methods, a target rendering method for the target particle object is determined.

[0371] Candidate rendering methods are used to indicate the rendering scheme that can be used when rendering target particles to the page.

[0372] The target rendering method is used to indicate the final selected rendering scheme for rendering the target particles onto the page.

[0373] In this specific implementation, firstly, the type of the target particle object is determined. Then, based on the type of the target particle object, among multiple candidate rendering methods, the candidate rendering method with the highest compatibility with the target particle object type is selected as the target rendering method. Specifically, determining the compatibility can be achieved using a lookup table. A pre-set mapping table indicating the compatibility between candidate rendering methods and various particle object types is obtained. Then, based on the type of the target particle object, the compatibility between each candidate rendering method and the target particle object type is found in the mapping table. Based on the magnitude of the compatibility, the candidate rendering method with the highest compatibility is selected as the target rendering method.

[0374] In step 1920, based on the target rendering method, the target particles are rendered into target particle objects in a pre-determined target texture map.

[0375] The target texture map is used to indicate the specific scene information when the target particle is rendered into a target particle object.

[0376] In the specific implementation of this embodiment, firstly, the appearance of the target particle object is determined according to the target rendering method. Then, using the target texture map as a background, the target particles are rendered at specific positions on the target texture map into target particle objects with the appearance specified by the target rendering method, based on the particle attributes of the target particles.

[0377] The advantage of this embodiment is that, when rendering the target particle object based on the target particle, the type of the target particle object is taken into consideration, and the candidate rendering method that best matches the type of the target particle object is selected as the target rendering method from multiple candidate rendering methods. Simultaneously, during rendering, according to the performance characteristics specified by the target rendering method, the target particle is rendered into a target particle object with that performance characteristics on the target texture map, achieving accurate rendering of the target particle object and thus improving the particle object rendering performance of the current rendering engine.

[0378] In a specific example, based on the target rendering method, the process of rendering target particles into target particle objects in a pre-determined target texture map includes, but is not limited to, the following steps:

[0379] If the target rendering method is the first method, then obtain the particle attribute information of the target particle, and render the target particle as a point element based on the particle attribute information;

[0380] Obtain the target texture map required for rendering;

[0381] The target particle object is rendered based on the target texture map and point elements.

[0382] The first method refers to a rendering method that renders particles as points (point sprite rendering method). This first method is suitable for target particle objects of the type of stars or raindrops. Rendering target particles as point elements means rendering target particles as points.

[0383] In the specific implementation of this embodiment, firstly, if the target rendering method is the first method, the particle attribute information of the target particle is obtained. In each frame, the target particle is rendered as a point, and the size and color of the point are adjusted according to the particle attribute information to obtain the point element. Next, with authorization, a predetermined target texture map for rendering is obtained, and the target texture map is rendered as the background. The point element is then rendered into the background, thereby rendering the target particle object.

[0384] The process of rendering the target particle object based on the target texture map and point elements may include, but is not limited to, the following steps:

[0385] The target texture map is divided into equal areas to obtain multiple animation frame images;

[0386] Determine the initial rendering coordinates of the point elements in each animation frame image;

[0387] The initial rendering coordinates are updated based on particle attribute information to obtain the target rendering coordinates;

[0388] Based on the target rendering coordinates, point elements are rendered as target particle objects in each animation frame image.

[0389] Among them, the animation frame image is the background to be rendered on the page, the initial rendering coordinates are used to indicate the initial position of the point element in the animation frame image, and the target rendering coordinates are used to indicate the specific position of the point element to be rendered on the animation frame image.

[0390] Specifically, firstly, the target texture image is divided into multiple animation frame images of equal area. Next, the image center of each animation frame image is used as the initial rendering coordinates of the point elements within that frame. Further, the initial rendering position of the point elements is obtained from the particle attribute information, and the initial rendering coordinates are updated based on the difference between the initial rendering position and the initial rendering coordinates to obtain the target rendering coordinates, where the target rendering coordinates are consistent with the specific position indicated by the initial rendering position. Finally, each animation frame image is rendered as the background of each frame in chronological order, and then, based on the target rendering coordinates, the point elements are rendered as target particle objects within each animation frame image (each frame background).

[0391] The advantage of this embodiment is that when the target particle object's type indicates that it should be rendered as a simple particle effect such as stars or raindrops, the first method is used as the target rendering method. Based on the first method and the particle attribute information, the target particle is rendered as a point element, so that the target particle is rendered as a single point in each frame. Then, the target texture map is rendered as the background, and the mesh model element point elements are rendered into the background, thus rendering the target particle object. This method effectively improves the rendering performance of the target particle object. Furthermore, since the target particle object is a series of points, the computational load during rendering is relatively small. This method can also meet the need to render a large number of target particle objects simultaneously, making it widely applicable to various rendering scenarios.

[0392] In another specific example, based on the target rendering method, the process of rendering target particles into target particle objects in a pre-determined target texture map includes, but is not limited to, the following steps:

[0393] If the target rendering method is the second method, then obtain the particle attribute information of the target particle, and render the target particle as a triangle primitive element based on the particle attribute information;

[0394] Obtain the target texture map required for rendering;

[0395] The target particle object is rendered based on the target texture map and triangle primitive elements.

[0396] The second method refers to a rendering method that renders particles as triangular primitives (triangular primitive rendering method). This second method is suitable for target particle objects of the type of fire or explosion. Rendering target particles as triangular primitive elements means rendering the target particles as triangular primitives.

[0397] In the specific implementation of this embodiment, firstly, if the target rendering method is the second method, the particle attribute information of the target particle is obtained. In each frame, the target particle is rendered into a triangular primitive, and the size, color, and other attributes of the triangular primitive are adjusted according to the particle attribute information to obtain the triangular primitive element. Next, with authorization, a predetermined target texture map for rendering is obtained and rendered as the background. The triangular primitive element is then rendered into the background, thereby rendering the target particle object.

[0398] The process of rendering the target particle object based on the target texture map and triangle primitive elements may include, but is not limited to, the following steps:

[0399] The target texture map is divided into equal areas to obtain multiple animation frame images;

[0400] Determine the initial rendering coordinate set of the triangular primitive element in each animation frame image;

[0401] The initial rendering coordinate set is updated based on particle attribute information to obtain the target rendering coordinate set;

[0402] Based on the target rendering coordinate group, triangular primitive elements are converted into target particle objects in each animation frame image.

[0403] The initial rendering coordinate set is used to determine the initial position of the triangle primitive element in the animation frame image, and the target rendering coordinate set is used to determine the final position of the triangle primitive element to be rendered in the animation frame image. Both the target rendering coordinate set and the initial rendering coordinate set contain the coordinate data of the three vertices of the triangle primitive element.

[0404] Specifically, the process of rendering a target particle object based on a target texture map and triangle primitives is basically the same as the process of rendering a target particle object based on a target texture map and point elements. The difference is that rendering a target particle object using triangle primitives requires configuring multiple coordinates, i.e., determining a set of rendering coordinates; while rendering a target particle object using point elements only requires configuring one coordinate. To save space, this will not be elaborated further.

[0405] The advantage of this embodiment is that when the target particle object's type indicates that it should be rendered as a complex particle effect such as an explosion or flame, the second method is used as the target rendering method. First, based on the second method and the particle attribute information, the target particles are rendered as triangular primitives. Then, the target texture map is rendered as the background, and the triangular primitive elements are rendered into the background. This effectively improves the rendering performance of the target particle object, giving the target particle object in the background a better visual effect. Furthermore, during rendering, the shape and size of the triangular primitives can be adjusted according to the particle attribute information and mesh configuration, providing good flexibility.

[0406] In another specific example, based on the target rendering method, the process of rendering target particles into target particle objects in a pre-determined target texture map includes, but is not limited to, the following steps:

[0407] If the target rendering method is the third method, then obtain the target particle's mesh configuration file and particle attribute information;

[0408] Based on the mesh configuration file and particle attribute information, the target particles are rendered as mesh model elements;

[0409] Obtain the target texture map required for rendering;

[0410] The target particle object is rendered based on the target texture map and mesh model elements.

[0411] The third method refers to a rendering method that renders particles as meshes (Mesh particle rendering method). This third method is suitable for target particle objects of three-dimensional effect types such as fragments and liquids.

[0412] The mesh configuration file is used to indicate configuration information related to rendering target particles into a mesh model.

[0413] Rendering target particles as mesh model elements refers to rendering target particles as mesh models.

[0414] In the specific implementation of this embodiment, firstly, if the target rendering method is the third method, the particle attribute information of the target particles is obtained. In each frame, the target particles are rendered into a three-dimensional mesh model, and the size, color, and other attributes of the mesh model are adjusted according to the particle attribute information to obtain mesh model elements. Next, with authorization, a pre-determined target texture map for rendering is obtained and rendered as the background. The mesh model elements are then rendered into the background, thereby rendering the target particle object.

[0415] The advantage of this embodiment is that, when the target particle object's type indicates that it should be rendered as a 3D particle effect, the third method is used as the target rendering method. First, based on the third method and the particle attribute information and mesh configuration file, the target particles are rendered into a 3D mesh model. Then, the target texture map is rendered as the background, and the mesh model elements are rendered into the background. This effectively improves the rendering performance of the target particle object, giving the target particle object in the background a better visual effect. Furthermore, during rendering, the shape and size of the mesh model can be adjusted according to the particle attribute information and mesh configuration file, providing good flexibility.

[0416] Since the particle attributes of target particles are not static and often change over time, these changes are typically recorded in the particle attribute file within the converted resource file. Therefore, this disclosure provides a scheme for periodically updating the particle attributes of target particles based on a timer. This enables timely updates to the target particles and improves the accuracy of their attribute configuration.

[0417] Please refer to Figure 20 In one embodiment, after generating target particles using a particle emitter, the particle object rendering process may include, but is not limited to, the following steps 2010-2030:

[0418] Step 2010: Obtain the current cumulative time value of the preset timer;

[0419] Step 2020: If it is determined that the current cumulative time value has reached the preset trigger condition, then obtain the updated configuration information of the target particle;

[0420] Step 2030: Based on the updated configuration information, update the properties of the target particles through the particle emitter.

[0421] Steps 2010-2030 are described in detail below.

[0422] In step 2010, the preset timer is used to measure the update time interval of the target particles; the current cumulative time value is used to indicate the duration accumulated by the preset timer at the current time point.

[0423] In a specific implementation of this embodiment, with authorization, the recorded time value is obtained from a preset timer to obtain the current cumulative time value.

[0424] In step 2020, the preset triggering condition is used to indicate the interval time required for one update of the target particle, and the updated configuration information is used to indicate the particle attributes that the target particle needs to be updated to.

[0425] In this specific implementation, firstly, the current accumulated time value is compared with the time threshold indicated in the preset trigger condition. Next, if the current accumulated time value is greater than or equal to the time threshold indicated in the preset trigger condition, it is determined that the current accumulated time value has reached the preset trigger condition, and the particle attributes of the target particle need to be updated. Based on this, the particle attributes to be updated for the target particle are obtained from the particle attribute file, resulting in the updated configuration information.

[0426] In step 2030, the updated configuration information is input into the particle emitter, and the particle emitter updates the properties of the target particles so that the various particle properties of the target particles are changed to the attribute parameters indicated in the updated configuration information.

[0427] The advantage of this embodiment is that it updates the particle attributes of the target particle periodically based on a timer. By obtaining the current cumulative time value of the preset timer in real time, and when the current cumulative time value reaches the preset trigger condition, it extracts the configuration information of the target particle corresponding to the current time from the particle attribute file, and updates the attributes of the target particle according to the configuration information corresponding to the current time. This method can achieve timely updates of the target particle, thereby improving the accuracy of the attribute configuration of the target particle at different times.

[0428] Since the memory size of the preset particle generation system in current rendering engines is limited, storing generated particles for extended periods can lead to infrequently used particles occupying the storage space, resulting in low memory utilization and hindering the generation of more particles. Therefore, this disclosure provides a scheme for recycling particles based on their lifecycle, which can promptly remove particles that do not meet requirements and improve the effective utilization of the preset particle generation system's memory space.

[0429] Please refer to Figure 21 In one embodiment, after generating target particles through a particle emitter, the particle object rendering process may include, but is not limited to, the following steps 2110-2120:

[0430] Step 2110: For the target particle, determine the particle failure time;

[0431] Step 2120: If it is determined that the current time has reached the particle expiration time, the target particle will be recovered.

[0432] Steps 2110-2120 are described in detail below.

[0433] In step 2110, the particle failure time is used to indicate the cutoff point at which the target particle is allowed to exist.

[0434] In this specific implementation, when each target particle is generated, the particle emitter assigns a lifecycle to the target particle according to the particle attribute file. This lifecycle indicates the effective duration of the target particle. Based on this, with authorization, the particle expiration time of the target particle can be determined according to its lifecycle.

[0435] In step 2120, firstly, the current time and the particle expiration time are compared. Then, if it is determined that the current time has reached the particle expiration time, it indicates that the target particle has exceeded its life cycle and needs to be cleaned up. Therefore, the target particle is recycled to free up a portion of the memory space of the preset particle generation system.

[0436] The advantage of this embodiment is that it recycles each particle based on its life cycle. When the current time reaches the particle expiration time of the target particle, the target particle is recycled, which can promptly remove each particle that has exceeded its life cycle, thereby improving the effective utilization rate of the memory space of the preset particle generation system.

[0437] The implementation details of a particle object rendering method according to an embodiment of this disclosure are described below.

[0438] The following reference Figures 22A-22C This document details a specific implementation process of the particle object rendering method according to an embodiment of the present disclosure.

[0439] like Figure 22A The diagram illustrates the overall workflow of particle object rendering. Specifically, the candidate resource files in the candidate rendering engine are created by objects (e.g., artists). During rendering, the candidate resource files in the candidate rendering engine are first exported as converted resource files for the current rendering engine using a resource export tool, a process similar to steps 1410-1440 above. Next, the converted resource files are loaded into the preset particle generation system of the current rendering engine. The particle emitters in the preset particle generation system are used to generate target particles, and the target particles are rendered as target particle objects, a process similar to steps 1710-1740 above. For brevity, these details are omitted.

[0440] like Figure 22BThe diagram shows the overall workflow of the current rendering engine's preset particle generation system. Specifically, firstly, the converted resource files are imported into the current rendering engine's preset particle generation system. The particle system management interface manages the particle system components, obtaining the emitter's construction parameters by parsing the emitter configuration file. The particle system components can then create a particle emitter. Next, the particle emitter configures particle attributes in multiple configuration modules, such as the particle position module, particle initial position module, particle emitter shape 1, and particle emitter shape 2, based on the particle attribute files and particle model files in the converted resource files, thereby generating target particles. The particle position module primarily determines the initial position of the generated particles. Furthermore, the lifecycle of the target particles is controlled using particle lifecycle information in the particle attribute files, a process similar to steps 1810-1840 above. Finally, the target particles are rendered, thus rendering the target particle objects onto the page, a process similar to steps 1910-1920 above. Additionally, a timer is set up in this process to trigger updates, causing the particle emitter to update the target particle's attributes based on the particle attribute file and particle model file, indicating the target particle should be in its current state. The specific process is similar to steps 2010-2030 above. To save space, it will not be described in detail here.

[0441] like Figure 22C The diagram shows the main workflow of the particle emitter. Specifically, the main workflow of the particle emitter consists of recycling, updating, generating, and rendering. Recycling refers to cleaning up particles that have exceeded their lifespan to reclaim memory; the specific process is similar to steps 2110-2120 above. Updating refers to updating the particle's position, size, color, and other attributes; the specific process is similar to steps 2010-2030 above. Generating refers to determining the number of particles to generate based on the particle emitter's various configuration parameters and generating the particles; the specific process is similar to steps 1810-1840 above. Rendering refers to rendering the particles into particle objects; the specific process is similar to steps 1910-1920 above. For the sake of brevity, these will not be elaborated further.

[0442] The apparatus and device according to embodiments of this disclosure will now be described.

[0443] It is understood that although the steps in the above flowcharts are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated in this embodiment, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the above flowcharts may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages in other steps.

[0444] It should be noted that in various specific embodiments of this application, when processing is required based on data related to the characteristics of the target object, such as target object attribute information or a set of attribute information, the permission or consent of the target object will be obtained first. Furthermore, the collection, use, and processing of this data will comply with relevant laws, regulations, and standards. In addition, when embodiments of this application require obtaining target object attribute information, separate permission or consent from the target object will be obtained through pop-ups or redirection to a confirmation page. Only after obtaining the target object's separate permission or consent will the necessary target object-related data for the normal operation of the embodiments of this application be obtained.

[0445] Figure 23 This is a schematic diagram of the structure of a particle object rendering processing apparatus 2300 provided in an embodiment of this disclosure. The particle object rendering processing apparatus 2300 includes:

[0446] The acquisition unit 2310 is used to acquire multiple candidate resource files for rendering the target particle object outside the current rendering engine if there is no first resource file for rendering the target particle object in the current rendering engine, wherein the first resource file has a first format and the candidate resource files have a second format.

[0447] The first determining unit 2320 is used to determine the content difference between the candidate resource file and the first resource file;

[0448] The second determining unit 2330 is used to determine the conversion complexity between the second format and the first format of the candidate resource file;

[0449] The third determining unit 2340 is used to determine the second resource file from multiple candidate resource files based on the content difference degree and the conversion complexity.

[0450] The processing unit 2350 is used to convert the second format of the candidate resource file into the first format to obtain the converted resource file, and import the converted resource file into the current rendering engine to render the target particle object.

[0451] Optionally, the acquisition unit 2310 includes:

[0452] The first acquisition module (not shown) is used to acquire multiple resource files to be examined for rendering the target particle object outside the current rendering engine;

[0453] The second acquisition module (not shown) is used to acquire the frequency of the resource file under investigation being used for rendering the target particle object;

[0454] The third acquisition module (not shown) is used to acquire the rendering accuracy of the resource file to be examined for rendering the target particle object;

[0455] A determination module (not shown) is used to determine multiple candidate resource files from multiple resource files to be examined based on frequency and rendering accuracy.

[0456] Optionally, the first acquisition module (not shown) is used for:

[0457] Obtain multiple rendering engines to be examined, other than the current rendering engine. The number of multiple rendering engines to be examined is equal to the number of multiple resource files to be examined.

[0458] From each rendering engine to be examined, obtain one resource file for rendering the target particle object to be examined, so as to form multiple resource files to be examined.

[0459] Optionally, the first determining unit 2320 is used for:

[0460] Extract the first attribute values ​​of multiple target rendering attributes from the first resource file;

[0461] Extract the second attribute values ​​of multiple target rendering attributes from the candidate resource files;

[0462] For each target rendering attribute, determine the difference between the first attribute value and the second attribute value;

[0463] The content difference is determined based on the difference in rendering attributes for each target.

[0464] Optionally, the second determining unit 2330 includes:

[0465] A comparison module (not shown) is used to compare the second format and the first format to obtain multiple differences.

[0466] The input module (not shown) is used to input multiple differences into the transformation complexity prediction model to obtain the transformation complexity.

[0467] Optionally, the first resource file includes multiple first sub-files, and the candidate resource file includes multiple candidate sub-files; the first format includes the first sub-format of each first sub-file, and the second format includes the second sub-format of each candidate sub-file;

[0468] Optionally, the comparison module (not shown) is used for:

[0469] Based on the correspondence between the first sub-file and the candidate sub-file, the mapping relationship between the first sub-format and the second sub-format is determined, wherein each first sub-format corresponds to one second sub-format;

[0470] By comparing the differences between the first and second sub-formats that have a mapping relationship, multiple sub-difference points are obtained.

[0471] Multiple sub-difference points are integrated into multiple difference points.

[0472] Optionally, the third determining unit 2340 is used for:

[0473] Candidate resource files with content differences greater than the first threshold are filtered out, resulting in multiple filtered resource files.

[0474] Based on the conversion complexity of each filtered resource file, the second resource file is determined from multiple filtered resource files.

[0475] Optionally, the third determining unit 2340 is used for:

[0476] The first score is determined based on the content differences of the candidate resource files;

[0477] The second score is determined based on the conversion complexity of the candidate resource files;

[0478] The total score of the candidate resource files is determined based on the first score and the second score.

[0479] Based on the total score of each candidate resource file, a second resource file is determined from multiple candidate resource files.

[0480] Optionally, the converted resource files include an emitter configuration parameter file, a rendering location file, and a rendering background file;

[0481] Processing unit 2350 is used for:

[0482] Import the converted resource files into the current rendering engine;

[0483] Render the background of the target particle object using the current rendering engine, based on the background file.

[0484] The emitter position is determined in the background based on the rendered position file;

[0485] At the emitter location, the target particle object is rendered using the emitter and based on the emitter configuration parameter file.

[0486] Optionally, the candidate resource files include particle system resource files in a second format, skeleton network resource files in a second format, and particle blueprint files in a second format;

[0487] Processing unit 2350 includes:

[0488] The import module (not shown) is used to import the converted resource files into the current rendering engine's preset particle generation system;

[0489] Create a module (not shown) to create a particle emitter in a preset particle generation system based on the emitter configuration file;

[0490] The generation module (not shown) is used to generate target particles through a particle emitter based on particle model files and particle attribute files.

[0491] The rendering module (not shown) is used to render target particle objects based on target particles.

[0492] Optionally, the generation module (not shown) is used for:

[0493] For each target particle, obtain the particle configuration parameters of the target particle from the particle model file and particle attribute file;

[0494] Determine the number of target particles to be generated;

[0495] Based on the particle configuration parameters and the number of particles, particles are generated through a particle emitter to obtain initial particles;

[0496] The initial particles are configured with failure times to obtain the target particles.

[0497] Optionally, the particle object rendering processing apparatus 2300 further includes an update unit (not shown), which is used for:

[0498] Get the current cumulative time value of the preset timer;

[0499] If it is determined that the current cumulative time value has reached the preset trigger condition, then obtain the updated configuration information of the target particle;

[0500] Based on the updated configuration information, the properties of the target particles are updated via the particle emitter.

[0501] Optionally, the particle object rendering processing apparatus 2300 further includes a recycling unit (not shown), which is used for:

[0502] For the target particle, determine the particle failure time;

[0503] If it is determined that the current time has reached the particle's expiration time, the target particle will be recovered.

[0504] Optionally, the rendering module (not shown) includes:

[0505] A determination submodule (not shown) is used to determine the target rendering method for the target particle object among multiple candidate rendering methods;

[0506] The rendering submodule (not shown) is used to render target particles into target particle objects in a predefined target texture map based on the target rendering method.

[0507] Optionally, the rendering submodule (not shown) is used for:

[0508] If the target rendering method is the first method, then obtain the particle attribute information of the target particle, and render the target particle as a point element based on the particle attribute information;

[0509] Obtain the target texture map required for rendering;

[0510] The target particle object is rendered based on the target texture map and point elements.

[0511] Optionally, the target particle object is rendered based on the target texture map and point elements, including:

[0512] The target texture map is divided into equal areas to obtain multiple animation frame images;

[0513] Determine the initial rendering coordinates of the point elements in each animation frame image;

[0514] The initial rendering coordinates are updated based on particle attribute information to obtain the target rendering coordinates;

[0515] Based on the target rendering coordinates, point elements are rendered as target particle objects in each animation frame image.

[0516] Optionally, the rendering submodule (not shown) is used for:

[0517] If the target rendering method is the second method, then obtain the particle attribute information of the target particle, and render the target particle as a triangle primitive element based on the particle attribute information;

[0518] Obtain the target texture map required for rendering;

[0519] The target particle object is rendered based on the target texture map and triangle primitive elements.

[0520] Optionally, the target particle object is rendered based on the target texture map and triangle primitive elements, including:

[0521] The target texture map is divided into equal areas to obtain multiple animation frame images;

[0522] Determine the initial rendering coordinate set of the triangular primitive element in each animation frame image;

[0523] The initial rendering coordinate set is updated based on particle attribute information to obtain the target rendering coordinate set;

[0524] Based on the target rendering coordinate group, triangular primitive elements are converted into target particle objects in each animation frame image.

[0525] Optionally, the rendering submodule (not shown) is used for:

[0526] If the target rendering method is the third method, then obtain the target particle's mesh configuration file and particle attribute information;

[0527] Based on the mesh configuration file and particle attribute information, the target particles are rendered as mesh model elements;

[0528] Obtain the target texture map required for rendering;

[0529] The target particle object is rendered based on the target texture map and mesh model elements.

[0530] Reference Figure 24 , Figure 24 To implement the structural block diagram of the terminal portion of the particle object rendering processing method according to the embodiments of this disclosure, the terminal includes: a radio frequency (RF) circuit 2410, a memory 2415, an input unit 2430, a display unit 2440, a sensor 2450, an audio circuit 2460, a wireless fidelity (WiFi) module 2470, a processor 2480, and a power supply 2490, etc. Those skilled in the art will understand that... Figure 24 The terminal structure shown does not constitute a limitation on mobile phones or computers and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0531] The RF circuit 2410 can be used to receive and transmit signals during information transmission or calls. In particular, it receives downlink information from the base station and processes it with the processor 2480; in addition, it transmits uplink data to the base station.

[0532] The memory 2415 can be used to store software programs and modules. The processor 2480 executes various functional applications and data processing of the target terminal by running the software programs and modules stored in the memory 2415.

[0533] The input unit 2430 can be used to receive input numeric or character information, and to generate key signal inputs related to the settings and function control of the target terminal. Specifically, the input unit 2430 may include a touch panel 2431 and other input devices 2432.

[0534] Display unit 2440 can be used to display input or provided information, as well as various menus of the target terminal. Display unit 2440 may include display panel 2441.

[0535] Audio circuitry 2460, speaker 2461, and microphone 2462 provide an audio interface.

[0536] In this embodiment, the processor 2480 included in the terminal can execute the particle object rendering processing method of the previous embodiment.

[0537] The terminals disclosed in this embodiment include, but are not limited to, mobile phones, computers, intelligent voice interaction devices, smart home appliances, vehicle terminals, and aircraft. The embodiments of this invention can be applied to various scenarios, including but not limited to data security, blockchain, data storage, and information technology.

[0538] Figure 25 This is a partial structural block diagram of a server for implementing the particle object rendering processing method of this disclosure. The server can vary significantly due to different configurations or performance, and may include one or more central processing units (CPUs) 2522 (e.g., one or more processors) and memory 2532, and one or more storage media 2530 (e.g., one or more mass storage devices) for storing application programs 2542 or data 2544. The memory 2532 and storage media 2530 can be temporary or persistent storage. The program stored in the storage media 2530 may include one or more modules (not shown in the diagram), each module including a series of instruction operations on the server. Furthermore, the CPU 2522 may be configured to communicate with the storage media 2530 and execute a series of instruction operations in the storage media 2530 on the server.

[0539] The server may also include one or more power supplies 2526, one or more wired or wireless network interfaces 2550, one or more input / output interfaces 2558, and / or one or more operating systems 2541, such as Windows Server™, Mac OS X™, Unix™, Linux™, FreeBSD™, etc.

[0540] The central processing unit 2522 in the server can be used to execute the particle object rendering processing method of the present disclosure embodiments.

[0541] This disclosure also provides a computer-readable storage medium for storing program code for executing the particle object rendering processing methods of the foregoing embodiments.

[0542] This disclosure also provides a computer program product comprising a computer program. A processor of a computer device reads and executes the computer program, causing the computer device to perform the particle object rendering processing method described above.

[0543] The terms “first,” “second,” “third,” “fourth,” etc. (if present) in this disclosure and the foregoing drawings are used to distinguish similar objects and are not necessarily used to describe a particular order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this disclosure described herein can be implemented, for example, in orders other than those illustrated or described herein. Furthermore, the terms “comprising” and “including,” and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that includes a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatuses.

[0544] It should be understood that in this disclosure, "at least one item" means one or more, and "more than one" means two or more. "And / or" is used to describe the relationship between related objects, indicating that three relationships can exist. For example, "A and / or B" can represent three cases: only A exists, only B exists, and both A and B exist simultaneously, where A and B can be singular or plural. The character " / " generally indicates that the preceding and following related objects are in an "or" relationship. "At least one of the following" or similar expressions refer to any combination of these items, including any combination of single or plural items. For example, at least one of a, b, or c can represent: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", where a, b, and c can be single or multiple.

[0545] It should be understood that in the description of the embodiments disclosed herein, "multiple" means two or more, "greater than", "less than", "exceeding" etc. are understood to exclude the number itself, and "above", "below", "within" etc. are understood to include the number itself.

[0546] In the several embodiments provided in this disclosure, 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, indirect coupling or communication connection between apparatuses or units, and may be electrical, mechanical, or other forms.

[0547] In this disclosure, 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.

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

[0549] Furthermore, the functional units in the various embodiments of this disclosure 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. The integrated unit can be implemented in hardware or as a software functional unit.

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

[0551] It should also be understood that the various implementation methods provided in this disclosure can be combined arbitrarily to achieve different technical effects.

[0552] The above is a detailed description of the embodiments of this disclosure. However, this disclosure is not limited to the above embodiments. Those skilled in the art can make various equivalent modifications or substitutions without departing from the spirit of this disclosure. All such equivalent modifications or substitutions are included within the scope defined by the claims of this disclosure.

Claims

1. A particle object rendering method, characterized in that, For the current rendering engine, the method includes: If there is no first resource file for rendering the target particle object in the current rendering engine, multiple candidate resource files for rendering the target particle object are obtained outside the current rendering engine, wherein the first resource file has a first format and the candidate resource files have a second format. Determine the content difference between the candidate resource file and the first resource file; Determine the conversion complexity between the second format and the first format of the candidate resource files; Based on the content difference and the conversion complexity, a second resource file is determined from the plurality of candidate resource files; The candidate resource file is converted from its second format to its first format to obtain a converted resource file. The converted resource file is then imported into the current rendering engine to render the target particle object.

2. The method according to claim 1, characterized in that, The step of obtaining multiple candidate resource files for rendering the target particle object outside the current rendering engine includes: Outside the current rendering engine, acquire multiple resource files to be examined for rendering the target particle object; Obtain the frequency with which the resource file to be examined is used for rendering the target particle object; Obtain the rendering accuracy of the resource file to be examined for rendering the target particle object; Based on the frequency and the rendering accuracy, the plurality of candidate resource files are determined from the plurality of resource files to be examined.

3. The method according to claim 2, characterized in that, The step involves acquiring multiple resource files for rendering the target particle object outside the current rendering engine, including: Obtain multiple rendering engines to be examined, other than the current rendering engine, wherein the number of multiple rendering engines to be examined is equal to the number of multiple resource files to be examined; From each of the rendering engines to be examined, obtain one resource file to be examined for rendering the target particle object, so as to form the plurality of resource files to be examined.

4. The method according to claim 1, characterized in that, Determining the content difference between the candidate resource file and the first resource file includes: Extract the first attribute value of multiple target rendering attributes from the first resource file; Extract the second attribute values ​​of the plurality of target rendering attributes from the candidate resource files; For each of the target rendering attributes, determine the difference between the first attribute value and the second attribute value; The content difference is determined based on the difference in each of the target rendering attributes.

5. The method according to claim 1, characterized in that, Determining the conversion complexity between the second format and the first format of the candidate resource file includes: Comparing the second format and the first format reveals several differences. The multiple differences are input into the transformation complexity prediction model to obtain the transformation complexity.

6. The method according to claim 5, characterized in that, The first resource file includes multiple first sub-files, and the candidate resource file includes multiple candidate sub-files; the first format includes a first sub-format of each first sub-file, and the second format includes a second sub-format of each candidate sub-file; The comparison between the second format and the first format yields several differences, including: Based on the correspondence between the first sub-file and the candidate sub-file, the mapping relationship between the first sub-format and the second sub-format is determined, wherein each first sub-format corresponds to one second sub-format; A difference comparison is performed on the first sub-format and the second sub-format that have the aforementioned mapping relationship to obtain multiple sub-difference points; The multiple sub-difference points are integrated into the multiple difference points.

7. The method according to claim 1, characterized in that, The step of determining a second resource file from the plurality of candidate resource files based on the content difference and the conversion complexity includes: Candidate resource files whose content difference is greater than a first threshold are filtered out to obtain multiple filtered resource files; The second resource file is determined from among the multiple filtered resource files based on the conversion complexity of each of the filtered resource files.

8. The method according to claim 1, characterized in that, The step of determining a second resource file from the plurality of candidate resource files based on the content difference and the conversion complexity includes: A first score is determined based on the content differences of the candidate resource files; A second score is determined based on the conversion complexity of the candidate resource files; Based on the first score and the second score, determine the total score of the candidate resource file; The second resource file is determined from the plurality of candidate resource files based on the total score of each candidate resource file.

9. The method according to claim 1, characterized in that, The converted resource files include an emitter configuration parameter file, a rendering location file, and a rendering background file; The step of importing the converted resource file into the current rendering engine to render the target particle object includes: Import the converted resource file into the current rendering engine; The background of the target particle object is rendered using the current rendering engine, based on the rendering background file. Based on the rendered location file, determine the emitter position in the background; At the emitter location, the target particle object is rendered using the emitter, based on the emitter configuration parameter file.

10. The method according to claim 1, characterized in that, The candidate resource files include particle system resource files in a second format, skeleton network resource files in a second format, and particle blueprint files in a second format. The step of converting the second format of the candidate resource file into the first format to obtain the converted resource file includes: Based on predetermined export rules, the second format of the particle system resource file is converted into the first format to obtain the emitter configuration file; The second format of the skeleton network resource file is converted into the first format to obtain the particle model file; The second format of the particle blueprint file is converted into the first format to obtain the particle attribute file; The emitter configuration file, the particle model file, and the particle attribute file are integrated into the transformed resource file.

11. The method according to claim 10, characterized in that, The step of importing the converted resource file into the current rendering engine to render the target particle object includes: Import the converted resource file into the preset particle generation system of the current rendering engine; Based on the emitter configuration file, a particle emitter is created in the preset particle generation system; Based on the particle model file and the particle attribute file, the particle emitter generates particles to obtain the target particles. The target particle object is rendered based on the target particle.

12. The method according to claim 11, characterized in that, The process of generating target particles using the particle emitter based on the particle model file and the particle attribute file includes: For each target particle, obtain the particle configuration parameters of the target particle from the particle model file and the particle attribute file; Determine the number of target particles to be generated; Based on the particle configuration parameters and the number of particles, particles are generated through the particle emitter to obtain initial particles; The initial particle is configured with a failure time to obtain the target particle.

13. The method according to claim 11, characterized in that, After generating target particles through the particle emitter, the particle object rendering method further includes: Get the current cumulative time value of the preset timer; If it is determined that the current cumulative time value has reached the preset trigger condition, then the updated configuration information of the target particle is obtained; Based on the updated configuration information, the target particle's attributes are updated via the particle emitter.

14. The method according to claim 11, characterized in that, After generating target particles through the particle emitter, the particle object rendering method further includes: For the target particle, determine the particle failure time; If it is determined that the current time has reached the particle's expiration time, the target particle will be recovered.

15. The method according to claim 11, characterized in that, The process of rendering the target particle object based on the target particle includes: Among multiple candidate rendering methods, a target rendering method is determined for rendering the target particle object; Based on the target rendering method, the target particles are rendered into target particle objects in a pre-determined target texture map.

16. A particle object rendering processing apparatus, characterized in that, For the current rendering engine, the device includes: The acquisition unit is configured to acquire, outside the current rendering engine, a plurality of candidate resource files for rendering the target particle object if no first resource file for rendering the target particle object exists in the current rendering engine, wherein the first resource file has a first format and the candidate resource files have a second format. The first determining unit is used to determine the content difference between the candidate resource file and the first resource file; The second determining unit is used to determine the conversion complexity between the second format and the first format of the candidate resource file; The third determining unit is used to determine the second resource file from the plurality of candidate resource files based on the content difference degree and the conversion complexity. The processing unit is configured to convert the second format of the candidate resource file into the first format to obtain the converted resource file, and import the converted resource file into the current rendering engine to render the target particle object.

17. An electronic device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the particle object rendering processing method according to any one of claims 1 to 15.

18. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the particle object rendering processing method according to any one of claims 1 to 15.

19. A computer program product comprising a computer program that is read and executed by a processor of an electronic device, causing the electronic device to perform the particle object rendering processing method according to any one of claims 1 to 15.

Images