Automatic processing method and system for maya-based files

Abstract

The application provides a Maya-based file automatic processing method and system, and the method comprises the following steps: reading a scene level graph and a dependency graph of a Maya file, organizing nodes participating in the same creative effect into a creative expression unit, and generating a creative expression base set; through topological matching and object role consistency calculation, similar expression units are combined into standard creative expressions to generate a standard creative expression set; the standard creative expression set is mapped into a target implementation scheme executable by a target platform in combination with a platform capability table, and an execution order is determined; finally, data is written into a target project to generate a target file according to the execution order. The application solves the problem that existing automatic processing technologies are difficult to maintain creative logic, and realizes stable connection of Maya creative logic in a target platform.

Description

Technical Field

[0001] This invention belongs to the field of three-dimensional digital content processing technology, and in particular relates to a method and system for automatic file processing based on Maya. Background Technology

[0002] With the development of 3D animation production, industrialized film and television animation production, and real-time rendering technology, file transfer between Maya and real-time engines such as Unreal Engine (UE) has become a crucial part of the animation asset creation, camera preview, real-time interaction, and engine-based rendering workflow. Current projects typically use intermediate formats such as FBX and USD, or rely on Maya-UE bridging plugins, asset synchronization tools, and automatic export scripts to transfer model, skeleton, animation, material, and texture resources. While these existing technologies can address file export, resource path conversion, format adaptation, and project writing issues to some extent, their focus remains primarily on file structure, node parameters, and resource paths. They prioritize successful file transfer and loading, paying less attention to the creative logic within Maya files, which comprises node combinations, constraints, animation curves, drive connections, material networks, and asset references. In real-world film and animation and real-time interactive projects, the same creative effect can often be achieved using different Maya implementations. For example, a character's head looking towards a target can be achieved through orientation constraints or through a combination of controllers, expressions, and bone rotation connections; facial expressions can be driven by deformable targets or through a combination of driving keyframes and controller properties; material representations may also be formed by multiple texture nodes, material nodes, and shading groups. Existing automated processing workflows, if exported solely based on node type, parameter values, or format rules, can easily break down the same creative effect into multiple isolated resources, or treat the same creative logic under different implementations as different objects. This leads to problems such as incomplete constraint handling, loss of driving relationships, changes in animation control order, inaccurate material instance binding, and inconsistencies between the motion chain and the original Maya file after entering the UX or real-time interactive system. Further analysis reveals that the problem is not simply caused by format incompatibility, but rather by the lack of a continuous processing mechanism in existing technologies to extract creative expressions from Maya file structures, standardize similar creative relationships under different implementation methods, and generate executable implementation solutions based on the capabilities of the target platform. Therefore, although automatic processing at the file level can be completed, it is difficult to guarantee the stable transfer of Maya creative effects on the target platform. Summary of the Invention

[0003] This invention discloses a method and system for automatic document processing based on Maya, in order to solve the problems mentioned in the background art.

[0004] To achieve the above objectives, the first aspect of the present invention provides a Maya-based automatic document processing method, the method comprising:

[0005] Read the scene hierarchy and dependency graph of the Maya file, extract model nodes, constraint nodes, animation curve nodes, driver nodes, material nodes and external asset reference paths, organize nodes that jointly participate in the same creative effect into creative expression units according to the node connection relationship, and generate a basic set of creative expression containing expression category, source object identifier, target object identifier, connection path and dependency relationship;

[0006] The creative expression base set is standardized, and similar creative expression units are merged into standard creative expressions based on the topology matching results and the consistency of object roles. The main control link is determined, and a standard creative expression set is generated.

[0007] Based on the pre-set platform capability table, the standard creative expression set is mapped to the target implementation scheme that can be executed on the target platform. The execution order of the target implementation scheme is determined according to the dependency relationship, and a target implementation scheme set is generated.

[0008] The processing interface is called according to the execution order to write geometric data, skeletal animation data, control configuration, driving relationships and material resources into the target project and generate the target file.

[0009] Furthermore, the process of organizing nodes that jointly participate in the same creative effect into creative expression units based on node connection relationships includes:

[0010] Organize constraint nodes, constrained objects, and target objects into constraint expression units;

[0011] The animation curve nodes, controller properties, and controlled bones are organized into animation control expression units;

[0012] Organize controller attributes, driving keyframe nodes, expression nodes, and deformation nodes into driving expression units;

[0013] Material nodes, shading group nodes, texture nodes, and model objects are organized into material representation units.

[0014] Furthermore, the reading of the scene hierarchy graph and dependency graph of the Maya file also includes:

[0015] Generate a unique node identifier for each node traversed. The unique node identifier is determined by a combination of node path, namespace and node type.

[0016] Record the reference status and readability status of nodes with invalid reference paths, duplicate names, locked nodes, and hidden nodes, and switch to exception handling when the target implementation scheme cannot accommodate them.

[0017] Furthermore, the step of merging similar creative expression units into a standard creative expression based on the topological structure matching result and the consistency of the object role includes:

[0018] Generate an adjacency matrix for each creative expression unit, wherein the adjacency matrix records the connection relationship between the source object and the target object;

[0019] The weighted composite value of the adjacency matrix element matching weight, the object role consistency quantification term, and the control anchor point preservation term is used as the creative equivalence.

[0020] Creative expression units with creative equivalence higher than the preset merging threshold are merged into the same standard creative expression, while creative expression units that fall into the threshold buffer are retained as candidate standard expressions and the difference connection paths are recorded.

