A three-dimensional animation editing system and method based on recording and visual programming

Abstract

The application relates to the technical field of computer graphics processing, and discloses a three-dimensional animation editing system and method based on recording and visual programming, which comprises the following steps: obtaining a target object in a three-dimensional editing scene and a recording trigger instruction, collecting transformation data to generate recording animation data; encapsulating the recording animation data into an animation behavior unit containing a motion time axis, an object identifier, a playing parameter item and an animation output item; generating a corresponding motion node in a visual programming interface, and generating an animation logic diagram according to the connection relationship among an event node, a condition node and the motion node; triggering animation playing according to the logic diagram during preview execution, and outputting a playing progress, an event marker or an animation attribute value for use by subsequent logic nodes during the playing process. The application can realize the fusion of animation recording and visual logic programming, support animation data-driven logic states, reduce the creation threshold of three-dimensional interactive content and improve development efficiency.

Description

Technical Field

[0001] This invention relates to the field of computer graphics processing technology, and more specifically, to a three-dimensional animation editing system and method based on recording and visual programming. Background Technology

[0002] Current 3D animation editing typically employs methods such as keyframe animation, animation curves, skeletal rigging, physical simulation, script control, or workflow control. In keyframe animation, editors need to set the position, rotation, scaling, or other attributes of 3D objects at different points in time on the timeline, and then interpolate to create continuous animation. In script control or workflow control, editors can organize the playback order, trigger conditions, and state transitions of animation segments. While these methods can accomplish the production and control of conventional 3D animation, the creation of animation motion content and the editing of interactive control logic are usually separate processes, requiring repeated adjustments to motion, configuration of logic, and previewing during the editing process.

[0003] For example, Chinese patent CN116152398B discloses a 3D animation control method, device, equipment, and storage medium. The method includes: obtaining target 3D animation requirements; breaking down the target 3D animation requirements into several sub-processes; parsing each sub-process to obtain the model control logic contained in each sub-process; generating a model control logic list for the target animation based on the relationships between each sub-process; and controlling the corresponding model to execute animation actions based on the model control logic list to obtain the target 3D animation. This solution controls 3D animation through requirement breakdown and model control logic lists, improving the efficiency of 3D animation generation and the ease of modification. However, this type of solution mainly focuses on forming model control logic based on 3D animation requirements and organizing the execution process of model actions through model control logic. When editing interactive 3D animations, the animation action content and interactive control logic still need to be processed separately, and the correspondence between the two needs to be repeatedly confirmed during editing, configuration, and previewing, which can easily lead to insufficient connection between the animation action content and the interactive control logic.

[0004] Therefore, it is necessary to improve existing 3D animation editing technology to solve the problem of insufficient connection between animation action content and interactive control logic during the 3D animation editing process. Summary of the Invention

[0005] The purpose of this invention is to provide a 3D animation editing system and method based on recording and visualization programming, in order to solve the above-mentioned problems.

[0006] On one hand, this invention provides a 3D animation editing method based on recording and visual programming, including: The system acquires the target object and recording trigger command in the 3D editing scene, collects the transformation data of the target object during the recording period, and generates recording animation data associated with the target object. Based on the recorded animation data, determine the action timeline, object identifier, playback parameter items, and animation output items, and encapsulate the recorded animation data into animation behavior units; In the visual programming interface, an action node corresponding to the animation behavior unit is generated. The action node includes a parameter port corresponding to the playback parameter item and an output port corresponding to the animation output item. Obtain the connection relationships between event nodes, condition nodes, and action nodes, and generate an animation logic diagram based on the connection relationships; During preview execution, the target action node to be triggered is determined according to the animation logic diagram, the animation behavior unit corresponding to the target action node and the parameter value of the parameter port are read, and the target object is controlled to play the animation according to the recorded animation data; During animation playback, playback progress, event markers, or animation attribute values ​​are output according to the animation output items, and the playback progress, event markers, or animation attribute values ​​are provided to subsequent nodes connected to the output port in the animation logic diagram.

[0007] Furthermore, when generating the recorded animation data associated with the target object, the process includes: According to the recording sampling frequency, the position data, rotation data and scaling data of the target object are continuously acquired during the recording period; Using the sampling time as an index, the position data, rotation data, and scaling data at the same sampling time are written into the sampling record; Animation curves are generated based on the continuity of transformation between adjacent sampling records, and the animation curves are smoothed to obtain recorded animation data.

[0008] Furthermore, when determining the motion timeline, object identifier, playback parameters, and animation output items, the following are included: The motion timeline is determined based on the first and last sampling times in the recorded animation data; The object identifier is determined based on the object number of the target object in the 3D editing scene; The playback parameters are determined based on the playback control fields of the recorded animation data. The animation output items are determined based on the sampling time, event markers, and transformation data fields in the recorded animation data.

[0009] Furthermore, when encapsulating the recorded animation data into animation behavior units, it includes: Establish behavioral unit identifiers; Write the object identifier, action timeline, recorded animation data, playback parameters, and animation output items into the same behavior unit record; The association between the behavior unit record and the target object is established based on the behavior unit identifier to obtain the animation behavior unit.

[0010] Furthermore, when generating the action node corresponding to the animation behavior unit in the visual programming interface, the process includes: Generate node identifiers based on the behavioral unit identifiers; The parameter ports of the action node are generated based on the playback parameter items, and each parameter port is bound to the corresponding playback parameter item; The output ports of the action nodes are generated based on the animation output items, and each output port is bound to the corresponding animation output item. Write the behavior unit identifier into the action node.

[0011] Furthermore, when generating the animation logic diagram based on the connection relationship, the process includes: Obtain the event output port of the event node, the condition input port of the condition node, the trigger input port of the action node, and the output port of the action node; In response to a connection operation on a port, a connection edge is established between two ports if the port types match; An animation logic diagram is generated based on the event nodes, condition nodes, action nodes, and connecting edges, and the execution order of the nodes is determined according to the direction of the connecting edges.

[0012] Furthermore, when determining the triggered target action node based on the animation logic diagram, the process includes: After an event node receives an interactive event, it searches for a condition node connected to the event node along the connection edges in the animation logic graph. Read the input data of the condition node and generate the condition determination result; When the condition determination result meets the action triggering condition, the action node connected to the condition node is determined as the target action node; When multiple action nodes meet the action triggering conditions, the target action node is determined according to the connection order in the animation logic diagram.

