Three-dimensional rendering system and method for animated images

Abstract

The application provides a three-dimensional rendering system and method for animation images, and relates to the technical field of animation rendering. The system comprises a sub-task set obtaining module, a cluster computer configuration module, a cluster rendering task determining module and a rendered animation generating module. The sub-task set obtaining module is used for receiving a rendering task and obtaining a sub-task set according to the rendering task. The cluster computer configuration module is used for configuring a cluster computer according to the sub-task set through a central dispatcher. The cluster rendering task determining module is used for determining a cluster rendering task according to a cluster computer configuration result. The rendered animation generating module is used for executing the cluster rendering task through the cluster computer and generating a rendered animation by merging. The application can solve the technical problem that, in the prior art, long-time operation of a computer is required for animation rendering, which results in low rendering efficiency, resource waste and further influences the rendering effect, achieves the technical target of improving the rendering efficiency and achieves the technical effect of improving the rendering effect.

Description

Technical Field

[0001] This application relates to the field of animation rendering technology, and more particularly to a three-dimensional rendering system and method for animated images. Background Technology

[0002] 3D animation is a type of digital video that uses computer software to simulate the properties of real objects and output their motion.

[0003] Currently, existing animation rendering processes require computers to perform long-term calculations, resulting in significant consumption of electricity and hardware resources. Furthermore, if there is no effective task scheduling and resource management during the rendering process, even if the computer is continuously computing, there may be improper use of resources or uneven task allocation, leading to low rendering efficiency.

[0004] In summary, existing technologies suffer from the technical problem that animation rendering requires prolonged computer computation, resulting in low rendering efficiency, wasted resources, and further impacting rendering quality. Summary of the Invention

[0005] The purpose of this application is to provide a 3D rendering system and method for animation images, in order to solve the technical problem in the prior art that animation rendering requires long-term computer computation, resulting in low rendering efficiency, wasted resources, and further affecting the rendering effect.

[0006] In view of the above problems, this application provides a three-dimensional rendering system and method for animated images.

[0007] In a first aspect, this application provides a 3D rendering system for animated images, wherein the system comprises: a subtask set acquisition module, configured to receive rendering tasks and decompose the rendering tasks to obtain a subtask set; a cluster computer configuration module, configured to configure cluster computers according to the subtask set via a central scheduler; a cluster rendering task determination module, configured to determine cluster rendering tasks based on the cluster computer configuration results; and a rendering animation generation module, configured to execute the cluster rendering tasks via the cluster computers and merge them to generate a rendering animation.

[0008] Secondly, this application provides a three-dimensional rendering method for animated images, which is implemented by a three-dimensional rendering system for animated images. The method includes: receiving a rendering task and decomposing the rendering task into a set of subtasks; configuring a cluster computer according to the set of subtasks through a central scheduler; determining a cluster rendering task based on the cluster computer configuration result; and executing the cluster rendering task through the cluster computer to generate a rendered animation.

[0009] One or more technical solutions provided in this application have at least the following technical effects or advantages: By receiving rendering tasks and decomposing them into subtask sets, a central scheduler configures cluster computers based on the subtask sets, determines cluster rendering tasks based on the cluster computer configuration results, and executes the cluster rendering tasks through the cluster computers to generate rendering animations. In other words, through optimized cluster rendering, the technical goal of improving rendering efficiency is ultimately achieved, resulting in improved rendering effects.

[0010] The above description is merely an overview of the technical solution of this application. To better understand the technical means of this application and to facilitate its implementation according to the description, and to make the above and other objects, features, and advantages of this application more apparent, specific embodiments of this application are described below. It should be understood that the content described in this section is not intended to identify key or important features of the embodiments of this application, nor is it intended to limit the scope of this application. Other features of this application will become readily apparent through the following description. Attached Figure Description

[0011] To more clearly illustrate the technical solutions in this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are merely exemplary. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0012] Figure 1 This is a schematic diagram of the structure of the 3D rendering system for animated images used in this application; Figure 2 This is a flowchart illustrating the three-dimensional rendering method for animated images used in this application.

[0013] Explanation of reference numerals in the attached figures: Subtask set acquisition module 11, cluster computer configuration module 12, cluster rendering task determination module 13, and rendering animation generation module 14. Detailed Implementation

