A performance optimization method based on UE5 modular roles

Abstract

The application provides a performance optimization method based on UE5 modular roles, comprising: multi-module segmentation of the role; wrapping animation data of a skeleton in a UAnimInstance calculation unit, wrapping skeleton data in a USkeleton file, aligning and merging skeleton hierarchies, skeleton indexes and skeleton binding data of two adjacent skeletons to generate skeleton data containing all information of the two skeletons; dynamically merging skeletons and skeleton mesh bodies at runtime, setting to make each object apply effective animation individually, determining a posture of the skeleton through configuration in the case of data of the skeleton having an overlapping part, extending and configuring related support of related content in need of dynamic merging in a graph of an animation blueprint, so that the original graph function is supported under the new merging framework; and controlling animation through an interface and configuration to realize animation of a specific skeleton mesh body.

Description

Technical Field

[0001] This invention relates to the field of animation technology, and in particular to a performance optimization method based on UE5 modular characters. Background Technology

[0002] As the 3D industry's demands for image quality and interactivity continue to increase, the number of commonly used characters and animations in business applications has also shown a significant growth trend. This trend has increased the complexity of related 3D development. To ensure the diversity of modular character effects, projects often adopt modular character presentation and interaction systems. Characters typically consist of multiple systems and sub-components, including but not limited to animation, physics, AI, and logic. These systems are highly coupled, often requiring complex state synchronization and resource loading. In this context, the design of the core character system is generally quite complex and often brings significant problems, such as runtime performance bottlenecks. Traditional methods typically rely on the following approaches: using a fixed set of specific characters, using LeadPose provided by the UX for stitching, adopting seemingly similar content while maintaining a unified design, using slots to provide more components, and simple dynamic merging, etc.

[0003] For example, the invention disclosed in CN115984435A, entitled "Batch Processing Method, Apparatus, Electronic Device, and Computer Medium for Skeletal Data," includes the following method: acquiring the skeletal data of all characters in the current frame, and placing skeletal data of characters with the same model and model material into the same skeletal data array; splitting the skeletal data array into multiple skeletal data subarrays according to the memory occupied by the skeletal data of each character, wherein the memory occupied by the skeletal data in each skeletal data subarray is less than or equal to a batching memory threshold; and merging the skeletal data in the same skeletal data subarray into a batch for transmission to the graphics processor. By placing skeletal data of the same model and material into the same skeletal data array, splitting it into multiple skeletal data subarrays according to the batching memory threshold, and merging the skeletal data in the same skeletal data subarray into a batch for transmission, the frame rate and smoothness of rendering can be improved.

[0004] However, in actual deployment, the following problems exist: insufficient flexibility and extremely poor framework scalability; extremely high component redundancy, often leading users to feel that the value does not match reality; severe design limitations making it difficult to break through framework constraints, resulting in limited innovative performance; at the same time, maintenance costs gradually increase with project iterations, affecting development efficiency and final product quality; and difficulty in maintaining correct performance when performance is low. Therefore, developing a performance optimization method based on UE5 modular roles is one of the important problems that needs to be solved. Summary of the Invention

[0005] To address the aforementioned problems in existing technologies, the purpose of this invention is to provide a performance optimization method based on UE5 modular roles.

[0006] To address the aforementioned issues, this invention employs the following technical solution: a performance optimization method for UE5 modular characters, comprising: dividing the character into multiple modules; acquiring the skeletal data and animation data of the current module; packaging the animation data of the skeletal data in a UAnimInstance computing unit; packaging the skeletal data in a USkeleton file; aligning and merging the skeletal hierarchy, skeletal index, and skeletal binding data of two adjacent skeletons; filling in missing parts to generate a skeleton data containing all information of the two adjacent skeletons; dynamically merging skeletons and skeleton meshes at runtime; when model objects with multiple skeletons and multiple different animations need to be mixed, setting each object to apply its own effective animation; configuring the posture of data with overlapping parts of the skeletons; extending and configuring the relevant content that needs to be dynamically merged in the animation blueprint graph to support the original graph function under the new merging framework; controlling the animation through interfaces and configurations; and implementing the animation of a specific skeleton mesh based on the configuration.