[0013] Furthermore, controlling the target object to play the animation according to the recorded animation data includes: The playback speed, playback mode, and start time offset are read from the parameter port of the target action node. The target sampling time of the current playback moment in the action time axis is determined based on the playback speed and the start time offset. Based on the target sampling time, read position data, rotation data, and scaling data from the recorded animation data; The read position data, rotation data, and scaling data are applied to the target object.

[0014] Furthermore, the animation playback process also includes: The playback progress is determined based on the current playback time and the duration of the action timeline, and the playback progress is output through the output port corresponding to the playback progress. When the current playback time reaches the event marker set in the action timeline, the event marker is output through the output port corresponding to the event marker; When there is a subsequent node in the animation logic diagram that corresponds to the animation attribute value, the animation attribute value is read from the transformation data corresponding to the current playback time according to the attribute type requested by the subsequent node, and the animation attribute value is output through the output port corresponding to the animation attribute value. Record the execution status of each node in the animation logic diagram, and display the nodes in the execution state, as well as the input and output data of the nodes in the execution state, in the visual programming interface.

[0015] Compared with the prior art, the beneficial effects of the present invention are as follows: By acquiring the target object and recording trigger command in the 3D editing scene, the transformation data of the target object is collected during the recording period to generate recorded animation data. Then, based on the recorded animation data, the action timeline, object identifier, playback parameter items and animation output items are determined, and the recorded animation data is encapsulated into animation behavior units.

[0016] Building upon this, by generating action nodes corresponding to animation behavior units in the visual programming interface, each action node is configured with parameter ports corresponding to playback parameters and output ports corresponding to animation outputs, allowing the recorded dynamic process to be abstracted into visual logical components. Subsequently, an animation logic diagram is generated by acquiring the connection relationships between event nodes, condition nodes, and action nodes. During preview execution, the target action node to be triggered is determined based on the animation logic diagram, and the corresponding animation behavior unit and parameter values ​​are read to control the target object to play the animation.

[0017] During animation playback, the playback progress, event markers, or animation attribute values ​​are output in real time based on the animation output items, and this data is provided to subsequent nodes connected to the output port in the animation logic diagram, realizing the reverse driving of the logic flow by the animation state.

[0018] Therefore, this solution effectively addresses the technical challenges of logically describing dynamic animations due to the difficulty in directly mapping animation data to event- and condition-based logic frameworks. Furthermore, the weak integration of visual programming tools with rich animation data prevents the direct conversion of recorded dynamic processes into high-level action modules that can be logically referenced, thus limiting the potential of procedural interaction. This solution avoids the long iteration cycles, high collaboration costs, and difficulty for non-professional users to achieve complex interactions inherent in traditional workflows where animation production and logic editing are separated. This bidirectional data flow mechanism not only improves the efficiency and realism of animation interaction creation but also enhances the system's flexibility and scalability.

[0019] On the other hand, the present invention also provides a 3D animation editing system based on recording and visualization programming, comprising: The recording data generation unit is used to acquire the target object and recording trigger command in the 3D editing scene, collect the transformation data of the target object during the recording period, and generate recording animation data associated with the target object; The behavior unit encapsulation unit is used to determine the action timeline, object identifier, playback parameter items and animation output items based on the recorded animation data, and encapsulate the recorded animation data into animation behavior units; An action node generation unit is used to generate action nodes corresponding to the animation behavior unit in a visual programming interface. The action node includes a parameter port corresponding to the playback parameter item and an output port corresponding to the animation output item. The logic diagram generation unit is used to obtain the connection relationship between event nodes, condition nodes and action nodes, and generate an animation logic diagram based on the connection relationship. The preview execution unit is used to determine the triggered target action node according to the animation logic diagram during preview execution, read the animation behavior unit corresponding to the target action node and the parameter value of the parameter port, and control the target object to play the animation according to the recorded animation data. An animation output unit is used to output playback progress, event markers, or animation attribute values ​​according to the animation output items during animation playback, and to provide the playback progress, event markers, or animation attribute values ​​to subsequent nodes connected to the output port in the animation logic diagram.

[0020] It should be noted that the three-dimensional animation editing system and method based on recording and visualization programming of the present invention have the same beneficial effects, and will not be described in detail here. Attached Figure Description

[0021] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0022] Figure 1 A flowchart of a 3D animation editing method based on recording and visual programming provided in an embodiment of the present invention; Figure 2 This is a functional block diagram of a 3D animation editing system based on recording and visual programming, provided in an embodiment of the present invention. Detailed Implementation

[0023] 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 some embodiments of the present invention, and not all embodiments. 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.

[0024] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0025] See Figure 1 As shown, this embodiment of the invention provides a 3D animation editing method based on recording and visual programming, including: S100: Acquire the target object and recording trigger command in the 3D editing scene, collect the transformation data of the target object during the recording period, and generate recording animation data associated with the target object.

[0026] In this embodiment, the target object refers to the entity in the 3D editing scene that requires animation or interactive design, such as character models, props, special effects emitters, or camera perspectives. The recording trigger command serves as the signal to initiate animation capture and can be generated by clicking interface controls, triggering shortcut keys, or executing script commands. In response to this command, the recording period begins, and the movement state of the target object is monitored.

[0027] Transformation data is used to describe the shape and positional changes of a target object in three-dimensional space. The transformation matrix of the target object is continuously captured at a preset sampling frequency (e.g., 60 frames / second). This matrix includes position data (X, Y, Z axis coordinates), rotation data (Euler angles or quaternions), and scaling data (scales of each dimension). These data collectively constitute the motion trajectory that changes over time. The acquired transformation data is stored as a raw sequence in chronological order, and after denoising or formatting, recorded animation data uniquely associated with the target object is generated.

[0028] S200: Determine the action timeline, object identifier, playback parameter items, and animation output items based on the recorded animation data, and encapsulate the recorded animation data into animation behavior units.

[0029] The motion timeline defines the valid time range of the recorded animation data, with its start and end points corresponding to the first and last sampling times of the recording period, thus determining the total animation duration. Object identifiers are used to uniquely index target objects globally, and can take the form of a scene tree unique number (ID), a globally unique identifier (GUID), or a resource path string, ensuring that animation data is accurately mapped to the corresponding 3D entity.