[0021] Further, determining the main control link includes:

[0022] In the merged standard creative expression, based on the principles of control anchor integrity and shortest dependency path, the connection path from the source object to the target object is selected from the original creative expression unit list as the main control link, while auxiliary connection paths are retained to maintain the integrity of the action.

[0023] Furthermore, the step of mapping the standard creative expression set to a target implementation scheme executable by the target platform based on the pre-set platform capability table includes:

[0024] Read the platform capability table, which includes the target platform version, writable node types, resource path rules, and unsupported item flags;

[0025] The weighted composite value of the basic matching degree, main control link acceptance degree, dependency order preservation degree and target project constraint satisfaction degree of the candidate implementation scheme is used as the implementation fit degree.

[0026] The candidate implementation scheme with the highest adaptability is determined as the primary target implementation scheme, and the candidate implementation schemes marked as unsupported in the platform capability table are transformed into degraded implementation schemes.

[0027] Furthermore, determining the execution order of the target implementation scheme based on dependencies includes:

[0028] The target implementation scheme is regarded as the execution node, and the dependency relationship is regarded as the directed edge between the node. The task dependency graph is constructed and the topology is sorted.

[0029] When a circular reference is detected, the dependency edges corresponding to the main control link are preserved, and the auxiliary links are marked as subsequent connections;

[0030] For target implementation schemes at the same dependency level, the execution priority score is calculated based on the preset execution priority value and the main control link maintenance parameter, and the execution order is arranged from high to low according to the execution priority score.

[0031] Furthermore, the step of writing geometric data, skeletal animation data, control configuration, driving relationships, and material resources into the target project includes:

[0032] For the target implementation scheme of control constraint type, write the skeleton, controller and constraint direction into the control skeleton node path to generate gaze control node or rotation transformation node;

[0033] For the implementation scheme of animation blueprint type targets, the animation curves and bone tracks are exported as animation data, and input parameters and bone control entry points are generated;

[0034] For the target implementation scheme of deformation target type, the local deformation target and the driving input are written into the deformation binding relationship;

[0035] For the target implementation scheme of material instance type, the texture resources and material parameters are written into the material instance parameter slot, and the material instance is bound to the model material slot.

[0036] Furthermore, the generation of the target file also includes:

[0037] During the writing process, if the target node does not exist or the target platform interface does not support it, record the reason for the failure and the corresponding standard creation expression, continue to execute the subsequent target implementation scheme that does not depend on the current writing action, mark the subsequent target implementation scheme that depends on the current writing action as pending rewriting and output a repair prompt.

[0038] A second aspect of the invention provides a Maya-based automatic document processing system, the system comprising:

[0039] The parsing module is used to read the scene hierarchy and dependency graph of Maya files, extract model nodes, constraint nodes, animation curve nodes, driver nodes, material nodes and external asset reference paths, organize nodes that jointly participate in the same creative effect into creative expression units according to the node connection relationship, and generate a basic set of creative expressions containing expression category, source object identifier, target object identifier, connection path and dependency relationship;

[0040] The standardization module is used to standardize the basic set of creative expressions, merge similar creative expression units into standard creative expressions based on the topology matching results and the consistency of object roles, determine the main control link, and generate a set of standard creative expressions.

[0041] The mapping module is used to map the standard creative expression set to the target implementation schemes executable by the target platform based on the preset platform capability table, determine the execution order of the target implementation schemes according to the dependencies, and generate a set of target implementation schemes;

[0042] The execution module is used to call the processing interface according to the execution order, write geometric data, skeletal animation data, control configuration, driving relationship and material resources into the target project, and generate the target file.

[0043] The beneficial technical effects of the present invention are at least as follows:

[0044] To address the aforementioned issues, this invention transforms the traditional file-structure-centric automated processing method into a creative expression-centric one. It accurately extracts constraints, drivers, animation control, and material representation logic from 3D software files, ensuring stable transfer of creative effects across target platforms. By standardizing and merging similar creative relationships across different implementations, it unifies the description of scattered nodes, effectively avoiding issues such as redundant control, incomplete constraint transfer, and loss of driver relationships during cross-platform migration. By calculating the compatibility based on the target platform's capability table, it intelligently selects the optimal target implementation scheme and performs topological sorting based on dependencies and execution priorities. This ensures that the control structure in complex, multi-layered dependency scenarios is accurately transferred layer by layer according to the original creative chain, preventing control conflicts. Ultimately, it achieves high-fidelity automated migration from 3D digital content creation tools to real-time rendering engines, significantly improving the efficiency and quality of industrialized film and animation production and cross-platform collaborative production. Attached Figure Description

[0045] The present invention will be further described with reference to the accompanying drawings, but the embodiments in the drawings do not constitute any limitation on the present invention. For those skilled in the art, other drawings can be obtained based on the following drawings without creative effort.

[0046] Figure 1 This is a flowchart of the Maya-based automatic file processing method of the present invention.

[0047] Figure 2 This is a framework diagram of the Maya-based automatic document processing system of the present invention. Detailed Implementation

[0048] Embodiments of the present invention are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and should not be construed as limiting the present invention.

[0049] In one or more embodiments, such as Figure 1 As shown, a Maya-based automatic document processing method is disclosed, which includes the following:

[0050] S1: Read the scene hierarchy and dependency graph of the Maya file, extract model nodes, constraint nodes, animation curve nodes, driver nodes, material nodes and external asset reference paths, organize nodes that jointly participate in the same creative effect into creative expression units according to the node connection relationship, and generate a basic set of creative expressions containing expression category, source object identifier, target object identifier, connection path and dependency relationship.