[0014] This application provides a 3D rendering system and method for animated images, solving the technical problem in existing technologies where animation rendering requires long-term computer computation, resulting in low rendering efficiency, wasted resources, and further impacting rendering quality. It achieves the technical goal of improving rendering efficiency and thus enhances rendering effects.

[0015] The technical solutions of this application will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. It should be understood that this application is not limited to the exemplary embodiments described herein. All other embodiments obtained by those skilled in the art based on the embodiments of this application without creative effort are within the scope of protection of this application. It should also be noted that, for ease of description, only the parts related to this application are shown in the accompanying drawings, not all of them.

[0016] Example 1: Please see the appendix Figure 1 This application provides a 3D rendering system for animated images, wherein the system specifically includes the following steps: Subtask set acquisition module 11 is used to receive rendering tasks and obtain subtask sets according to the rendering tasks. Cluster computer configuration module 12 is used to configure the cluster computer according to the subtask set through a central scheduler; Cluster rendering task determination module 13 is used to determine cluster rendering tasks based on the cluster computer configuration results; The rendering animation generation module 14 is used to execute the cluster rendering task through the cluster computer and merge to generate rendering animation.

[0017] Furthermore, the cluster computer configuration module 12 in the system is also used for: Determine rendering requirements and acquire the necessary resources; Based on the rendering requirements, perform cluster computer load matching to obtain a matching computer; The matching computer performs task allocation.

[0018] Furthermore, the cluster computer configuration module 12 in the system is also used for: The central scheduler monitors the load of the cluster computers, obtains the balanced load, filters out idle computers with loads less than the balanced load, and extracts the rendering resources of the idle computers. The rendering resource requirements of the idle computer are extracted based on the sub-task set, and it is determined whether the rendering resource requirements of the sub-task set match the rendering resource requirements of the idle computer. If the rendering resources of the idle computer match, the matching computer is generated.

[0019] Furthermore, the cluster rendering task determination module 13 in the system is also used for: Based on the set of subtasks, determine the scheduling dependencies; Extract subtasks from the scheduling dependencies to generate graph nodes, generate graph edges based on the scheduling dependencies, and construct a directed acyclic graph by combining the graph nodes and graph edges. Sort the directed acyclic graph to generate the task execution order; The subtask allocation is performed according to the task execution order to determine the cluster rendering task.

[0020] Furthermore, the cluster rendering task determination module 13 in the system is also used for: Initialize the task weights of the subtask set; Calculate the upward ranking value for each subtask in the directed acyclic graph, and determine the task priority based on the upward ranking value; The task execution order is constructed based on the task priority.

[0021] Furthermore, the rendering animation generation module 14 in the system is also used for: Determine the rendering requirements and rendering resource requirements. If the rendering resource requirements meet the task resource threshold, invoke the parallel channel of the cluster computer to execute task replication. Based on the replication task, task scheduling is completed and the tasks are allocated to the cluster computers.

[0022] Furthermore, the rendering animation generation module 14 in the system is also used for: The central scheduler monitors the load of the cluster computers, obtains the balanced load, filters idle computers with loads less than the balanced load, and extracts monitoring records based on the idle computers. Based on the monitoring records, the idle computer is invoked to render the timeline, and the defective computer is obtained; The parallel channels of the cluster computers are invoked to schedule and allocate defective subtasks according to the defective computer.

[0023] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. The 3D rendering system and specific examples for animated images are also applicable to the 3D rendering method for animated images in this embodiment, so for the sake of brevity, they will not be described in detail here. As the system disclosed in the embodiments corresponds to the method disclosed in the embodiments, the description is relatively simple; relevant details can be found in the method section.

[0024] Example 2: This application provides a 3D rendering method for animated images; please refer to the appendix. Figure 2 The method includes: Step 1: Receive the rendering task and decompose it into a set of subtasks.

[0025] Specifically, when a rendering task is received, its complexity and requirements are first analyzed. Based on these requirements, it is broken down into multiple subtasks, each of which can be executed independently and processed in parallel. For example, a complex 3D animation rendering may involve multiple scenes, multiple camera angles, or multiple frames, each of which can be considered a subtask.

[0026] Step 2: Configure the cluster computers according to the subtask set through the central scheduler.