[0030] The playback parameters configure the animation playback behavior, including playback speed, playback mode (single, loop, round trip), and start time offset. The animation output defines the external data interface during playback, including playback progress percentage, preset event markers (such as the FootStep event triggered at a specific time), and real-time animation attribute values ​​(such as height coordinates or rotation angle). When the playback mode is single playback, if the target sampling time exceeds the end of the motion timeline, the target sampling time is determined as the end sampling time, and a playback end status is generated. When the playback mode is loop playback, if the target sampling time exceeds the end of the motion timeline, the target sampling time is looped back according to the length of the motion timeline. When the playback mode is round trip playback, the forward or reverse reading of the recorded animation data is determined based on the playback cycle in which the target sampling time is located.

[0031] The encapsulation process packages recorded animation data, motion timelines, object identifiers, playback parameters, and animation outputs into independent and self-contained logical entities, namely animation behavior units. These units are represented as structured data records, containing a metadata area storing object identifiers and timeline information, a parameter configuration area storing playback parameters, a data payload area storing the transformation data sequence, and an output definition area storing output definition information.

[0032] S300: Generates action nodes corresponding to animation behavior units in the visual programming interface. The action nodes include parameter ports corresponding to playback parameter items and output ports corresponding to animation output items.

[0033] The visual programming interface provides users with a graphical environment for building interactive logic, including a node editor, canvas, and connection tools. Action nodes, as visual representations of animation behavior units, logically correspond one-to-one with each action node.

[0034] Action nodes are represented as graphical geometric blocks, with ports distributed along their boundaries for data transmission. Parameter ports serve as input interfaces, receiving externally input parameters to dynamically control playback behavior. For example, for a playback speed parameter, an action node generates a corresponding parameter port, allowing users to connect numerical variables or calculation results to adjust the runtime rate. Output ports serve as output interfaces, transmitting playback-generated data to other nodes in the logic graph in real time. For each animation output item, an action node generates a corresponding output port, such as playback progress or event markers. The port data type matches the animation output item definition, covering floating-point numbers, Boolean values, or strings. This port mapping mechanism transforms internal animation data into standardized signals recognizable by the visual programming logic.

[0035] S400: Obtain the connection relationships between event nodes, condition nodes, and action nodes, and generate an animation logic diagram based on the connection relationships.

[0036] Event nodes serve as the starting point for logical execution, responding to external or internal interaction events, such as mouse clicks, keyboard input, collision detection, or timer triggers. Condition nodes perform logical judgments, returning a true or false result based on the input data, such as numerical comparisons or status checks.

[0037] The connection relationships describe the data flow and dependency order between nodes, represented by the connection edges between node ports. The system monitors user connection operations in the visual programming interface, obtaining the connection paths from the event node output port to the condition node input port, from the condition node output port to the action node trigger input port, and from the action node output port to the subsequent node input port. Based on these connection relationships, an animation logic diagram containing all participating nodes and their topology is constructed. This diagram defines the operational framework of the interactive system, clarifying the conditions that trigger which animation actions after a specific event occurs, and the flow of animation output data, forming a complete event-driven logic chain.

[0038] S500: During preview execution, the target action node to be triggered is determined according to the animation logic diagram, the parameter values ​​of the animation behavior unit and parameter port corresponding to the target action node are read, and the target object is controlled to play the animation according to the recorded animation data.

[0039] Preview execution refers to simulating the execution of the logic diagram and rendering the scene within the editor to verify the correctness of the interaction design. Once the preview starts, event nodes are monitored in real time. When an event node is activated, the logic path is traversed based on the connecting edges in the animation logic diagram: starting from the event node, connected condition nodes are searched and the judgment result is calculated; if the condition is met, the search continues for connected action nodes. The final determined action node to be executed is the target action node.

[0040] After identifying the target action node, the recorded animation data from its bound animation behavior unit is read, and the currently connected values ​​or variable values ​​of each parameter port are obtained as playback parameters. Based on these parameters, the target object is controlled to move in the 3D scene according to the recorded animation data. Specifically, based on the current position on the timeline at the playback moment, the corresponding position, rotation, and scaling values ​​are extracted from the recorded animation data and applied to the target object, thereby visually presenting a dynamic effect consistent with the recording or adjusted by the parameters.

[0041] S600: During animation playback, output playback progress, event markers, or animation attribute values ​​according to the animation output items, and provide the playback progress, event markers, or animation attribute values ​​to subsequent nodes connected to the output port in the animation logic diagram.

[0042] During each frame update cycle of the animation playback, the animation output items are parsed in real time. For playback progress, the proportion of the current moment relative to the total length of the action timeline is calculated, and a floating-point number or percentage value between 0 and 1 is output. For event flags, it is detected whether the current moment has reached the preset time point; if so, an output signal is triggered. For animation attribute values, specific attributes (such as Y-axis height or rotation angle) are extracted from the current transformation data according to logical requirements and output.

[0043] The output data is provided in real time to subsequent nodes connected to the corresponding output ports in the animation logic diagram. These subsequent nodes can serve as trigger inputs for other action nodes, judgment criteria for conditional nodes, or UI update nodes. This mechanism feeds back the internal state of the animation to the logic system in real time, enabling animation data to drive the logical flow in reverse. For example, connecting the playback progress to a conditional node can determine the end of the animation to trigger the next action; connecting an event marker to a sound playback node can achieve audio-visual synchronization. This two-way data interaction enhances the expressiveness and interactive depth of 3D animation.

[0044] In some embodiments of this application, continuously acquiring transformation data according to the recording sampling frequency and generating a smooth animation curve includes: Step S110: According to the recording sampling frequency, continuously acquire the position data, rotation data and scaling data of the target object during the recording period.

[0045] The recording sampling frequency is determined based on the speed of motion of the target object, the required animation accuracy, and the processing capability of the device.

[0046] Position data characterizes the coordinates of the target object in three-dimensional space, typically represented as a three-dimensional vector. Rotation data describes the orientation of the target object in three-dimensional space and can be recorded in the form of Euler angles, quaternions, or rotation matrices. Scaling data represents the size ratio of the target object along three axes and is also typically represented as a three-dimensional vector. During the recording period, the above data is read in real time from the scene's physics engine or transformation components, forming a raw data stream that changes continuously over time.

[0047] Step S120: Using the sampling time as an index, write the position data, rotation data, and scaling data at the same sampling time into the sampling record.