[0051] Specifically, this step takes the Maya file to be processed as input. The system reads the engineering content from the file through the Maya scene access interface. The read objects include model-level nodes, skeleton nodes, controller nodes, constraint nodes, animation curve nodes, driver nodes, material nodes, texture connection nodes, and external asset reference paths. All of the above content comes from the scene hierarchy graph and dependency graph inside the Maya file, which can be obtained by traversing node types, node names, node attribute connections, input / output connections between nodes, and reference paths through the Maya API. To ensure that the read results can be used stably in subsequent steps, the system generates a unique node identifier for each node during traversal. This unique node identifier is jointly determined by the Maya internal node path, namespace, and node type. For nodes with invalid reference paths, duplicate node names, locked nodes, or hidden nodes, the system does not discard them directly, but records the reference status, readable status, and node role. The exception handling is only initiated later when the target implementation scheme cannot accommodate the node. After reading the data, the system uses visible model objects, skeleton objects, controller objects, or material output objects as the starting point for analysis. It traces nodes that have control, constraint, drive, or material output relationships with these objects along the input and output connections in the dependency graph, and organizes nodes that jointly contribute to the same creative effect into creative expression units. The result is not a simple list of nodes, but structured data that reflects the constraint, drive, animation control, and material representation relationships in the Maya file.

[0052] In constraint-related content processing, the system reads the constrained object, target object, constraint type, and connection direction of constraint nodes and organizes them into constraint expression units. For example, when a character's head skeleton is connected to an orientation constraint node, and that orientation constraint node is connected to a target controller, the system groups the head skeleton, orientation constraint node, and target controller into the same constraint expression unit. This expression unit represents the creative relationship of the character's head continuously facing the target controller. In animation control-related content processing, the system reads the connection relationship between animation curve nodes and controllers or bones and preserves the links between controllers, animation curves, and controlled objects. For example, when a character's arm movement is driven by controller keyframes to move the upper arm, forearm, and wrist bones, the system organizes the controller, its associated animation curves, and controlled bone nodes together into an animation control expression unit. This unit represents the action being generated by the controller link, rather than by isolated bone keyframes.

[0053] In driver-related content processing, the system reads the attribute transfer relationships formed by expression nodes, driver keyframe nodes, and tool nodes, and records the driving source object, the driven object, and the attribute connection path. For example, when the rotation attribute of the face controller affects the eyelid deformation node through a driver keyframe, the system organizes the face controller, driver keyframe node, and eyelid deformation node into a driver expression unit to represent the linkage between the controller attribute and facial deformation. In material-related content processing, the system reads the connection relationships between texture nodes, material nodes, shading group nodes, and model objects from the material network to form material representation expression units. For example, when a character clothing model is connected to color textures, normal textures, and material nodes simultaneously, the system organizes the texture input, material nodes, shading groups, and clothing model into a material representation expression unit to represent that the material representation of the model is formed by this group of material networks.

[0054] During the generation of expression units, the system determines the expression category based on node type, connection direction, and object role. Constraint nodes that connect both the constrained object and the target object are classified into constraint expression units; animation curve nodes that connect to controller attributes and affect skeletons or model objects are classified into animation control expression units; controller attributes that affect deformation nodes through driving keyframes, expression nodes, or tool nodes are classified into driving expression units; and material nodes that connect to model objects through shading groups are classified into material representation expression units. For expression units with identical source objects, target objects, expression categories, and connection paths, the system retains only one; for expression units with the same source and target objects but different connection paths, both are retained. For example, when the same facial controller drives eyelid deformation and mouth corner deformation respectively, the system generates separate eyelid driving expression units and mouth corner driving expression units due to the different connection paths and controlled deformation targets.

[0055] After completing the above processing, the system generates a basic set of creative expressions. Each expression unit in the basic set includes an expression category, a source object identifier, a target object identifier, a connection path, and dependencies. The expression category distinguishes constraints, drives, animation controls, and material representations; the source and target object identifiers come from node identifiers in the Maya file; the connection path comes from node connections in the Maya dependency graph; and dependencies represent the control sequence or synergistic relationship between multiple expression units. For example, in a shot of a character looking up at a target, there can be a head orientation expression unit, a neck animation control expression unit, and an eye orientation expression unit, which together describe the creative logic of the character's gaze movement through dependencies. This basic set of creative expressions serves as input for the next step, used to organize similar creative relationships under different Maya implementations into standard creative expressions.

[0056] S2: Standardize the basic set of creative expressions, merge similar creative expression units into standard creative expressions based on the topology matching results and the consistency of object roles, determine the main control link, and generate a standard creative expression set.

[0057] Specifically, this step uses the creative expression foundation set generated in step one. As input, Each expression unit contains an expression category, source object identifier, target object identifier, connection path, and dependencies. The system first groups the expression units according to functional categories, including constraint expression units, driving expression units, animation control expression units, and material representation expression units. Then, it standardizes and organizes the expression units within each group, categorizing them into standardized creative expression sets. This standardization process is particularly significant in cross-platform migration because the same creative logic under different node combinations and different expression methods needs to be uniformly represented when migrating to the target platform to ensure consistency in control logic and visual effects.

