Method and system for realizing animation interactive preview

Abstract

The invention provides a method and a system for realizing animation interactive preview. The method comprises the following steps of: converting skeleton animation data of a role model to be previewed, which is originally processed by a CPU (Central Processing Unit), into a file in a special format for the GPU, loading the file into a GPU cache, and realizing high-efficiency preview and convenient edition and modification of the animation of the role model to be previewed through a four-order dynamic control mechanism (loading / enabling / disabling / removing) of the GPU. And meanwhile, tools such as Maya / PyTorch are losslessly compatible, so that the data integrity of a production chain is guaranteed. According to the technical scheme provided by the invention, the previewed character animation can be flexibly switched between the precision mode and the performance mode, the frame rate can be doubled and improved by a dual-core acceleration architecture of'simple mode agent + GPU calculation ', and finally, the occupation of a video memory is remarkably reduced while the occupation of CPU resources is greatly reduced.

Description

Technical Field

[0001] The technical solution provided in this application relates to the field of 3D animation production technology, specifically to a method and system for realizing interactive preview of animation. Background Technology

[0002] As the 3D animation industry accelerates towards ultra-large-scale character scenes (such as Avatar 2 featuring over 200 characters rendered simultaneously), the conflict between real-time rendering performance and editing flexibility during production is becoming increasingly acute. Traditional character animation preview solutions rely on CPUs to calculate skeletal animation data frame by frame, placing high demands on CPU and other hardware resources. This is especially problematic when multiple characters are on screen simultaneously, often resulting in severe stuttering during real-time preview (e.g., a 10-character scene consumes 1.2GB of video memory). Furthermore, the traditional CPU-based frame-by-frame calculation method results in animation frame rates generally below 5fps (Industrial Light & Magic 2024 data) for scenes with over 100 characters on screen, failing to meet the 24fps cinematic-grade preview requirements. Therefore, the industry is shifting towards GPU-accelerated animation rendering technology.

[0003] While GPU acceleration technology has significantly reduced CPU usage and improved animation rendering efficiency, existing solutions have a fundamental flaw: static baking (such as Maya gpuCache) requires pre-rendering the complete animation sequence, which necessitates freezing the binding data of related character models. Freezing the binding data of each character model means sacrificing editing freedom. Later-developed simplified model proxy technology, while simplifying the model, loses a significant amount of detail and is disconnected from GPU acceleration. In other words, existing character model animation preview solutions cannot balance rendering performance and editing flexibility. For example, sacrificing animation detail to increase frame rate (such as simplified model proxies) results in the loss of keyframe fine-tuning capabilities, while preserving accuracy is limited by CPU computing power (frame rate < 5fps in scenes with 100 characters). Summary of the Invention

[0004] This application combines dynamic GPU caching, fourth-order control, and a two-level collaborative mechanism to provide a technical solution for interactive animation preview. This solution enables computational transfer during rendering (GPU parallelization) and convenient switching to CPU processing during animation data editing and modification. This balances rendering accuracy and performance during character animation preview with real-time animation modification, convenience, and flexibility, ensuring data integrity and lossless compatibility across the 3D animation production chain (Maya / Blender ecosystem).

[0005] The first aspect of this application provides a method for interactive previewing of animation. The method includes: converting the skeletal animation data of the animated character to be previewed into a GPU-dedicated cache format file, and loading the GPU-dedicated cache format file into the GPU cache. By manipulating the dynamic GPU to intervene or exit the animation preview process, the system switches between a first mode and a second mode to achieve interactive previewing of the animated character. The first mode is a GPU computing mode, in which the loaded GPU-dedicated cache format file directly drives the GPU to perform animation rendering. The second mode is a GPU-disabled mode, in which the GPU cache is suspended, related processing is performed by the CPU, and the user can fine-tune the keyframes of the character's animation. The GPU-dedicated cache format file includes files with the .gpuCache extension.

[0006] Furthermore, loading the GPU-specific cache format file includes: calling the simplified model agent to generate a simplified model corresponding to the selected animation character to be previewed, loading the GPU-specific cache format file and the simplified model into the GPU cache, and binding the two together. During character animation preview, GPU-accelerated computation and the simplified model agent work together to achieve collaborative optimization.