[0048] The discretely acquired raw data is organized into a structured storage format. The sampling time serves as a time reference, precisely recording the time point of each sampling, typically expressed as a relative time value starting from the recording start time. Sampling records constitute the basic unit of data organization, aligning and binding different dimensional transformation information acquired at the same instant.

[0049] After each sampling, the sampling time, position data, rotation data, and scaling data are written into the same sampling record, and multiple sampling records are arranged in the order of sampling time.

[0050] Step S130: Generate an animation curve based on the transformation continuity between adjacent sampling records, and smooth the animation curve to obtain the recorded animation data.

[0051] This involves a crucial transformation from discrete data to continuous animation. Animation curves are mathematically abstract representations of motion trajectories, describing the functional relationship between object attributes and time. Since sampled data only contains the state at discrete time points, direct playback often results in a mechanical or jittery feel. Therefore, interpolation calculations are performed based on the continuity of transformations between adjacent sampled records to generate continuous animation curves.

[0052] When the playback time is between two adjacent sampling times, intermediate state calculations are performed on the position data, rotation data, and scaling data in the two adjacent sampling records based on the time ratio between the playback time and the two adjacent sampling times.

[0053] The generated animation curves are smoothed to ensure that the transformations between adjacent sample records meet the requirements for continuous playback.

[0054] In some embodiments of this application, determining the motion timeline, object identifier, playback parameter items, and animation output items includes: Step S210: Determine the motion timeline based on the first and last sampling times in the recorded animation data.

[0055] The first sampling moment represents the time reference point at the start of the animation sequence corresponding to the recorded animation data, and the last sampling moment represents the time reference point at the end of the animation sequence corresponding to the recorded animation data. The action timeline is not a simple physical time length, but a logical time interval constructed based on the above start and end moments, used to define the effective playback range of the animation behavior unit in the entire 3D scene time flow. By parsing the header metadata or index structure of the recorded animation data, the start timestamp and end timestamp are extracted and their time span is calculated, thereby generating accurate timeline parameters.

[0056] Step S220: Determine the object identifier based on the object number of the target object in the 3D editing scene.

[0057] An object ID is a unique identifier assigned by the 3D editing engine to distinguish different entities. An object identifier, generated by mapping this object ID, is used to lock the reference relationship of the target execution subject within an animation action unit. The unique ID of the associated object is read from the metadata carried by the recorded animation data and encapsulated as a binding attribute of the animation action unit. This mechanism decouples the animation action unit from a specific target object while maintaining a tight connection; that is, the same animation action unit can be called by the logic system, but can only operate on a target object with that specific object ID. Using the object identifier, the association between the animation action unit and the target object can be established, and the corresponding target object can be located during playback.

[0058] Step S230: Establish a playback control field for the recorded animation data, and determine the playback parameter items based on the playback control field.

[0059] Playback parameters are a set of configurations that control the playback characteristics of animation behavior units. Playback control fields are created when the recorded animation data is encapsulated into animation behavior units and are stored in association with the recorded animation data. They are used to record the control parameters when the recorded animation data is played.

[0060] The playback control fields include a playback speed field, a playback mode field, and a start time offset field. The playback speed field determines the time advance rate of the recorded animation data during playback; the playback mode field determines the handling method when the target sampling time exceeds the motion timeline range; and the start time offset field determines the starting position of the animation on the motion timeline when playback begins.

[0061] Based on the playback speed, playback mode, and start time offset fields mentioned above, playback parameter items corresponding to the playback speed, playback mode, and start time offset are generated. Subsequently, when generating action nodes, these playback parameter items are mapped to the parameter ports of the action nodes, allowing users to configure them or for parameter values ​​to be input from upstream nodes in the animation logic diagram.

[0062] Step S240: Determine the animation output items based on the sampling time, event markers, and transformation data fields in the recorded animation data.

[0063] Animation output items are a set of interfaces that expose state information from animation behavior units to the external logical network. They are constructed based on the sampling time, event markers, and transformation data fields recorded within the recorded animation data. The sampling time and transformation data fields constitute the core trajectory of the animation's evolution over time, while the event markers represent the logical trigger signals that occur at specific points in time during animation playback (such as a foot landing or a collision). These discrete data points and event points are mapped into continuous or pulse-like output signals. For example, the spatial coordinate value corresponding to a certain sampling time can be converted into a real-time output position attribute, or the event marker at a specific moment can be converted into an instantaneously triggered event pulse. The construction of animation output items makes animation playback no longer a closed black box process, but rather a process that can provide real-time feedback on its own state (such as the current playback progress or the real-time position of objects), thereby driving subsequent connected condition nodes or other action nodes.

[0064] In some embodiments of this application, establishing behavior unit identifiers and writing multiple types of data into records to encapsulate animation behavior units includes: Step S250: Establish behavioral unit identifiers.

[0065] In the process of encapsulating the collected and processed recorded animation data into animation behavior units, the first step is to generate unique identification information for each data unit. The behavior unit identifier serves as a unique index to distinguish different animation logic modules, and its generation logic is executed in response to the encapsulation instruction. Specifically, it can be calculated by combining the current timestamp, the object number of the target object, and a random sequence number, or by using a Universally Unique Identifier (UUID) generation algorithm to produce a unique string or integer value as the behavior unit identifier.

[0066] Step S260: Write the object identifier, action timeline, recorded animation data, playback parameters, and animation output items into the same behavior unit record.

[0067] Based on the generated unique behavior unit identifier, an aggregated data write operation is performed, integrating various metadata and core content required to describe the animation. The behavior unit record, serving as the data carrier for animation behavior units, can adopt a key-value pair or structured data table format internally. Using the behavior unit identifier as the primary key, this record encompasses multiple fields, including object identifier, action timeline, recorded animation data, playback parameters, and animation output items. Specifically, the object identifier specifies the concrete object in the 3D scene to which the animation acts; the action timeline defines the start and end times and duration of the animation; the recorded animation data stores the specific transformation sequence; the playback parameters record control information such as playback speed and loop mode; and the animation output items contain progress or event information that can be used for logical driving.

[0068] Step S270: Establish the association between the behavior unit record and the target object based on the behavior unit identifier to obtain the animation behavior unit.

[0069] After the data writing is complete, to ensure that the animation behavior unit is correctly invoked and applied to the specified object at runtime, a mapping between the record and the scene entity needs to be established. This association can be established by constructing a mapping table or a reference pointer, for example, using the object identifier of the target object as the key and the generated behavior unit identifier as the value, or by directly adding a reference field pointing to the behavior unit record in the attribute list of the target object.