[0058] During the standardization process, the system uses a topology matching method to generate the adjacency matrix for each representation unit. Elements in the matrix Represents the source object With the target object Are there direct control, constraint, drive, or material output relationships between them? This indicates that a corresponding relationship exists. This indicates that no corresponding relationship exists. Based on the adjacency matrix, the system defines two representation units. and Creative equivalence This serves as the criterion for merging. The calculation originates from the Jaccard set similarity coefficient in mathematics, which measures the proportion of the intersection of two sets relative to their union. This step treats the connection paths between two representation units as a set of connecting edges, and adds object role consistency quantification and control anchor point preservation terms to the topological similarity, making it suitable for the standardized merging of constraint, drive, animation control, and material representation relationships in Maya files. The calculation method is as follows:

[0059] ;

[0060] in, and Respectively, they are expression units and expression unit The adjacency matrix elements are derived from the connection paths of the expression units in step one; Indicates the topology matching weight; This represents the object role consistency quantification item, which is obtained from the object type matching results of the source object and the target object in the Maya dependency graph. For example, the higher value is taken when it is bone to bone, controller to controller, or material output to material output. This indicates the anchor point retention item, which is determined by whether the key control objects in the expression unit are retained simultaneously. Key control objects include controllers, skeletons, deformable targets, or material output objects. and These represent the weights of the object role consistency quantification term and the control anchor maintenance term, respectively. Adjacency matrix elements, topological similarity sub-items, and All are dimensionless quantified terms. , and For dimensionless weights, usually according to Normalization is performed so that the components on the right side of the formula can be combined into the same dimensionless creative equivalence. All values ​​were normalized before being used in the calculation. , and The data is identified by manually verified samples or test asset sets from historical migration projects and kept fixed within the same project template. When both expression units lack valid connecting edges, resulting in an empty union, the system does not perform a merge calculation but retains them as isolated expression units and marks them for manual verification to avoid uncertain results when the denominator is zero. Taking the character's head orientation action as an example, if the union of the connection paths of two expression units contains 5 connecting edges and the intersection contains 4 connecting edges, then the topological similarity sub-item is: If the source object and the target object have the same object role, then If both the skull and the gaze controller, the two key control objects, are retained, then ;set up , , ,but When the merge threshold is set to At that time, the system merges the two expression units into the same standard for creating expression; after merging, it then... The integrity of the corresponding control anchor points and the length of the connection path determine the main control link of the standard's creative expression.

[0061] The system iterates through all representation units and performs calculations. A merging process is performed, combining expression units with a similarity exceeding a preset threshold into a single standard creative expression, while retaining the original list of expression units and the main control chain information. The merging threshold is determined by the test results of standard assets in the project template; for example, selecting several constraints, drivers, and materials that have been confirmed to be equivalently transferable, and statistically analyzing their... After distribution, take the boundary value that can distinguish between equivalent and non-equivalent expressions; when When a value falls into the buffer near the threshold, the system does not automatically merge it but retains it as a candidate standard expression and records the difference connection paths. The main control link selection is based on the principles of control anchor integrity and shortest dependency path, ensuring that the control structure generated when migrating to the target platform can support the creation logic. For example, in facial expression control, the eye rotation controller and the BlendShape driver node both belong to the same facial expression action. The system will merge them into a standardized facial expression, and the main control link will select the path from the eye controller to the BlendShape node, retaining other auxiliary links to maintain the complete action. The material representation unit analyzes the ShadingEngine connection topology to unify color textures, normal textures, and roughness textures into a single material representation standard expression, and records the source and output object of each input texture to ensure consistent performance when migrating to UE material instances.

[0062] In cases of complex actions and multi-layered dependencies, the system uses a standardized expression set. The expressive units within the animation establish hierarchical dependencies. For example, neck animation control first affects the head skeleton posture, then the direction of the head is corrected, the direction of the eyes is corrected, and finally the gaze is adjusted. Facial expression drivers then overlay micro-expression changes on top of this. In this way, a standardized set of expressive elements is created. It not only unifies the expression categories under different implementation methods, but also preserves the dependency order and control hierarchy in the creation chain, ensuring that the generated expressions maintain logical integrity and visual consistency during cross-platform migration.

[0063] The system ultimately outputs a standard collection of creative expressions. , Each element includes a standardized expression category, source object identifier, target object identifier, main control chain, list of original expression units, and dependencies, used in the next step to generate the target implementation scheme. Through this step, the same creative logic under different Maya implementations is uniformly represented, while preserving the necessary control chains and dependency order, providing clear and standardized input for subsequent automatic migration to generate executable target control schemes.

[0064] S3: Based on the pre-set platform capability table, map the standard creative expression set to the target implementation scheme that can be executed on the target platform, determine the execution order of the target implementation scheme according to the dependency relationship, and generate a target implementation scheme set.

[0065] Specifically, this step uses the standard creative expression set generated in step two. As input, Each element in the dataset includes a standard expression category, source object identifier, target object identifier, main control chain, list of original expression units, and dependencies. In this step, the system maps the standard creative expressions to executable implementation schemes for the target platform, forming a set of target implementation schemes. To ensure that the creative logic expressed in Maya can be accurately received in UE or real-time rendering systems, the system selects an appropriate implementation type for each standard expression by combining the pre-defined control structures, animation blueprint entry points, MorphTarget binding methods, material instance parameter entry points, resource path writing rules, and project configuration rules in the MUBridge platform capability table. This platform capability table includes the target platform version, writable node types, acceptable parameter types, resource path rules, dependency execution constraints, and unsupported item flags, and is read when the system starts or the target project is switched. If the implementation type corresponding to a standard expression is unavailable in the current target platform version, the system converts it into a downgraded implementation scheme or a pending implementation scheme, rather than directly writing it to an unsupported target node. Head orientation standard expressions are received through the ControlRigLookAt control structure, animation control expressions through the animation blueprint skeleton track, drive control expressions through MorphTarget, animation blueprint parameters, or Transform control links, and material representation expressions through material instances and texture input links.