[0027] Specifically, the central scheduler is the core of the cluster rendering system, responsible for managing and allocating resources. Upon receiving a set of subtasks, the central scheduler evaluates the performance, load, and availability of each computer in the cluster. Based on the evaluation information, the central scheduler selects the most suitable computing resources for each subtask, thus forming a cluster computer configuration for executing the set of subtasks.

[0028] Step 3: Determine the cluster rendering tasks based on the cluster computer configuration results.

[0029] Specifically, after determining the cluster computer configuration, subtasks are assigned to the computers in the cluster based on the configuration results. Once assigned, the tasks on each computer constitute part of the cluster rendering task. The tasks will be executed in parallel according to the scheduler's instructions to improve the overall rendering efficiency.

[0030] Step 4: Execute the cluster rendering task through the cluster computer and merge to generate the rendering animation.

[0031] Specifically, each computer in the cluster begins executing its assigned subtask. These subtasks may include scene rendering, effects calculation, and image compositing. Once all subtasks are complete, the rendering results are merged into a single, complete rendered animation. The merging process may involve steps such as image stitching, timeline alignment, and color correction to ensure the quality and consistency of the final rendered animation.

[0032] The aforementioned 3D rendering for animated images can achieve the technical goal of improving rendering efficiency and thus enhance rendering effects.

[0033] Furthermore, this application also includes: Determine rendering requirements and acquire rendering resources; perform cluster computer load matching based on the rendering resources to acquire matching computers; perform task allocation based on the matching computers.

[0034] Specifically, before starting rendering, it's essential to clarify the specific rendering requirements, such as scene complexity, expected rendering quality, required effects, and post-processing. Based on these requirements, the necessary computing resources need to be determined, including CPU, GPU, memory, and storage space. Resource requirements depend on the scale and complexity of the rendering. These resources are obtained by querying existing computing resource libraries or communicating with resource providers.

[0035] Then, each computer in the cluster has different performance and load status. To maximize rendering efficiency, computers in the cluster are matched according to the rendering demand resources. The load matching process typically involves evaluating the performance of each computer (such as CPU speed, GPU model and number, memory size, etc.) and its current load status (such as CPU and GPU utilization, memory usage, etc.). By comparing the rendering demand resources with the performance and load status of the cluster computers, the set of computers best suited to perform the current rendering task can be identified, and this set is called the matched computers.

[0036] Next, once the matching computers are identified, rendering tasks need to be assigned to them. Task assignment can be performed using various strategies, such as load balancing, priority ranking, and task dependencies. Load balancing ensures that the workload is evenly distributed across the computers in the cluster, while priority ranking determines the execution order based on the urgency and importance of tasks. The result of task assignment is typically a detailed schedule, specifying the subtasks to be executed on each computer, their start and end times, etc. After task assignment, the relevant information is sent to the matching computers to initiate the execution of the rendering tasks. The subtasks will be processed, and the results will be returned to the system.

[0037] By continuously monitoring the cluster's status and performance, and adjusting task allocation and load matching strategies as needed, the stability and reliability of the rendering process are ensured.

[0038] Furthermore, this application also includes: The central scheduler monitors the load of the cluster computers and obtains a balanced load. It then filters idle computers with loads less than the balanced load and extracts their rendering resources. Based on the sub-task set, it extracts the rendering resource requirements of the idle computers and determines whether the rendering resource requirements of the sub-task set match the rendering resource requirements of the idle computers. If they match, it generates the matching computer.

[0039] Specifically, the central scheduler continuously monitors the load of each computer in the cluster. The load may include multiple aspects such as CPU utilization, memory usage, and network bandwidth. By collecting and analyzing load data, the central scheduler can calculate a balanced load value, representing the ideal load state of the computers in the cluster, aiming to maximize resource utilization and balance task distribution.

[0040] Then, based on the monitored load data, the central scheduler filters out computers whose current load is below the load balancer. These filtered computers are considered to have additional processing power and can handle more rendering tasks. These computers are called idle computers; although they may still be performing other tasks, their load levels indicate their ability to handle additional rendering work.

[0041] Next, for the selected idle computers, the central scheduler will further extract rendering resource information. This may include the number of CPU cores, GPU model and quantity, memory capacity, available storage, etc., which is crucial for subsequent resource matching and task allocation.