[0070] In some embodiments of this application, the 3D animation editing method based on recording and visualization programming further includes: generating node identifiers based on behavior unit identifiers; generating parameter ports of action nodes based on playback parameter items, and binding each parameter port to the corresponding playback parameter item; generating output ports of action nodes based on animation output items, and binding each output port to the corresponding animation output item; and writing behavior unit identifiers into action nodes.

[0071] Step S310: Generate node identifiers based on behavior unit identifiers.

[0072] To establish unique identifiers for graphical action nodes in the visual programming interface, node identifiers are generated using the behavior unit identifiers produced in the preceding steps, employing deterministic mapping rules or string copying strategies. These node identifiers not only distinguish different animation behaviors in the node list of the programming interface but also serve as keys for establishing internal data structure references. In practice, the behavior unit identifier is typically a globally unique identifier (UUID) assigned during the encapsulation phase. Node identifiers can directly inherit this value or have a specific prefix (such as NODE_) added to distinguish object types, ensuring rapid location of the corresponding data source in complex logical graphs.

[0073] Step S320: Generate parameter ports for action nodes based on playback parameter items, and bind each parameter port to the corresponding playback parameter item.

[0074] The configurable parameters defined in the animation behavior unit are visualized as input interfaces in the visual programming interface. Playback parameters are defined fields used to control the animation playback method, such as playback speed, loop mode, and start time offset. First, the list of playback parameters stored internally in the animation behavior unit is parsed to obtain the name, data type (such as floating-point number, boolean value, enumeration type), and default value of each parameter. Then, a corresponding number of parameter ports are generated in the graphical representation area of ​​the action node. In the visual programming interface, the parameter port is represented as a connection point or input box on the left side of the node, used to receive data streams from constant nodes, variable nodes, or other logical nodes. A logical mapping relationship is established between the parameter ports and the backend playback parameter items to ensure that when the user inputs a value to the parameter port through a connection or directly modifies the parameter at the port, the value can be accurately transmitted to the corresponding playback parameter item, thus taking effect during preview execution. This binding relationship is achieved through a port mapping table maintained internally by the node, which records the correspondence between port IDs and parameter field names within the behavior unit.

[0075] Step S330: Generate the output ports of the action nodes based on the animation output items, and bind each output port to the corresponding animation output item.

[0076] The real-time data state during animation playback is exposed as a data source that can be used by subsequent logic nodes. Animation outputs are also defined, containing dynamically changing fields such as playback progress, event markers, and animation attribute values. The animation output configuration within the animation behavior unit is traversed, generating a corresponding output port on the right side of the action node for each item. These output ports are used to transmit data to downstream nodes in the animation logic graph; for example, outputting playback progress to a decision node to determine when to switch scenes, or outputting event markers to a trigger to execute subsequent actions.

[0077] Step S340: Write the behavior unit identifier in the action node.

[0078] The final construction of the action node is completed, enabling it to retrieve underlying data at runtime. An action node is not merely a graphical element in the visual interface, but also a logical container holding specific data references. By writing the behavior unit identifier into the internal attribute area or metadata structure of the action node, a strong association is established between the graphical node and the backend animation behavior unit data entity. During the preview execution phase, when the animation logic graph's execution engine triggers the target action node, the engine first reads the behavior unit identifier stored internally by the node. Based on this identifier, it retrieves and loads the corresponding recorded animation data and configuration information from the database or memory, thereby driving the target object to play the animation.

[0079] In some embodiments of this application, the response port connection operation establishes a connection edge and determines the node execution order, including: Step S410: Obtain the event output port of the event node, the condition input port of the condition node, the trigger input port of the action node, and the output port of the action node.

[0080] In constructing a visual logic network, different types of nodes interact logically and perform functions through specific ports. Event nodes listen for and respond to discrete events occurring externally or internally, such as mouse clicks, collision detection completion, or keyboard key presses, and send signals to initiate subsequent logic flows when an event is triggered. Condition nodes perform Boolean logic judgments or numerical comparisons, determining the logical direction based on the true or false value of the input. Action nodes execute specific functional operations, such as playing recorded animations, modifying object properties, or sending messages. To establish ordered connections between nodes, it is first necessary to identify and extract the interfaces on each type of node used for data and control flow transmission. Specifically, the event output port of an event node serves as the starting point of the logic flow, activating and sending an execution signal when a specific event is triggered. The condition input port of a condition node receives data or status transmitted from upstream as the basis for logical judgments. The trigger input port of an action node is the interface for receiving execution instructions, executing its encapsulated function only when a valid signal is received. The output port of an action node, after the action is completed, transmits the calculation results, animation attributes, or new trigger signals to downstream nodes. The acquisition of the aforementioned port information constitutes the basic data preparation stage for constructing the logical network topology, ensuring that subsequent connection operations can accurately target the interaction points between nodes.

[0081] Step S420: In response to a connection operation on a port, establish a connection edge between the two ports if the port types match.

[0082] When a user attempts to connect a port of one node to a port of another node in the visual programming interface via mouse dragging or other interactive methods, the system responds to this connection operation and performs type matching verification on the two ports initiating the connection. Port type matching requires that the data type or control signal type of the output port be compatible with the expected type of the input port. For example, a Boolean output can only be connected to a Boolean input, and an execution stream output can only be connected to a trigger input. If type incompatibility is detected between the two ports, the connection will be prevented and an error message will be provided, thus avoiding runtime data type errors during the editing phase. After verifying that the two ports are type-matched, a logical connection channel, or connection edge, is created between them.

[0083] Step S430: Generate an animation logic diagram based on event nodes, condition nodes, action nodes, and connecting edges, and determine the execution order of nodes according to the direction of the connecting edges.

[0084] After completing the node layout and establishing the connecting edges, all nodes involved in the logic orchestration in the scene and their connections are integrated to form a unified animation logic graph. This animation logic graph is essentially a directed graph data structure, where nodes represent processing units and connecting edges represent dependencies. To enable the static logic graph to run dynamically as expected, the execution order of nodes is parsed based on the direction of the connecting edges. The direction of the connecting edges indicates the propagation path of the logic flow, typically starting from the event output port, flowing sequentially through condition judgment nodes, and finally reaching the action node or continuing to extend to subsequent nodes. Graph traversal algorithms (such as depth-first search or breadth-first search) are used to trace the logic flow along the direction of the connecting edges, thereby determining the activation order of each node. For example, when an event node is triggered, the next condition node is located along the edge connected to its output port. After the condition node is evaluated, the logic flows to the corresponding action node along the edge of the corresponding branch based on the judgment result.