[0066] When determining the target implementation scheme, the system calculates the implementation suitability for each candidate implementation scheme. This calculation originates from the multi-criteria linear weighted evaluation method in engineering decision-making. This method combines multiple normalized evaluation items into a comparable score. This step adds main control link inheritance, dependency order preservation, and target project generation constraints to the basic platform matching, enabling candidate solution selection to adapt to the creative logic migration requirements in the automatic processing of Maya to UE files. The calculation method is as follows:

[0067] ;

[0068] in, This represents the basic matching degree, which is obtained by matching the standard expression category with the available implementation type of the target platform. For example, a higher value is taken when the orientation expression is mapped to the ControlRigLookAt node. Indicates the level of connectivity of the main control link, derived from... The proportion of key objects in the main control link that are mapped in the candidate implementation structure, such as the head skeleton and gaze controller, is taken as a higher value when they are both mapped to the UE node; Indicates the degree of dependency order preservation, derived from The dependency relationship between expression units is maintained in the execution order of candidate implementation schemes. For example, when neck animation control is preceded by head orientation and head orientation is preceded by eyeball orientation, a higher value is taken. This indicates the degree to which the target project generates constraints, derived from the satisfaction status of candidate implementation methods when writing the UE project path, resource configuration, and node interface into the MUBridge. , , and These are the corresponding weight parameters. , , and All are dimensionless evaluation terms after normalization. , , and Dimensionless weights are typically configured such that the sum of the weights is one, so that the output on the right side of the formula is... The fitness is still achieved using dimensionless methods. All evaluation items are normalized before being used in the calculation.

[0069] During the computation process, the system generates all candidate implementation schemes for each standard expression. The value is determined, and the solution with the highest adaptation is selected as the primary target implementation solution. Simultaneously, auxiliary links that work in conjunction with the primary target implementation solution are recorded. Taking the character's head orientation action as an example, the main control link formed by the head skeleton and the gaze controller is mapped to the ControlRigLookAt node. Indicates an exact match of the categories. This indicates that the main control link has been fully taken over. This indicates that the dependency order is preserved. This indicates that the target project path and configuration meet the write conditions; assuming... , , , ,but The system will input the implementation plan. For facial expression-driven standard expressions, the system converts the controller input relationships and local deformation targets in Maya into UE-side MorphTarget bindings, animation blueprint parameter entries, and controller input mappings, and then... The primary target implementation scheme is selected, while auxiliary links are retained to maintain the integrity of the expression-driven relationship.

[0070] The system also based on The system organizes the execution order of target implementation schemes based on the dependencies between expression units. In scenarios with multiple expression units, such as neck animation control, head orientation control, eye orientation control, and facial expression driving, the system prioritizes the neck animation control mapping scheme first, the head orientation control mapping scheme second, the eye orientation control mapping scheme third, and the facial expression driving mapping scheme fourth. Material representation is generated after the action chain, and the implementation order follows Maya's creation logic and ensures no control conflicts occur on the target platform. Through this ordering, a set of target implementation schemes is established. Each element in the file not only records the implementation type and node path, but also preserves the execution order, providing precise control for the automatic generation of target files in subsequent steps.

[0071] The system outputs a set of target implementation schemes. , Each element in the code contains a standard expression category, source object identifier, target object identifier, main control chain, target platform implementation type, target node path, parameter writing location, resource writing location, dependencies, and execution order. The standard expression category, source object identifier, target object identifier, main control chain, and dependencies are derived from... The target platform implementation type, target node path, parameter write location, and resource write location are derived from the MUBridge platform capability table and... Value calculation result; execution order based on The dependencies are organized in this process. Through this step, the standard creative expression is mapped into a control and presentation scheme that can be directly executed on the target platform, providing complete input for the automatic generation of loadable files in step four.

[0072] S4: Call the processing interface according to the execution order to write geometric data, skeletal animation data, control configuration, driving relationship and material resources into the target project and generate the target file.

[0073] Specifically, this step uses the target implementation scheme set generated in step three. As input, Each element in the document contains a standard expression category, source object identifier, target object identifier, main control chain, target platform implementation type, target node path, parameter writing location, resource writing location, dependencies, and execution order. The system follows... The execution order recorded in the file is used to automatically process Maya files sequentially in the MUBridge system, writing the target implementation scheme corresponding to the standard creative expression into the target project of the UX or cross-platform film and television real-time interactive system, and finally generating the target file. Among them, the standard expression category is used to determine the type of processing to be performed; the source object identifier and target object identifier are used to determine the correspondence between Maya objects and target platform objects; the main control link is used to determine the core link for generating control logic; the target platform implementation type is used to determine the implementation structure adopted by the UE side, such as ControlRig, animation blueprint, MorphTarget, or material instance; the target node path is used to determine the node generation location in the target project; the parameter writing location is used to determine the writing entry point for blueprint parameters, control parameters, or material parameters; the resource writing location is used to determine the storage directory for geometry, animation, textures, and configuration files; and the dependency relationship and execution order are used to control the generation order of different implementation schemes.