[0042] Next, the central scheduler analyzes the set of subtasks to be assigned and extracts the rendering resource requirements for each subtask. The resource requirements may vary from task to task; for example, some tasks may require more CPU computing power, while others may rely on powerful GPU processing power.

[0043] The central scheduler then compares the rendering resource requirements of the subtasks with the actual rendering resources of the idle computers. This matching process ensures that each subtask is assigned to a computer with sufficient resources, thereby guaranteeing efficient execution of the rendering tasks.

[0044] Next, if the rendering resources of an idle computer match the rendering requirements of a subtask, then the computer is considered a matched computer. Once a matched computer is determined, the central scheduler can proceed with the next step of task allocation.

[0045] By recognizing the importance of resource matching and task allocation, dynamic resource management and task allocation mechanisms can significantly improve resource utilization and rendering efficiency in clustered rendering environments.

[0046] Furthermore, this application also includes: Based on the set of subtasks, determine the scheduling dependencies; extract the subtasks from the scheduling dependencies to generate graph nodes, generate graph edges based on the scheduling dependencies, and construct a directed acyclic graph by combining the graph nodes and graph edges; sort the directed acyclic graph to generate a task execution order; perform subtask allocation according to the task execution order to determine the cluster rendering task.

[0047] Specifically, in cluster rendering, subtasks may have dependencies on each other. For example, the output of one subtask may be the input of another, or some subtasks may need to wait for other subtasks to complete before they can begin. Analyze the set of subtasks to determine the scheduling dependencies between them.

[0048] Then, each subtask is treated as a node in a directed acyclic graph (DAG), i.e., a graph node. Based on the scheduling dependencies between subtasks, edges of the DAG are generated, i.e., graph edges. Graph edges represent the execution order and dependencies between subtasks.

[0049] Next, using the extracted constituent graph nodes and edges, a complete directed acyclic graph (DAG) is constructed. The DAG represents all subtasks and their dependencies and execution order.

[0050] Next, a topological sort is performed on the constructed directed acyclic graph. Topological sorting is an algorithm that performs a linear sort on a directed acyclic graph, outputting a linear sequence such that for any pair of nodes U and V in the graph, if a path exists from U to V, then U always appears before V in the sequence. The result of topological sorting is a task execution order, indicating the order in which subtasks should be executed.

[0051] After obtaining the task execution order, the system can then begin subtask allocation. Based on the performance, load, and availability of the computers in the cluster, as well as the resource requirements of the subtasks, the system assigns subtasks to suitable computers. Once the subtask allocation is complete, the computers in the cluster begin rendering work according to the assigned task execution order, thus completing the determination and execution of the cluster rendering tasks.

[0052] By constructing and sorting a directed acyclic graph, it is ensured that subtasks are executed in the correct order and according to their dependencies, thereby improving the efficiency and accuracy of cluster rendering.

[0053] Furthermore, this application also includes: Initialize the task weights of the subtask set; calculate the upward ranking value for each subtask in the directed acyclic graph, determine the task priority based on the upward ranking value; and construct the task execution order according to the task priority.

[0054] Specifically, for each subtask, an initial weight is assigned based on its importance, complexity, required resources, and other factors, representing the relative importance of the task in the scheduling process.

[0055] The upward rank is a metric used to measure the importance of nodes in a directed acyclic graph (DAG). It is typically calculated bottom-up, considering the longest path from a node to all its successors. When calculating the upward rank, an initial value is assigned to each node, starting with the exit node of the DAG. Then, for each node, the upward rank values ​​of all its successors are summed with their weights, and the result is used as the upward rank value for that node. This process is repeated until the upward rank values ​​for all nodes have been calculated.

[0056] Next, once the upward ranking values ​​of all subtasks have been calculated, task priorities can be determined based on these values. Tasks with higher upward ranking values ​​have higher priorities because they have a greater impact on subsequent tasks, and vice versa.

[0057] Next, after determining the priority of each task, the task execution order is constructed. This can be achieved in various ways, such as using a priority queue or heap data structure to maintain tasks and performing dequeue operations based on priority. Since tasks in a directed acyclic graph have dependencies, these dependencies must also be considered when constructing the execution order. Specifically, a task can only begin execution after all its predecessor tasks have been completed. Therefore, when dequeuing tasks, it is necessary to ensure that all its predecessor tasks have been executed or scheduled into the execution plan. By continuously retrieving tasks from the priority queue and checking the status of their predecessor tasks, a task execution plan that satisfies all dependencies and is arranged in priority order can be generated.