[0007] Furthermore, the process of aligning and merging the skeletal hierarchy, skeletal index, and skeletal binding data of the two bones specifically involves:

[0008] The skeleton merging is encapsulated as a static method function. The function takes a set of skeleton mesh objects and configuration parameter data as input and returns a merged skeleton mesh object. During the merging process, conflicts are checked. If a mismatch is found, the relevant information about the mismatch is returned. The merging time is arbitrary. The general principle is to merge before use. However, since this behavior requires a certain amount of I / O time, it is recommended to preload the skeleton mesh objects before they are used.

[0009] Furthermore, the extension and configuration of related support specifically includes:

[0010] The configuration includes source skeleton, source skeleton mesh, model material segmentation mapping, UV transformation rules, LOD processing, CPU accessibility, and skeleton update mode.

[0011] Furthermore, the process of filling in the missing parts specifically includes:

[0012] When animation data is missing, the graph supports bones that actually exist in the skeleton but lack relevant data in the animation. It automatically constructs specific bone chains through ControlRig to fill in the animation data (Note: When using fullbodyIk, pay attention to the order of related nodes to prevent out-of-bounds access).

[0013] Furthermore, the skeletal mesh merging specifically refers to merging two or more skeletal mesh models into a single mesh asset.

[0014] Furthermore, the animation control specifically provides a set of standard functions, which users can trigger the animation behavior of specific components by calling the interface and passing parameters in the animation blueprint.

[0015] Furthermore, data assets are used to define the components, mount names, and model references available to roles, and configuration drives role composition.

[0016] Furthermore, the character is divided into multiple modules, specifically the modular division of different actions, movements of different parts of the body, and different functions of the character.

[0017] Furthermore, the optimization method includes the following steps:

[0018] Step 1: Create a plugin and write dynamic skeleton merging code that depends on mergemesh, including mergemesh usage encapsulation, animation blueprint access registration, and animation node construction;

[0019] Step 2: Write the relevant encapsulation for users. The user's original data is used to identify the required model through data identification. After filtering, adaptation and completion steps, all the data required for the merging is formed.

[0020] Step 3: Write the animation interface to prepare the data framework for the state machine-animation transition;

[0021] Step 4: Inherit the animation interface described in Step 3, and implement the animation of a specific skeleton mesh through configuration;

[0022] Step 5: Under Runtime, select to merge the relevant model data and then select the animation.

[0023] Furthermore, this application provides a performance optimization method based on UE5 modular roles, the usage of which includes:

[0024] S1. Start UE5 and enable the mergemesh plugin;

[0025] S2. Import the skeleton mesh;

[0026] S3. Configure the skeleton mesh and mount the registration name;

[0027] S4. Create an animation blueprint, specifying the skeleton and related information of the object;

[0028] S5. At runtime, the blueprint calls the dynamic merge and applies it, specifying the relevant animation.

[0029] Working Principle: The performance optimization method for UE5 modular characters provided in this application involves dividing the character into multiple modules; acquiring the skeletal data and animation data of the current module; packaging the animation data of the skeleton in a UAnimInstance computing unit; packaging the skeletal data in a USkeleton file; aligning and merging the skeletal hierarchy, skeletal index, and skeletal binding data of two adjacent skeletons; filling in missing parts to generate a skeleton data containing all information of the two adjacent skeletons; dynamically merging skeletons and skeleton meshes at runtime; when model objects with multiple skeletons and multiple different animations need to be mixed, setting each object to apply its own effective animation; configuring the posture of data with overlapping parts of the skeletons; extending and configuring the relevant content that needs to be dynamically merged in the animation blueprint graph to support the original graph function under the new merging framework; controlling the animation through interfaces and configurations; and implementing the animation of a specific skeleton mesh based on the configuration.