[0074] The system first based on The system executes corresponding file processing actions based on the target platform implementation type. For target implementation schemes with the target platform implementation type of ControlRig, the system reads the source object identifier and target object identifier from the main control link, writes the bones, controllers, and constraint directions from Maya into the ControlRig node path on the UE side, and generates the corresponding LookAt, Transform constraint, or rotation control nodes. For target implementation schemes with the target platform implementation type of animation blueprint, the system reads the main control link and parameter writing position corresponding to the animation control expression, exports the animation curves and bone tracks from Maya into animation data readable by the target platform, and generates the corresponding input parameters and bone control entry points in the animation blueprint. For target implementation schemes with the target platform implementation type of MorphTarget, the system reads the source object identifier, target object identifier, and parameter writing position from the drive control expression, writes the local deformation target, drive input, and target deformation object from Maya into the MorphTarget binding relationship on the UE side. For target implementation schemes with the target platform implementation type of material instance, the system reads the resource writing position and material parameter writing position, writes the texture resources, material parameters, and model material slots into the target project, and keeps the color texture, normal texture, roughness texture, and material output object consistent with the target project. The material representation schemes in the middle have a consistent correspondence.

[0075] When multiple solutions for achieving a goal have dependencies, the system relies on... The dependencies and execution order determine the generation order. This execution order is based on the topological sorting concept of directed acyclic graphs (DAGs). Topological sorting is a classic algorithm in graph theory used to generate a linear execution sequence that satisfies dependencies in a set of tasks with sequential constraints. This step will... Each target implementation scheme in the process is treated as an execution node. The dependencies recorded are treated as directed edges between nodes. Combined with the priority of the main control link, nodes in the same dependency level are sorted, ensuring that basic skeletal animation is generated first, followed by constraint and orientation control, local deformation and facial expression-driven animation, and material instances and resource bindings are written after the motion control structure is stable. When circular references occur in dependencies, the system prioritizes retaining the dependency edges corresponding to the main control link, temporarily storing auxiliary links as post-connections, and executing auxiliary bindings only after the target file is generated, to avoid topological sorting failures. For cases where multiple executable target implementation schemes exist in the same dependency level, the system uses priority scoring to determine the execution order, calculated as follows:

[0076] ;

[0077] in, Indicates the first The execution priority of each goal achievement plan is scored by the system based on... The execution order, main control chain, and dependencies of the proposed solution are calculated. Indicates the first The basic execution priority value of each objective achievement plan is determined by... The execution order and preset execution priority value configuration are recorded in the middle. The preset execution priority value configuration comes from the target project generated template. For example, basic skeletal animation corresponds to a higher basic execution priority value, and material performance corresponds to a lower basic execution priority value. Indicates the first The main control link hold value for each target implementation scheme is derived from whether the key objects involved in the main control link in the scheme have completed the configuration of the target node path, parameter writing location, and resource writing location; This parameter represents the impact of the main control link's hold value on the order of values ​​within the same level. , and All of these are dimensionless sorting parameters, therefore It is also a dimensionless score, not representing time, distance, or resource quantity. This formula is derived from the classic linear weighted sorting method. This step introduces a main control link retention value in addition to the basic execution priority value, so that within the same dependency level, the scheme that can take over the critical control link is executed first. Used for relative sorting, the higher the value, the earlier it is executed.

[0078] Take, for example, a shot of a character looking up at a target with a change in expression. It includes a neck animation control scheme, a head orientation control scheme, an eye orientation control scheme, a facial expression driving scheme, and a clothing material representation scheme. Based on preset execution priority values, the basic execution priority value of the neck animation control scheme is configured. Pick Its main control link maintains the value Pick ,when Pick When performing priority scoring The basic execution priority value of the head orientation control scheme Pick Main control link hold value Pick Execution priority scoring The basic execution priority of the facial expression-driven solution Pick Main control link hold value Pick Execution priority scoring The basic implementation priority of the clothing material representation scheme Pick Main control link hold value Pick Execution priority scoring The system first generates a neck animation control scheme, then a head orientation control scheme and an eye orientation control scheme, followed by a facial expression driving scheme, and finally writes the material rendering scheme and resource binding configuration. This execution process is similar to... The consistent expression of dependencies allows the control structure in the target project to be inherited layer by layer according to the Maya creation chain.

[0079] After sorting, the system calls the corresponding processing interfaces of MUBridge according to the execution order of the target implementation scheme, writing the geometric data, skeletal animation, control configuration, driving relationships, material instances, and resource references from the Maya file into the target project. For geometric data, the system exports the model mesh and bone hierarchy according to the resource writing location, while maintaining the correspondence between the source object identifier and the target node path; for animation data, the system writes animation curves, skeletal tracks, and animation blueprint parameter entries according to the parameter writing location; for control configuration, the system generates ControlRig nodes, LookAt control nodes, Transform constraint nodes, and necessary input / output connections according to the target node path; for driving relationships, the system generates MorphTarget bindings and driving parameter entries according to the target object identifier; for material representation, the system writes texture resources according to the resource writing location, connects the texture input to the parameter slot of the UE material instance according to the parameter writing location, and then binds the material instance to the target model material slot. If a write operation fails due to an invalid resource path, a non-existent target node, or unsupported target platform interface, the system records the reason for the failure, the corresponding standard authoring expression, and the target implementation solution, and continues to execute subsequent solutions that do not depend on the failed operation; for subsequent solutions that depend on the failed operation, they are marked as pending rewriting and a repair prompt is output. Each write operation is defined as follows: Based on the corresponding elements, ensure that the nodes, parameters, and resource paths in the target project are consistent with the target implementation scheme generated in step three.