[0058] By ensuring that tasks are executed in a logical order in a clustered rendering environment, rendering efficiency and quality are improved.

[0059] Furthermore, this application also includes: Determine the rendering requirements and rendering resource requirements. If the rendering resource requirements meet the task resource threshold, invoke the parallel channel of the cluster computer to execute task copying. Complete task scheduling based on the copied task and allocate it to the cluster computer.

[0060] Specifically, the rendering requirements must be clearly defined, including scene complexity, expected rendering quality, required effects, and post-processing. Next, based on these requirements, the necessary computing resources, such as CPU, GPU, memory, and storage space, must be determined. These resource requirements depend on the scale and complexity of the rendering process.

[0061] Then, before assigning tasks, the rendering resource requirements are compared with the total amount of available resources in the cluster to assess whether the current cluster computers have sufficient resources to meet the rendering needs. A task resource threshold is set, representing the minimum or maximum resource requirement that the cluster can handle. If the rendering resource requirements exceed this threshold, other solutions may need to be considered, such as waiting for more resources to be released or increasing the cluster size. If the rendering resource requirements meet the task resource threshold, the next step can proceed.

[0062] Next, cluster computers typically have multiple processors, GPUs, or other computing units that can process multiple tasks in parallel. To fully utilize these resources, the cluster's parallel channels can be invoked to duplicate the rendering task into multiple subtasks. The goal of task duplication is to break down the original task into multiple smaller, parallelizable subtasks. These subtasks can be assigned to different computers within the cluster or to different processors on the same computer. Task duplication improves overall processing efficiency because multiple subtasks can be performed concurrently, rather than sequentially.

[0063] Next, once the task is replicated into multiple subtasks, task scheduling is required to distribute these subtasks to the computers in the cluster for processing. Based on the computers' performance, load, availability, and the needs and dependencies of the subtasks, the task scheduler is responsible for determining which subtasks each computer should handle. The task scheduler also needs to ensure that the workload is evenly distributed among the computers in the cluster, avoiding overload of some computers while others are idle, based on load balancing. The task scheduler generates a task allocation plan and assigns the subtasks to the appropriate computers for execution. These computers will process the subtasks in parallel and merge the results to complete the entire rendering task.

[0064] Improve rendering efficiency and speed by ensuring that available resources are fully utilized in a clustered rendering environment.

[0065] Furthermore, this application also includes: The central scheduler monitors the load of the cluster computers and obtains a balanced load. It then filters idle computers with loads less than the balanced load and extracts monitoring records from the idle computers. Based on the monitoring records, it calls the idle computers to render timeliness and obtains defective computers. Finally, it calls the parallel channels of the cluster computers and schedules and allocates defective subtasks based on the defective computers.

[0066] Specifically, the central scheduler continuously monitors the load of each computer in the cluster, including performance metrics such as CPU utilization and memory usage. Based on the monitoring data, the central scheduler calculates the balanced load of the cluster. The balanced load is the ideal load level for the cluster to maintain efficient operation, and it is set based on the overall performance and resource utilization of the cluster.

[0067] Then, among all the monitored computers, the central scheduler filters out computers whose current load is lower than the load balancer and considers them as idle computers with additional processing power to handle more rendering tasks.

[0068] Next, for the selected idle computers, the central scheduler further extracts monitoring records. These records include key information such as performance data, fault history, and maintenance records of the idle computers over a period of time.

[0069] Next, the central scheduler analyzes the monitoring records of idle computers to extract rendering timeliness. Rendering timeliness refers to the time required for a computer to complete a rendering task, reflecting the computer's actual rendering performance. If the rendering timeliness of an idle computer is found to be significantly lower than the cluster average or historical records, the computer is marked as a defective computer. Defective computers may experience performance degradation due to hardware aging, software problems, or improper configuration.