[0085] In some embodiments of this application, the 3D animation editing method based on recording and visualization programming further includes: Step S510: After the event node receives an interactive event, search for the condition node connected to the event node along the connection edges in the animation logic graph.

[0086] Interactive events serve as the signal source driving the animation logic graph. These events can take various forms, including user mouse clicks, keyboard inputs, collision signals, and timer triggers within the 3D editing scene. Upon an event node detecting any of these interactive events, the type of the event and its associated parameter information are analyzed. Based on the pre-constructed graph topology, a breadth-first or depth-first search is performed, starting from the event node and extending downstream along the connecting edges, to locate all directly or indirectly related condition nodes.

[0087] Step S520: Read the input data of the condition node and generate the condition judgment result.

[0088] For each identified condition node, data connected to its input port is read. Input data sources include output parameters from preceding event nodes (e.g., collision point coordinates, key values), and state attributes of global variables or other objects in the scene (e.g., character health, item quantity). The pre-defined decision logic within each condition node is invoked to process the acquired input data. This decision logic includes numerical comparisons, Boolean logic operations, enumeration type matching, and string inclusion relationship checks. Based on the calculation results, a condition decision result is generated, typically a Boolean value indicating whether the current scene state meets the preset execution conditions, thus determining whether the logic flow is passed to downstream action nodes.

[0089] Step S530: When the condition determination result meets the action triggering condition, the action node connected to the condition node is determined as the target action node.

[0090] The generated condition judgment result is compared with the predefined action triggering conditions. If the judgment result is true or meets a specific threshold requirement, it indicates that the current environment state has reached the standard for executing a specific animation behavior. At this time, the action node directly connected to the condition node is retrieved along the output direction of the condition node, and the retrieved action node is marked as the target action node. This target action node represents the animation behavior unit authorized to be executed under the current combination of interaction event and condition. Subsequently, the scheduler will load and drive the corresponding 3D object to execute the preset recorded animation data.

[0091] Step S540: When multiple action nodes meet the action triggering conditions, determine the target action node according to the connection order in the animation logic diagram.

[0092] In complex logic scenarios, multiple condition nodes may simultaneously meet their triggering conditions, resulting in multiple action nodes being eligible for execution. To ensure the orderly execution of logic and the continuity of animation effects, a connection order is introduced as the basis for execution decision-making. Based on the node execution order determined during the animation logic graph generation stage, all action nodes that meet the conditions are sorted. The node execution order is determined based on the direction of the connecting edges and the order in which the connecting edges are established.

[0093] In some embodiments of this application, controlling the target object to play animation according to recorded animation data includes: Step S550: Read the playback speed, playback mode, and start time offset according to the parameter port of the target action node.

[0094] During the animation logic execution phase, the core control parameters required to drive animation playback are obtained by parsing the parameter ports of the target action node. Playback speed, playback mode, and start time offset together constitute the set of control variables for animation playback. Playback speed is a floating-point parameter greater than zero, used to define the playback rate of the animation; for example, a value of 1.0 indicates normal speed playback, 2.0 indicates double-speed fast-forwarding, and 0.5 indicates half-speed slow-motion. Playback mode is an enumerated type parameter used to limit the timing behavior logic of the animation, including but not limited to once, loop, and ping-pong modes. The start time offset is a time parameter used to specify the initial time point on the action timeline when the animation begins playback. These parameter values ​​can be configured in the visual programming interface or passed in from upstream logic nodes; during execution, the current parameter values ​​of the parameter ports are read as the basic input for calculating the target sampling time.

[0095] Step S560: Determine the target sampling time in the action timeline of the current playback moment based on the playback speed and the start time offset.

[0096] By utilizing the acquired playback speed and start time offset, a mapping relationship from global time to the motion timeline is constructed, thereby calculating the discrete sampling point corresponding to the current playback moment in the recorded animation data sequence. The motion timeline is a continuous time interval defined by the start and end times in the recorded animation data, while the recorded animation data is a discrete frame sequence acquired within this interval at a fixed sampling rate. When determining the target sampling moment, the current global time is first obtained, and the relative time relative to the animation start point is calculated by combining it with the start time offset. Then, the relative time is multiplied by the playback speed to obtain the mapped sampling time index.

[0097] This mapping process can be formally represented as: T sample =T offset +(T) current -T start ) × Speed.

[0098] Among them, T sample T represents the calculated target sampling time. offset Indicates the start time offset, T current Indicates the current system playback time, T startThe system time at which the animation begins playback is indicated, and Speed ​​represents the playback speed. Based on this calculation result, the corresponding sampling position is located on the timeline of the recorded animation data. If the calculation result falls within the valid range of the motion timeline, it is directly rounded or truncated to obtain the index of the target sampling time; if it exceeds the range, it is processed according to the playback mode. For example, in loop mode, the time is mapped back to the starting point of the timeline through modulo operation, while in single-shot mode, the playback ends.

[0099] Step S570: Read position data, rotation data, and scaling data from the recorded animation data according to the target sampling time.

[0100] After determining the target sampling time, the corresponding transformation state information is retrieved and extracted from the pre-stored recorded animation data structure. The recorded animation data is a time-indexed structured dataset, and each sampling record contains a complete spatial transformation description of the target object at that moment. During data reading, the target sampling time is used as the key to query the corresponding record in the recorded animation data. The read position data is usually in the form of a three-dimensional vector, such as (x, y, z) coordinates, used to represent the spatial position of the object in the three-dimensional scene coordinate system; rotation data is usually in the form of quaternions or Euler angles, used to represent the orientation of the object; scaling data is also in the form of a three-dimensional vector, used to represent the scale of the object in the three axes.

[0101] Step S580: Apply the read position data, rotation data, and scaling data to the target object.