[0007] In some embodiments, the skeletal animation data of the character to be previewed is converted into a GPU-specific cache format file, which is then automatically processed / coordinated by a Python script. When the user enables GPU caching, the system first calls a simplified model proxy to generate a simplified model of the character to be previewed, loads the simplified model into the GPU cache, and performs motion control (binding to the GPU-specific cache format file) using the GPU-specific cache format file. Technicians configure the Maya toolkit to ensure compatibility with ADV character rigging tools and commonly used Python packages (such as the pip library), so that the original rigging can be restored without loss after data conversion, avoiding production chain interruptions.

[0008] Furthermore, the step of converting the skeletal animation data of the character to be previewed into a GPU-specific cache format file includes: receiving the skeletal animation data of the character to be previewed from the animation production software; and using a Python script to call the built-in GPU caching function of the animation production software to convert the skeletal animation data of the character to be previewed into a GPU-specific cache format file. The aforementioned animation production software can be Maya, Blender, Unreal Engine / Unity, etc.

[0009] Furthermore, after the interactive preview is complete, the loaded GPU-specific cache format file is cleared, and the original binding data of the corresponding animation character to be previewed is restored.

[0010] Corresponding to the above method, a second aspect of this application also provides a system for implementing interactive animation preview. The system includes: a data conversion module, a data loading module, and a dynamic GPU operation module.

[0011] The data conversion module converts the skeletal animation data of the animated character to be previewed into a GPU-specific cache format file. The data loading module loads this GPU-specific cache format file into the GPU cache. The dynamic GPU operation module provides a corresponding GPU operation interface, allowing the dynamic GPU to intervene in or exit the animation preview process, enabling interactive previewing of the animated character.

[0012] In some embodiments, users can switch between a first mode and a second mode through a corresponding operation interface. The first mode is a GPU parallel computing mode, in which the GPU is directly driven to perform animation rendering by the loaded GPU-specific cache format file; the second mode is a GPU disabled mode, in which the GPU cache is suspended and related processing is performed by the CPU, allowing users to fine-tune the keyframes of the character animation.

[0013] Furthermore, the data loading module generates a simplified model of the corresponding animated character to be previewed by calling the simplified model proxy, loads the GPU-specific cache format file and the simplified model into the GPU cache, and binds the two together.

[0014] Furthermore, the data loading module receives the skeletal animation data of the animated character to be previewed from the animation production software, and uses a Python script to call the built-in GPU caching function of the animation production software to convert the skeletal animation data of the animated character to be previewed into a GPU-specific cache format file.

[0015] Furthermore, the system also includes a data cleaning module; the data cleaning module is used to clear the loaded GPU-specific cache format file and restore the original binding data of the animation character to be previewed after the interactive preview is completed.

[0016] In addition, this application also provides a computer-readable storage medium. The computer-readable storage medium stores a computer program, which, when executed by a computer system, implements the aforementioned method for implementing interactive animation preview.

[0017] The technical solution provided by this invention achieves smooth multi-character simultaneous animation preview through GPU caching, dynamic control, and collaborative optimization, while ensuring the convenience of editing and modifying the previewed character animations. Furthermore, by converting complex character models to GPU processing in the background, users can continue other production work in the foreground without waiting for processing to complete. This parallel processing method not only improves work efficiency but also allows users to make full use of their time resources. Compared with existing technologies, this invention demonstrates significant advantages in improving user experience and work efficiency. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the specific embodiments of this application or the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0019] Figure 1 The flowchart of one embodiment of the method for implementing interactive animation preview provided by the present invention is shown. Detailed Implementation

[0020] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of them. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0021] Therefore, the following detailed description of the embodiments of the invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the invention without inventive effort are within the scope of protection of the invention.

[0022] like Figure 1 In the illustrated embodiment, the method for implementing interactive animation preview provided by this application includes the following steps:

[0023] S1. Obtain the skeletal animation data (such as the character's skeletal motion sequence) of the animated character to be previewed from the animation software. The skeletal animation data of the animated character is used to control the character's movement in each frame. During animation preview, this data typically needs to be processed frame-by-frame by the CPU, consuming significant CPU resources; especially when previewing multiple characters on the same screen, it often causes stuttering. This data can be exported from 3D animation software platforms such as Maya, Unreal Engine, and Blender.

[0024] S2. The skeletal animation data of the character to be previewed is converted into a GPU-specific cache format file and then loaded into the GPU cache. The conversion process involves parsing the bone position, rotation, and scaling information, and encoding it into a GPU-readable format (such as a binary cache file), supporting graphics interfaces such as OpenGL, Vulkan, or DirectX. The GPU-specific cache format file includes files with the .gpuCache extension.

[0025] In some embodiments, the user loads the GPU-specific cache format file into the GPU cache by clicking the "Load Dynamic GPU" button. Further, loading the GPU-specific cache format file includes: calling a simplified model proxy to generate a simplified model corresponding to the selected animated character to be previewed; loading the GPU-specific cache format file and the simplified model into the GPU cache and binding them together. During character animation preview, GPU-accelerated computation and the simplified model proxy work together to achieve collaborative optimization. The simplified model proxy first simplifies the face count of the character model (e.g., reducing geometric details), reducing model complexity and GPU memory usage (in actual testing, the GPU memory usage for a 10-character scene decreased from 1.2GB to 240MB). The GPU then processes the simplified character model data during subsequent previews. With both working together, a consumer-grade graphics card (such as an NVIDIA GeForce GTX 1660Ti) can smoothly render more than 50 characters on screen simultaneously.

[0026] The above conversion process can be automated by a Python script calling Maya's built-in GPUCache function. Technicians specify the animation range (e.g., from the start frame to the end frame), and the Python script automatically converts the acquired skeletal animation data of the preview character into a GPU-dedicated cache format file. This GPU-dedicated cache format file can be stored on the local machine, ensuring it can be regenerated each time the animation is updated (avoiding data expiration). In this way, the parallel processing capabilities of the GPU can replace the serial computation of the CPU during the preview of the animated character, significantly reducing the consumption of CPU resources.

[0027] S3. By manipulating the dynamic GPU to intervene in or exit the animation preview process, interactive previewing of the animated character to be previewed is achieved. In some embodiments, this step can provide a user interface (integrated into the Maya toolkit) that allows animators to manage the GPU cache through operation interfaces such as "Enable Dynamic GPU" and "Disable Dynamic GPU". When the user clicks the "Enable Dynamic GPU" button, the system switches to GPU parallel computing mode, and the loaded GPU-specific cache format file is activated. In this mode, the loaded GPU-specific cache format file directly drives the GPU to render the animation, resulting in a smooth animation preview but preventing modification of details. When the user needs to easily modify animation details, they can click the "Disable Dynamic GPU" button to switch the system back to GPU-disabled mode. In GPU-disabled mode, the GPU cache is paused, and related processing is performed by the CPU, allowing users to fine-tune keyframes (such as modifying bone positions).

[0028] S4. After the interactive preview is complete, clear the loaded GPU-specific cache format file and restore the original binding data of the animated character to be previewed. In some embodiments, the user can click the "Remove Dynamic GPU" button to clear the loaded GPU-specific cache format file and restore the original binding data of the character to ensure data integrity.

[0029] Corresponding to the above-described method for implementing interactive animation preview, this application also provides a system for implementing interactive animation preview. The system includes: a data conversion module, a data loading module, and a dynamic GPU operation module.

[0030] The data conversion module is used to convert the skeletal animation data of the animated character to be previewed into a GPU-specific cache format file. Furthermore, the data loading module is also used to receive the skeletal animation data of the animated character to be previewed from the animation production software, and use a Python script to call the built-in GPU caching function of the animation production software to convert the skeletal animation data of the animated character to be previewed into a GPU-specific cache format file.

[0031] The data loading module is used to load the GPU-specific cache format file into the GPU cache. In some embodiments, the data loading module generates a simplified model of the corresponding animation character to be previewed by calling a simplified model proxy, loads the GPU-specific cache format file and the simplified model into the GPU cache, and binds the two together.

[0032] The dynamic GPU operation module provides a corresponding GPU operation interface, enabling the dynamic GPU to intervene in or exit the animation preview process, thus achieving interactive previewing of the animated character. In some embodiments, users can switch between a first mode and a second mode through the corresponding operation interface. The first mode is a GPU parallel computing mode, where the GPU is directly driven to render the animation using a loaded GPU-specific cache format file, resulting in smooth but uneditable animation. The second mode is a GPU disabled mode, where the GPU cache is suspended, and related processing is performed by the CPU, allowing users to fine-tune the keyframes of the character animation.

[0033] Furthermore, the system also includes a data cleaning module; the data cleaning module is used to clear the loaded GPU-specific cache format file and restore the original binding data of the animation character to be previewed after the interactive preview is completed.

[0034] In addition, this application also provides a computer-readable storage medium. The computer-readable storage medium stores a computer program, which, when executed by a computer system, implements the aforementioned method for implementing interactive animation preview.

[0035] The technical solution provided by this invention converts the skeletal animation data of the character to be previewed into a specific format file that can be directly read and processed by the GPU during the animation preview process. This specific format file is loaded into the GPU cache and a dynamic GPU management mechanism is introduced. Combined with simplified model proxy technology, this effectively improves the efficiency and smoothness of multi-character simultaneous preview and reduces CPU resource consumption. More importantly, the above technical solution also ensures the flexibility of editing and modifying animation details during the animation preview process. Furthermore, by placing the complex character skeletal animation data and simplified model generation in the background, it does not affect the user's ability to continue other production work in the foreground, significantly improving work efficiency.

[0036] The above description is merely a preferred embodiment of this application and is not intended to limit this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the protection scope of this application. It should be noted that similar reference numerals and letters in the following figures indicate similar items; once an item is defined in one figure, it does not need further definition and explanation in subsequent figures.

Claims

1. A method of enabling an animated interactive preview, the method comprising: The method comprises: converting bone animation data of an animation character to be previewed into a GPU special cache format file, and loading the GPU special cache format file into a GPU cache; and switching the system between a first mode and a second mode by operating dynamic GPU intervention or exit of an animation preview process, to realize interactive preview of the animation character to be previewed; wherein the first mode is a GPU parallel computing mode, in which the loaded GPU special cache format file directly drives the GPU to perform animation rendering; and the second mode is a GPU disabled mode, in which the GPU cache is suspended from use, and relevant processing is performed by a CPU, to allow a user to finely adjust key frames of a character animation.

2. The method of claim 1, wherein, The loading of the GPU special cache format file comprises: calling a simplified model agent to generate a simplified model corresponding to the animation character to be previewed, and loading the GPU special cache format file and the simplified model into the GPU cache and binding the two.

3. The method of claim 1 or 2, wherein, The conversion of the bone animation data of the animation character to be previewed into the GPU special cache format file comprises: receiving bone animation data of the animation character to be previewed from animation production software; and calling a GPU cache function built in the animation production software by using a Python script, to convert the bone animation data of the animation character to be previewed into the GPU special cache format file.

4. The method of claim 1 or 2, wherein, The method further comprises: after the interactive preview is completed, clearing the loaded GPU special cache format file, and restoring original binding data of the corresponding animation character to be previewed.

5. The method of claim 3, wherein, The GPU special cache format file comprises a file with a suffix of.gpuCache.

6. A system for enabling animated interactive previews, the system comprising: The system comprises: a data conversion module, a data loading module, and a dynamic GPU operation module. The data conversion module is configured to convert bone animation data of an animation character to be previewed into a GPU special cache format file. The data loading module is configured to load the GPU special cache format file into a GPU cache. The dynamic GPU operation module provides a corresponding GPU operation interface, so that dynamic GPU intervention or exit of an animation preview process is enabled to switch the system between a first mode and a second mode, to realize interactive preview of the animation character to be previewed. The first mode is a GPU parallel computing mode, in which the loaded GPU special cache format file directly drives the GPU to perform animation rendering; and the second mode is a GPU disabled mode, in which the GPU cache is suspended from use, and relevant processing is performed by a CPU, to allow a user to finely adjust key frames of a character animation.

7. The system of claim 6, wherein, The data loading module calls a simplified model agent to generate a simplified model corresponding to the animation character to be previewed, and loads the GPU special cache format file and the simplified model into the GPU cache and binds the two.

8. The system of claim 6 or 7, wherein, The data loading module receives bone animation data of the animation character to be previewed from animation production software, and calls a GPU cache function built in the animation production software by using a Python script, to convert the bone animation data of the animation character to be previewed into the GPU special cache format file.

9. The system of claim 6, wherein, The system further comprises a data cleaning module; the data cleaning module is used for cleaning the loaded GPU special cache format file and restoring original binding data of the animation character to be previewed after the interaction preview is completed.

10. A computer-readable storage medium, characterized in that, The computer readable storage medium stores a computer program, and the computer program is executed by a computer system to implement the method for realizing animation interaction preview in any one of claims 1-5.

Images