[0080] The system eventually generates the target file. , This includes geometric resources, skeletal animation resources, ControlRig configuration, animation blueprint configuration, MorphTarget binding, material instances, texture resources, and asset reference paths after being written to the target project. All the contents are from The target implementation scheme is executed, where the target node path determines the control structure writing location, the parameter writing location determines the entry point for writing control parameters and material parameters, the resource writing location determines the project resource saving directory, and dependencies and execution order determine the writing order. The generated... It can be loaded and run in UE or cross-platform film and television-level real-time interactive systems, and can undertake the standard creative expression formed in step two and the target implementation scheme formed in step three.

[0081] In one or more embodiments, such as Figure 2 As shown, a Maya-based automatic document processing system is disclosed, the system comprising:

[0082] The parsing module is used to read the scene hierarchy and dependency graph of Maya files, extract model nodes, constraint nodes, animation curve nodes, driver nodes, material nodes and external asset reference paths, organize nodes that jointly participate in the same creative effect into creative expression units according to the node connection relationship, and generate a basic set of creative expressions containing expression category, source object identifier, target object identifier, connection path and dependency relationship;

[0083] The standardization module is used to standardize the basic set of creative expressions, merge similar creative expression units into standard creative expressions based on the topology matching results and the consistency of object roles, determine the main control link, and generate a set of standard creative expressions.

[0084] The mapping module is used to map the standard creative expression set to the target implementation schemes executable by the target platform based on the preset platform capability table, determine the execution order of the target implementation schemes according to the dependencies, and generate a set of target implementation schemes;

[0085] The execution module is used to call the processing interface according to the execution order, write geometric data, skeletal animation data, control configuration, driving relationship and material resources into the target project, and generate the target file.

[0086] It is worth noting that the specific workflow of the Maya-based automatic document processing system provided in this embodiment of the invention is the same as that of the Maya-based automatic document processing method described in the above embodiments, and will not be repeated here.

[0087] This invention also provides a Maya-based automatic document processing device, including a processor, a memory, and a computer program stored in the memory and configured to be executed by the processor. When the processor executes the computer program, it implements the steps described in the Maya-based automatic document processing method embodiments above, for example... Figure 1 The steps S1 to S4 described above; or, when the processor executes the computer program, it implements the functions of each module in the above system embodiments.

[0088] For example, the computer program may be divided into one or more modules, which are stored in the memory and executed by the processor to perform the present invention. The one or more modules may be a series of computer program instruction segments capable of performing specific functions, which describe the execution process of the computer program in the Maya-based document automation device.

[0089] The Maya-based automatic document processing device can be a desktop computer, laptop, handheld computer, or cloud server, among other computing devices. This device may include, but is not limited to, a processor and memory. Those skilled in the art will understand that the Maya-based automatic document processing device may also include input / output devices, network access devices, and buses.

[0090] The processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor can be a microprocessor or any conventional processor. This processor is the control center of the Maya-based document automation device, connecting all parts of the device via various interfaces and lines.

[0091] The memory can be used to store the computer programs and / or modules. The processor implements various functions of the Maya-based automatic file processing device by running or executing the computer programs and / or modules stored in the memory, and by calling data stored in the memory. The memory may mainly include a program storage area and a data storage area. The program storage area may store the operating system, at least one application program required for a function, etc.; the data storage area may store data created according to the operation of the controller, etc. In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as hard disk, memory, plug-in hard disk, smart media card (SMC), secure digital card (SD card), flash card, at least one disk storage device, flash memory device, or other volatile solid-state storage device.

[0092] The modules integrated into the Maya-based automatic file processing device, if implemented as software functional units and sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the above embodiments of the present invention can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying the computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc.

[0093] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0094] The above description represents the preferred embodiments of the present invention. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of the present invention, and these improvements and modifications are also considered to be within the scope of protection of the present invention.

Claims

1. A Maya-based automatic document processing method, characterized in that, include: Read the scene hierarchy and dependency graph of the Maya file, extract model nodes, constraint nodes, animation curve nodes, driver nodes, material nodes and external asset reference paths, organize nodes that jointly participate in the same creative effect into creative expression units according to the node connection relationship, and generate a basic set of creative expression containing expression category, source object identifier, target object identifier, connection path and dependency relationship; The creative expression base set is standardized, and similar creative expression units are merged into standard creative expressions based on the topology matching results and the consistency of object roles. The main control link is determined, and a standard creative expression set is generated. The process of merging similar creative expression units into a standard creative expression based on the topological structure matching result and the consistency of the object role includes: Generate an adjacency matrix for each creative expression unit, wherein the adjacency matrix records the connection relationship between the source object and the target object; The weighted composite value of the adjacency matrix element matching weight, the object role consistency quantification term, and the control anchor point preservation term is used as the creative equivalence. Creative expression units with creative equivalence higher than the preset merging threshold are merged into the same standard creative expression, and creative expression units that fall into the threshold buffer are retained as candidate standard expressions and the difference connection paths are recorded. Based on a pre-defined platform capability table, the standard creative expression set is mapped to a target implementation scheme executable by the target platform. The execution order of the target implementation schemes is determined according to dependencies, and a target implementation scheme set is generated. The process of mapping the standard creative expression set to a target implementation scheme executable by the target platform based on the pre-defined platform capability table includes: Read the platform capability table, which includes the target platform version, writable node types, resource path rules, and unsupported item flags; The weighted composite value of the basic matching degree, main control link acceptance degree, dependency order preservation degree and target project constraint satisfaction degree of the candidate implementation scheme is used as the implementation fit degree. The candidate implementation scheme with the highest adaptability is determined as the main target implementation scheme, and the candidate implementation schemes marked as unsupported in the platform capability table are converted into degraded implementation schemes; The processing interface is called according to the execution order to write geometric data, skeletal animation data, control configuration, driving relationships and material resources into the target project and generate the target file.