[0030] Compared with the prior art, the beneficial technical effects of the present invention are as follows:

[0031] 1. This application provides a performance optimization method based on UE5 modular characters, which can effectively reduce the copying and redundant calculation of animation poses by dynamically merging the skeleton and skeleton mesh at runtime;

[0032] 2. The optimization method provided in this application, by aligning and merging the skeletal data of two skeletons before running to form a single skeleton data and unifying the skeleton index, helps to reduce CPU animation calculation and memory access overhead.

[0033] 3. The optimization method provided in this application can ensure animation reuse while maintaining the characteristic structure, thereby reducing the repeated production of animation assets;

[0034] 4. The optimization method provided in this application can provide high iteration efficiency by dynamically merging the skeleton and skeleton mesh, without depending on the same skeleton data, and has high compatibility. Attached Figure Description

[0035] Figure 1 This is a flowchart of the optimization method described in the embodiments of this application. Detailed Implementation

[0036] The technical solution of the present invention will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0037] In the description of this invention, it should be noted that the terms "center," "upper," "lower," "vertical," "horizontal," and "inner," etc., indicating orientation or positional relationships based on the orientation or positional relationships shown in the accompanying drawings, are only for the convenience of describing this application and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation, and therefore should not be construed as a limitation of this application. Furthermore, unless otherwise explicitly specified and limited, the terms "installed," "connected," and "linked" should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral connection; they can refer to a mechanical connection; they can refer to a direct connection or an indirect connection through an intermediate medium; they can refer to the internal communication between two elements. Those skilled in the art can understand the specific meaning of the above terms in this invention based on the specific circumstances.

[0038] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.

[0039] Example 1

[0040] like Figure 1 As shown, a performance optimization method based on UE5 modular roles includes:

[0041] The character is segmented into multiple modules. It should be noted that this segmentation specifically involves dividing the character into multiple modules, specifically modularizing the character's different actions, movements of different body parts, and different functions. For example, in some embodiments, a character is divided into multiple parts, such as the head, body, and legs. A corresponding skeleton mesh and skeleton are set for each segmentation module.

[0042] The system acquires the skeletal data and animation data of the current module, aligns and merges the skeletal hierarchy, skeletal index, and skeletal binding data of two adjacent skeletons, and fills in any missing parts to generate a skeleton data containing all information of the two adjacent skeletons. It should be noted that the animation data of the skeleton is packaged in the UAnimInstance computing unit, and the skeletal data is packaged in the USkeleton file. The skeletal data includes metadata such as skeletal hierarchy, binding status, slots, and notifications.

[0043] At runtime, the skeleton and skeleton mesh are dynamically merged. The relevant content that needs to be dynamically merged is extended and configured in the graph of the animation blueprint, so that the original graph function can be supported under the new merging framework.

[0044] Animation is controlled through an interface and configuration, and based on the configuration, the animation of a specific skeleton mesh is realized.

[0045] Specifically, aligning and merging the skeletal hierarchy, skeletal index, and skeletal binding data of the two bones involves:

[0046] The skeleton merging mechanism is encapsulated as a static method function. This function takes a set of skeleton mesh objects and configuration parameters as input and returns a merged skeleton mesh object. During the merging process, conflicts are checked; if a mismatch is found, relevant information about the mismatch is returned. The merging time is arbitrary, but a general principle is to merge before use. However, because this behavior requires some I / O time, it is recommended to preload the skeleton mesh objects before their intended use. It should be noted that the configuration includes the source skeleton, source skeleton mesh, model material segmentation mapping, UV transformation rules, LOD processing, CPU accessibility, and skeleton update mode.

[0047] It should be noted that the filling in of the missing parts specifically refers to:

[0048] When animation data is missing, the graph supports bones that actually exist in the skeleton but lack relevant data in the animation. It automatically constructs specific bone chains through ControlRig to fill in the animation data (Note: When using fullbodyIk, pay attention to the order of related nodes to prevent out-of-bounds access).

[0049] In this embodiment of the application, the merging method is specifically as follows:

[0050] S1. Read the reference skeleton of Skeletal Mesh to obtain information such as bone hierarchy, index, and binding pose;

[0051] S2. Read the animation sequence and obtain the keyframe data for each bone;

[0052] S3. Pack the animation data into the AnimInstance computing unit;

[0053] S4. Save the skeletal data as a USkeleton resource;

[0054] S5. Align the two skeleton structures, generate a mapping table, unify the hierarchical structure, index, binding pose, etc. of the two skeletons into the same skeleton, and fill in the missing bones.

[0055] S6. Iterate through all animation sequences (which can be the animation libraries of two models respectively); for each Track, use a mapping table to convert the source bone index into the target bone index; write the converted trajectory into a new UAnimSequence (or UAnimComposite).

[0056] At runtime, skeletons and skeleton meshes are dynamically merged, combining two or more skeletal mesh models into a single mesh asset. When model objects with multiple skeletons and different animations need to be mixed, settings allow each object to apply its own effective animation. For data with overlapping skeletons, the posture is determined by configuration. The relevant content requiring dynamic merging is extended and configured in the animation blueprint graph to support the original graph functionality under the new merging framework. Animation control is achieved through interfaces and configurations, implementing animation for a specific skeleton mesh based on the configuration. Specifically, the animation control provides a set of standard functions, which users in the animation blueprint call in the interface and pass parameters to trigger the animation behavior of specific components.

[0057] Use data assets to define the components, mount names, and model references available to roles, and use configuration to drive role composition.

[0058] In this embodiment of the application, the dynamic merging of the skeleton and the skeleton mesh specifically includes the following steps:

[0059] Step 1: Load / obtain the skeleton data, skeleton mesh, and animation sequence of each module of the character;

[0060] Step 2: Align the two sets of skeletal hierarchies, generate a mapping table, and fill in the missing bones;

[0061] Step 3: Create the merged skeleton, unify the skeleton hierarchy, and bind the pose;

[0062] Step 4: Merge the animation tracks and write the keyframes into the new animation sequence according to the mapping table;

[0063] Step 5: Customize the AnimInstance to hold the merged Skeleton and Anim;

[0064] Step Six: Add a "Dynamic Merge" support node to the animation blueprint.

[0065] Step 7: Bind to the skeleton mesh model component at runtime to complete dynamic merging.

[0066] Example 2

[0067] A performance optimization method based on UE5 modular roles, the optimization method includes the following steps:

[0068] Step 1: Create a plugin and write dynamic bone merging code based on mergemesh, including mergemesh usage encapsulation, animation blueprint access registration, and animation node construction. The animation node construction described in this embodiment is specifically: Layered blend By Name, with input parameters: Base Pose, BlendPoses 0, Blend Profile Mask 0, skeleton reference (FSKT1), and BlendWeights 0. Precise blending is performed based on bone names, using the blend profile to control the blending intensity of different bones, and supporting cross-skeleton blending (by specifying the target skeleton via FSKT1).

[0069] Step 2: Write the relevant encapsulation for users. The user's original data is used to identify the required model through data identification. After filtering, adaptation and completion steps, all the data required for the merging is formed.

[0070] Step 3: Write the animation interface to prepare the data framework for the state machine-animation transition;

[0071] Step 4: Inherit the animation interface described in Step 3, and implement the animation of a specific skeleton mesh through configuration;

[0072] Step 5: Under Runtime, select to merge the relevant model data and then select the animation.

[0073] Example 3

[0074] A performance optimization method based on UE5 modular roles, the usage of which includes:

[0075] S1. Start UE5 and enable the mergemesh plugin;

[0076] S2. Import the skeleton mesh;

[0077] S3. Configure the skeleton mesh and mount the registration name;

[0078] S4. Create an animation blueprint, specifying the skeleton and related information of the object;

[0079] S5. At runtime, the blueprint calls the dynamic merge and applies it, specifying the relevant animation.

[0080] Finally, it should be pointed out that the above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in the present invention should be included within the scope of protection of the present invention.

Claims

1. A performance optimization method based on UE5 modular roles, characterized in that, include: The character is divided into multiple modules; Obtain the bone data and animation data of the current module, wrap the animation data of the bones in the UAnimInstance calculation unit, wrap the bone data in the USkeleton file, align and merge the bone hierarchy, bone index and bone binding data of two adjacent skeletons, and fill in the missing parts to generate a skeleton data containing all the information of two adjacent skeletons. At runtime, skeletons and skeleton meshes are dynamically merged. When model objects with multiple skeletons and multiple different animations need to be mixed, each object is set to apply its own effective animation. For data with overlapping parts of the skeleton, the posture is determined by configuration. The relevant content that needs to be dynamically merged is extended and configured in the animation blueprint graph, so that the original graph function is supported under the new merging framework. Animation is controlled through an interface and configuration, and based on the configuration, the animation of a specific skeleton mesh is realized.

2. The performance optimization method based on UE5 modular roles according to claim 1, characterized in that, The process of aligning and merging the skeletal hierarchy, skeletal index, and skeletal binding data of two adjacent skeletons specifically involves: The skeleton merging is encapsulated as a static method function. The function takes a set of skeleton mesh objects and configuration parameter data as input and returns a merged skeleton mesh object. During the merging process, conflicts are checked, and if a mismatch is found, relevant information about the mismatch is returned.

3. The performance optimization method based on UE5 modular roles according to claim 1, characterized in that, The extension and configuration of related support are specifically as follows: The configuration includes source skeleton, source skeleton mesh, model material segmentation mapping, UV transformation rules, LOD processing, CPU accessibility, and skeleton update mode.

4. The performance optimization method based on UE5 modular roles according to claim 1, characterized in that, The filling in of the missing parts specifically refers to: When animation data is missing, the graph supports bones that actually exist in the skeleton but lack relevant data in the animation. It automatically constructs specific bone chains through ControlRig to fill in the animation data.

5. The performance optimization method based on UE5 modular roles according to claim 1, characterized in that, The dynamic merging of the skeleton and skeleton mesh specifically involves merging two or more skeletal mesh models into a single mesh asset.

6. The performance optimization method based on UE5 modular roles according to claim 1, characterized in that, The animation control specifically provides a set of standard functions, which users can trigger the animation behavior of specific components by calling the interface and passing parameters in the animation blueprint.

7. The performance optimization method based on UE5 modular roles according to claim 1, characterized in that, Use data assets to define the components, mount names, and model references available to roles, and use configuration to drive role composition.

8. The performance optimization method based on UE5 modular roles according to claim 1, characterized in that, The character is divided into multiple modules, specifically the modular division of different actions, movements of different parts of the body, and different functions.

9. A performance optimization method based on UE5 modular roles according to claim 1, characterized in that, The optimization method includes the following steps: Step 1: Create a plugin and write dynamic skeleton merging code that depends on mergemesh, including mergemesh usage encapsulation, animation blueprint access registration, and animation node construction; Step 2: Write the relevant encapsulation for users. The user's original data is used to identify the required model through data identification. After filtering, adaptation and completion steps, all the data required for the merging is formed. Step 3: Write the animation interface to prepare the data framework for the state machine-animation transition; Step 4: Inherit the animation interface described in Step 3, and implement the animation of a specific skeleton mesh through configuration; Step 5: Under Runtime, select to merge the relevant model data and then select the animation.

Images