[0102] The transformation parameters extracted from the recorded animation data are parsed in real time and assigned to the target object in the 3D scene to drive its corresponding movement. Applying the transformation data essentially involves synchronously updating the target object's local transformation matrix with the read position, rotation, and scaling data. In this process, firstly, position data is written to the target object's displacement attribute, updating its coordinates in the scene to its spatial position at the time of recording; secondly, rotation data is written to the target object's orientation attribute, adjusting its rotation angle to match the recording posture; finally, scaling data is written to the target object's scaling attribute, changing its geometric scale. Through these operations, the target object is updated to the state corresponding to the recorded animation data in each frame of the 3D rendering, thus visually presenting a motion trajectory and shape changes consistent with the recording process.

[0103] In some embodiments of this application, outputting playback progress and event markers and displaying node execution status during animation playback includes: Step S610: Determine the playback progress based on the current playback time and the duration of the action timeline, and output the playback progress through the output port corresponding to the playback progress.

[0104] The current playback moment can refer to the time point corresponding to the current time step when the target action node drives the target object to perform animation playback. The duration of the action timeline can refer to the total duration covered by the recorded animation data, that is, the time span from the first sampling moment to the last sampling moment. The playback progress is calculated based on the ratio of the current playback moment to the duration of the action timeline. This playback progress is usually expressed as a normalized value (such as a floating-point number between 0.0 and 1.0) or a percentage to quantify the degree of completion of the animation playback. For example, if the total duration of the action timeline is 5 seconds and the current playback moment is 2 seconds, then the playback progress is 0.4 or 40%. This playback progress is output in real time through a preset output port, so that subsequent nodes connected to this port (such as UI progress bar update nodes, logic judgment nodes) can obtain the execution status of the animation, thereby realizing logic control based on the animation progress, such as triggering subsequent plot or resetting the execution status when the progress reaches 100%.

[0105] Step S620: When the current playback time reaches the event marker set in the action timeline, output the event marker through the output port corresponding to the event marker.

[0106] Event markers are trigger points set by the user at specific points in the action timeline during recording or editing. These triggers emit specific signals or notifications when the animation reaches that point. These event markers typically have clear semantics, such as FootStep (footstep sound), Impact (impact), or OpenComplete (opening complete). During animation playback, the current playback time is continuously monitored. Once the current playback time matches the timestamp of any preset event marker in the action timeline, the event marker is considered reached. At this point, the event marker is output through the corresponding output port. The output typically includes the event marker's name or identifier, enabling subsequent nodes connected to that output port (such as sound effect playback nodes or special effects generation nodes) to respond to the event. For example, when playback reaches the point marked FootStep, this marker is output to trigger the playback of a footstep sound effect, thereby achieving precise synchronization between the animation visuals and the sound or special effects, enhancing the richness and immersion of the interaction.

[0107] Step S630: When there is a subsequent node in the animation logic diagram that corresponds to the animation attribute value, read the animation attribute value from the transformation data corresponding to the current playback time according to the attribute type requested by the subsequent node, and output the animation attribute value through the output port corresponding to the animation attribute value.

[0108] Subsequent nodes refer to nodes connected to the output port of the current action node in the animation logic diagram. These nodes may need to obtain real-time attribute information of the target object during playback to execute their logic. Animation attribute values ​​can refer to specific state parameters of the target object at the current playback moment, including but not limited to position coordinates, rotation quaternions, scaling ratios, or their components (such as Y-axis height). When a subsequent node requests a specific animation attribute value, the attribute type requested by the subsequent node is first parsed. Then, based on the current playback moment, the corresponding sampling record is located from the recorded animation data, and the requested attribute value is extracted from the transformation data of that record. For example, if a subsequent node requests the height information of the target object, the Y-axis coordinate value in the position data at the current playback moment is read. This value is output through the output port corresponding to the animation attribute value, enabling the subsequent node to perform conditional judgments or data-driven actions based on the real-time state of the animation. For example, a conditional node can read the Y-axis height of the current object, determine whether it is greater than a certain threshold, and if so, trigger the animation of opening a mechanism, thereby realizing the interactive mode of animation-driven logic.

[0109] Step S640: Record the execution status of each node in the animation logic diagram, and display the nodes in the execution state, as well as the input and output data of the nodes in the execution state, in the visual programming interface.

[0110] Execution status refers to the lifecycle state of each node in the animation logic diagram during runtime, including but not limited to idle, active, executing, or completed. During animation playback, the running status of each node in the animation logic diagram is traversed and tracked in real time, establishing and maintaining an execution status log. Nodes currently processing data or executing logic are marked as being in the execution state. In the visual programming interface, to provide intuitive debugging feedback, nodes in the execution state are visually highlighted, for example, by changing the node's border color, flashing effects, or adding specific status icons. Simultaneously, the current input and output data of the node are dynamically displayed on the node or next to its associated data port. For example, when a conditional node is executed, the node is highlighted, and its received input value (e.g., Height=5.2) and output judgment result (e.g., True) are displayed.

[0111] See Figure 2 As shown, the 3D animation editing system based on recording and visual programming includes: The recording data generation unit is used to acquire target objects and recording trigger commands in the 3D editing scene, collect transformation data of the target objects during the recording period, and generate recording animation data associated with the target objects. The behavior unit encapsulation unit is used to determine the action timeline, object identifier, playback parameter items and animation output items based on the recorded animation data, and encapsulate the recorded animation data into animation behavior units; The action node generation unit is used to generate action nodes corresponding to the animation behavior unit in the visual programming interface. The action node includes parameter ports corresponding to the playback parameter items and output ports corresponding to the animation output items. The logic diagram generation unit is used to obtain the connection relationships between event nodes, condition nodes, and action nodes, and generate an animation logic diagram based on the connection relationships. The preview execution unit is used to determine the target action node to be triggered based on the animation logic diagram during preview execution, read the parameter values ​​of the animation behavior unit and parameter port corresponding to the target action node, and control the target object to play the animation according to the recorded animation data. Animation output unit is used to output playback progress, event markers, or animation attribute values ​​according to the animation output items during animation playback, and to provide the playback progress, event markers, or animation attribute values ​​to subsequent nodes connected to the output port in the animation logic diagram.

[0112] The modules in the aforementioned 3D animation editing system based on recording and visualization programming can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in the processor of a computer device in hardware form or independent of it, or stored in the memory of the computer device in software form, so that the processor can call and execute the corresponding operations of each module.

[0113] The embodiments described above are merely preferred embodiments of the present invention and are not intended to limit the scope of the present invention. Various modifications and improvements made to the technical solutions of the present invention by those skilled in the art without departing from the spirit of the present invention should fall within the protection scope defined by the present invention.