[0070] Then, after identifying the defective computer, the central scheduler invokes the cluster's parallel channels to reschedule and allocate tasks. Parallel channels allow the central scheduler to process multiple task scheduling requests simultaneously, ensuring rapid task response and efficient allocation. For defective subtasks on the defective computer—subtasks originally assigned to that computer but failing to complete on time due to performance issues—the central scheduler will reassign them to other idle computers. During the allocation process, the central scheduler considers the subtask's dependencies, resource requirements, and the target computer's load and performance to ensure tasks are executed in the correct order and with optimal resource utilization.

[0071] The central scheduler can promptly identify and resolve performance bottlenecks within the cluster, ensuring efficient cluster operation and successful completion of rendering tasks. Simultaneously, it can fully utilize idle resources within the cluster, improving overall resource utilization and rendering efficiency.

[0072] In summary, the 3D rendering method for animated images provided in this application has the following technical effects: By receiving rendering tasks and decomposing them into subtask sets, a central scheduler configures cluster computers based on the subtask sets, determines cluster rendering tasks based on the cluster computer configuration results, and executes the cluster rendering tasks through the cluster computers to generate rendering animations. In other words, through optimized cluster rendering, the technical goal of improving rendering efficiency is ultimately achieved, resulting in improved rendering effects.

[0073] The above description of the disclosed embodiments enables those skilled in the art to make or use this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Therefore, this application is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

[0074] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application. Therefore, if such modifications and variations fall within the scope of this application and its equivalents, this application also intends to include such modifications and variations.

Claims

1. A three-dimensional rendering system for animated images, characterized in that, The system includes: The subtask set acquisition module is used to receive rendering tasks and obtain subtask sets based on the rendering tasks. A cluster computer configuration module is used to configure the cluster computer according to the subtask set through a central scheduler; The cluster rendering task determination module is used to determine the cluster rendering task based on the cluster computer configuration results. The rendering animation generation module is used to execute the cluster rendering task through the cluster computers and merge the results to generate a rendering animation. The cluster rendering task determination module is used for: Based on the set of subtasks, determine the scheduling dependencies; Extract subtasks from the scheduling dependencies to generate graph nodes, generate graph edges based on the scheduling dependencies, and construct a directed acyclic graph by combining the graph nodes and graph edges. Sort the directed acyclic graph to generate the task execution order; The subtask allocation is performed according to the task execution order to determine the cluster rendering task; The animation generation module is also used for: The central scheduler monitors the load of the cluster computers, obtains the balanced load, filters idle computers with loads less than the balanced load, and extracts monitoring records based on the idle computers. Based on the monitoring records, the idle computer is invoked to render the timeline, and the defective computer is obtained; The parallel channels of the cluster computers are invoked to schedule and allocate defective subtasks according to the defective computer.

2. The system as described in claim 1, characterized in that, The cluster computer configuration module is used for: Determine rendering requirements and acquire the necessary resources; Based on the rendering requirements, perform cluster computer load matching to obtain a matching computer; The matching computer performs task allocation.

3. The system as described in claim 2, characterized in that, The cluster computer configuration module is also used for: The central scheduler monitors the load of the cluster computers, obtains the balanced load, filters out idle computers with loads less than the balanced load, and extracts the rendering resources of the idle computers. The rendering resource requirements of the idle computer are extracted based on the sub-task set, and it is determined whether the rendering resource requirements of the sub-task set match the rendering resource requirements of the idle computer. If the rendering resources of the idle computer match, the matching computer is generated.

4. The system as described in claim 1, characterized in that, The cluster rendering task determination module is also used for: Initialize the task weights of the subtask set; Calculate the upward ranking value for each subtask in the directed acyclic graph, and determine the task priority based on the upward ranking value; The task execution order is constructed based on the task priority.

5. The system as described in claim 1, characterized in that, The rendering animation generation module is used for: Determine the rendering requirements and rendering resource requirements. If the rendering resource requirements meet the task resource threshold, invoke the parallel channel of the cluster computer to execute task replication. Based on the replication task, task scheduling is completed and the tasks are allocated to the cluster computers.

6. A three-dimensional rendering method for animated images, characterized in that, The method is applied to the system according to any one of claims 1 to 5, and the method comprises: Receive a rendering task and decompose the rendering task to obtain a set of subtasks; The cluster computers are configured according to the subtask set via a central scheduler; Based on the cluster computer configuration results, determine the cluster rendering tasks; The cluster rendering task is executed by the cluster computer, and the rendered animation is generated by merging the results.

Images