2. The Maya-based automatic document processing method according to claim 1, characterized in that, The process of organizing nodes that jointly participate in the same creative effect into creative expression units based on node connection relationships includes: Organize constraint nodes, constrained objects, and target objects into constraint expression units; The animation curve nodes, controller properties, and controlled bones are organized into animation control expression units; Organize controller attributes, driving keyframe nodes, expression nodes, and deformation nodes into driving expression units; Material nodes, shading group nodes, texture nodes, and model objects are organized into material representation units.

3. The Maya-based automatic document processing method according to claim 1, characterized in that, The process of reading the scene hierarchy and dependency graph of the Maya file also includes: Generate a unique node identifier for each node traversed. The unique node identifier is determined by a combination of node path, namespace and node type. Record the reference status and readability status of nodes with invalid reference paths, duplicate names, locked nodes, and hidden nodes, and switch to exception handling when the target implementation scheme cannot accommodate them.

4. The Maya-based automatic document processing method according to claim 1, characterized in that, The determination of the main control link includes: In the merged standard creative expression, based on the principles of control anchor integrity and shortest dependency path, the connection path from the source object to the target object is selected from the original creative expression unit list as the main control link, while auxiliary connection paths are retained to maintain the integrity of the action.

5. The Maya-based automatic document processing method according to claim 1, characterized in that, Determining the execution order of the target implementation scheme based on dependencies includes: The target implementation scheme is regarded as the execution node, and the dependency relationship is regarded as the directed edge between the node. The task dependency graph is constructed and the topology is sorted. When a circular reference is detected, the dependency edges corresponding to the main control link are preserved, and the auxiliary links are marked as subsequent connections; For target implementation schemes at the same dependency level, the execution priority score is calculated based on the preset execution priority value and the main control link maintenance parameter, and the execution order is arranged from high to low according to the execution priority score.

6. The Maya-based automatic document processing method according to claim 1, characterized in that, The process of writing geometric data, skeletal animation data, control configuration, driving relationships, and material resources into the target project includes: For the target implementation scheme of control constraint type, write the skeleton, controller and constraint direction into the control skeleton node path to generate gaze control node or rotation transformation node; For the implementation scheme of animation blueprint type targets, the animation curves and bone tracks are exported as animation data, and input parameters and bone control entry points are generated; For the target implementation scheme of deformation target type, the local deformation target and the driving input are written into the deformation binding relationship; For the target implementation scheme of material instance type, the texture resources and material parameters are written into the material instance parameter slot, and the material instance is bound to the model material slot.

7. The Maya-based automatic document processing method according to claim 1, characterized in that, The generation of the target file also includes: During the writing process, if the target node does not exist or the target platform interface does not support it, record the reason for the failure and the corresponding standard creation expression, continue to execute the subsequent target implementation scheme that does not depend on the current writing action, mark the subsequent target implementation scheme that depends on the current writing action as pending rewriting and output a repair prompt.

8. A Maya-based automatic document processing system, characterized in that: include: The parsing module is used to read the scene hierarchy and dependency graph of Maya files, extract model nodes, constraint nodes, animation curve nodes, driver nodes, material nodes and external asset reference paths, organize nodes that jointly participate in the same creative effect into creative expression units according to the node connection relationship, and generate a basic set of creative expressions containing expression category, source object identifier, target object identifier, connection path and dependency relationship; The standardization module is used to standardize the basic set of creative expressions, merge similar creative expression units into standard creative expressions based on the topology matching results and the consistency of object roles, determine the main control link, and generate a set of standard creative expressions. The process of merging similar creative expression units into a standard creative expression based on the topological structure matching result and the consistency of the object role includes: Generate an adjacency matrix for each creative expression unit, wherein the adjacency matrix records the connection relationship between the source object and the target object; The weighted composite value of the adjacency matrix element matching weight, the object role consistency quantification term, and the control anchor point preservation term is used as the creative equivalence. Creative expression units with creative equivalence higher than the preset merging threshold are merged into the same standard creative expression, and creative expression units that fall into the threshold buffer are retained as candidate standard expressions and the difference connection paths are recorded. The mapping module is used to map the standard creative expression set to target implementation schemes executable on the target platform based on a preset platform capability table, determine the execution order of the target implementation schemes according to dependencies, and generate a set of target implementation schemes; the step of mapping the standard creative expression set to target implementation schemes executable on the target platform based on the preset platform capability table includes: Read the platform capability table, which includes the target platform version, writable node types, resource path rules, and unsupported item flags; The weighted composite value of the basic matching degree, main control link acceptance degree, dependency order preservation degree and target project constraint satisfaction degree of the candidate implementation scheme is used as the implementation fit degree. The candidate implementation scheme with the highest adaptability is determined as the main target implementation scheme, and the candidate implementation schemes marked as unsupported in the platform capability table are converted into degraded implementation schemes; The execution module is used to call the processing interface according to the execution order, write geometric data, skeletal animation data, control configuration, driving relationship and material resources into the target project, and generate the target file.

Images