Claims

1. A 3D animation editing method based on recording and visual programming, characterized in that, include: The system acquires the target object and recording trigger command in the 3D editing scene, collects the transformation data of the target object during the recording period, and generates recording animation data associated with the target object. Based on the recorded animation data, determine the action timeline, object identifier, playback parameter items, and animation output items, and encapsulate the recorded animation data into animation behavior units; In the visual programming interface, an action node corresponding to the animation behavior unit is generated. The action node includes a parameter port corresponding to the playback parameter item and an output port corresponding to the animation output item. Obtain the connection relationships between event nodes, condition nodes, and action nodes, and generate an animation logic diagram based on the connection relationships; During preview execution, the target action node to be triggered is determined according to the animation logic diagram, the animation behavior unit corresponding to the target action node and the parameter value of the parameter port are read, and the target object is controlled to play the animation according to the recorded animation data; During animation playback, playback progress, event markers, or animation attribute values ​​are output according to the animation output items, and the playback progress, event markers, or animation attribute values ​​are provided to subsequent nodes connected to the output port in the animation logic diagram.

2. The 3D animation editing method based on recording and visualization programming according to claim 1, characterized in that, When generating recorded animation data associated with the target object, the following steps are included: According to the recording sampling frequency, the position data, rotation data and scaling data of the target object are continuously acquired during the recording period; Using the sampling time as an index, the position data, rotation data, and scaling data at the same sampling time are written into the sampling record; Animation curves are generated based on the continuity of transformation between adjacent sampling records, and the animation curves are smoothed to obtain recorded animation data.

3. The 3D animation editing method based on recording and visualization programming according to claim 2, characterized in that, When defining the motion timeline, object identifier, playback parameters, and animation outputs, the following are included: The motion timeline is determined based on the first and last sampling times in the recorded animation data; The object identifier is determined based on the object number of the target object in the 3D editing scene; The playback parameters are determined based on the playback control fields of the recorded animation data. The animation output items are determined based on the sampling time, event markers, and transformation data fields in the recorded animation data.

4. The 3D animation editing method based on recording and visual programming according to claim 3, characterized in that, When encapsulating the recorded animation data into animation behavior units, it includes: Establish behavioral unit identifiers; Write the object identifier, action timeline, recorded animation data, playback parameters, and animation output items into the same behavior unit record; The association between the behavior unit record and the target object is established based on the behavior unit identifier to obtain the animation behavior unit.

5. The 3D animation editing method based on recording and visualization programming according to claim 4, characterized in that, When generating the action node corresponding to the animation behavior unit in the visual programming interface, the following steps are included: Generate node identifiers based on the behavioral unit identifiers; The parameter ports of the action node are generated based on the playback parameter items, and each parameter port is bound to the corresponding playback parameter item; The output ports of the action nodes are generated based on the animation output items, and each output port is bound to the corresponding animation output item. Write the behavior unit identifier into the action node.

6. The 3D animation editing method based on recording and visualization programming according to claim 5, characterized in that, When generating the animation logic diagram based on the connection relationship, the following is included: Obtain the event output port of the event node, the condition input port of the condition node, the trigger input port of the action node, and the output port of the action node; In response to a connection operation on a port, a connection edge is established between two ports if the port types match; An animation logic diagram is generated based on the event nodes, condition nodes, action nodes, and connecting edges, and the execution order of the nodes is determined according to the direction of the connecting edges.

7. The 3D animation editing method based on recording and visualization programming according to claim 6, characterized in that, When determining the triggered target action node based on the animation logic diagram, the following are included: After an event node receives an interactive event, it searches for a condition node connected to the event node along the connection edges in the animation logic graph. Read the input data of the condition node and generate the condition determination result; When the condition determination result meets the action triggering condition, the action node connected to the condition node is determined as the target action node; When multiple action nodes meet the action triggering conditions, the target action node is determined according to the connection order in the animation logic diagram.

8. The 3D animation editing method based on recording and visualization programming according to claim 7, characterized in that, Controlling the target object to play animation according to the recorded animation data includes: The playback speed, playback mode, and start time offset are read from the parameter port of the target action node. The target sampling time of the current playback moment in the action time axis is determined based on the playback speed and the start time offset. Based on the target sampling time, read position data, rotation data, and scaling data from the recorded animation data; The read position data, rotation data, and scaling data are applied to the target object.

9. The three-dimensional animation editing method based on recording and visualization programming according to claim 8, characterized in that, The animation playback process also includes: The playback progress is determined based on the current playback time and the duration of the action timeline, and the playback progress is output through the output port corresponding to the playback progress. When the current playback time reaches the event marker set in the action timeline, the event marker is output through the output port corresponding to the event marker; When there is a subsequent node in the animation logic diagram that corresponds to the animation attribute value, the animation attribute value is read from the transformation data corresponding to the current playback time according to the attribute type requested by the subsequent node, and the animation attribute value is output through the output port corresponding to the animation attribute value. Record the execution status of each node in the animation logic diagram, and display the nodes in the execution state, as well as the input and output data of the nodes in the execution state, in the visual programming interface.

10. A 3D animation editing system based on recording and visual programming, characterized in that, include: The recording data generation unit is used to acquire the target object and recording trigger command in the 3D editing scene, collect the transformation data of the target object during the recording period, and generate recording animation data associated with the target object; The behavior unit encapsulation unit is used to determine the action timeline, object identifier, playback parameter items and animation output items based on the recorded animation data, and encapsulate the recorded animation data into animation behavior units; An action node generation unit is used to generate action nodes corresponding to the animation behavior unit in a visual programming interface. The action node includes a parameter port corresponding to the playback parameter item and an output port corresponding to the animation output item. The logic diagram generation unit is used to obtain the connection relationship between event nodes, condition nodes and action nodes, and generate an animation logic diagram based on the connection relationship. The preview execution unit is used to determine the triggered target action node according to the animation logic diagram during preview execution, read the animation behavior unit corresponding to the target action node and the parameter value of the parameter port, and control the target object to play the animation according to the recorded animation data. An animation output unit is used to output playback progress, event markers, or animation attribute values ​​according to the animation output items during animation playback, and to provide the playback progress, event markers, or animation attribute values ​​to subsequent nodes connected to the output port in the animation logic diagram.

Images