Origami-Inspired Hinge Rigging for Real-Time Cube-to-Character Transformation in Unreal Engine

Transformation characters appear frequently in games, films, and interactive media. Traditional transformation animation requires complex skeletal rigs, deformation systems, and many manually created keyframes. These workflows are difficult to reuse for different characters. This research proposes a modular rigging framework inspired by origami folding. Instead of deforming one mesh, the character is divided into rigid body modules connected through hinge joints. A Python controller moves these modules from an initial cube configuration into a target character configuration, while Unreal Engine Control Rig enables runtime transformation.

Proposes an origami-inspired modular rigging framework. Introduces reusable rigid body modules connected through hinge joints. Implements a Python-based transformation controller in Maya. Designs a workflow for Unreal Engine runtime transformation using Control Rig.

Previous research has explored procedural rigging, modular control rigs, and real-time animation systems. Unreal Engine Modular Control Rig improves rig reuse, while Maya provides flexible scripting for procedural rig generation. Origami-inspired folding has also been used in robotics and geometric modeling because complex shapes can be created through simple rotational movements. However, existing methods focus on humanoid characters or predefined transformation sequences. Few approaches provide a reusable modular framework that combines procedural rig generation with real-time transformation control.

The proposed method introduces an origami-inspired modular rigging framework for real-time cube-to-character transformation using Autodesk Maya and Unreal Engine. Instead of relying on mesh deformation or manually animated transformation keyframes, the framework represents the character as a collection of rigid body modules connected through hinge-based joints. The workflow is designed as a reusable transformation pipeline that combines procedural rig generation, Python-based transformation control, and Unreal Engine Control Rig for runtime animation. The complete framework consists of six stages: generating a modular cube structure, separating the cube into rigid body modules, creating hinge-based skeletal connections, implementing Python transformation logic, exporting the rig to Unreal Engine, and performing runtime transformation through Control Rig. This modular approach enables body modules to move from an initial cube configuration to a predefined target character configuration while preserving rigid body structure and supporting reusable character transformations.

The proposed workflow consists of six stages: Generate a modular cube structure in Maya. Separate the cube into rigid body modules. Create hinge-based skeletal connections. Build Python transformation logic. Export the rig to Unreal Engine. Perform runtime transformation using Control Rig.

The prototype begins with a cube divided into nine rigid modules representing body parts including the head, body, claws, hands, and legs. Two configurations are created: cube_start: Initial cube arrangement. Crab_Target: Desired transformed character. The transformation system maps each source module to its corresponding target module.

Each body module behaves as a rigid panel connected through hinge joints. Instead of mesh deformation, transformations occur through joint rotations around predefined pivot locations. This approach preserves rigid shapes while allowing procedural folding similar to origami. The hinge rotation is controlled using: where is the normalized transformation parameter between the cube and target configuration. Equation 1 Parameters Meaning θi,1 Target hinge angle in transformation configuration θi,0 Initial hinge angle in cube configuration t Normalized transformation parameters between 0 and 1

The proposed modular rigging framework was implemented using Autodesk Maya and Unreal Engine 5. The implementation begins by generating a modular cube representation in Maya, where each body part is separated into an independent rigid module. A hierarchical skeleton is created using hinge-based joints so that each module can rotate around predefined pivot locations while preserving its rigid shape. Python scripting is used to automate the transformation process by reading the world-space translation and rotation values of each target module and applying them to the corresponding source module. This removes the need to manually animate or reposition individual body parts during the transformation process. After the modular rig is generated, the skeleton is exported as an FBX file and imported into Unreal Engine, where Control Rig manages the runtime transformation through a single transformation parameter. The implementation demonstrates a reusable workflow that combines procedural rig generation in Maya with real-time transformation control in Unreal Engine.

A Python script reads the world-space position and rotation of every module inside Crab_Target and applies those transforms to the corresponding module inside cube_start. Algorithm 1. Python-Based Modular Transformation import maya.cmds as cmds for module in modules: source = "cube_start|" + module target = "Crab_Target|" + module if cmds.objExists(source) and cmds.objExists(target): pos = cmds.xform(target, q=True, ws=True, t=True) rot = cmds.xform(target, q=True, ws=True, ro=True) cmds.xform(source, ws=True, t=pos) cmds.xform(source, ws=True, ro=rot) This removes the need for manually positioning each body part during transformation.

After rig generation, the modular skeleton is exported as FBX into Unreal Engine. A single parameter called TransformAmount controls the interpolation between the initial and target configurations using Control Rig. The runtime system updates hinge rotations continuously instead of relying on keyframed animation.

A proof-of-concept prototype was developed to evaluate the feasibility of the proposed origami-inspired modular rigging framework. The prototype successfully generated a modular cube representation composed of rigid body modules corresponding to major character parts, including the head, body, claws, hands, and legs. A Python-based transformation controller mapped the translation and rotation values from the target configuration (Crab_Target) to the initial cube configuration (cube_start), enabling the modular body parts to move into the target character arrangement without manually creating transformation keyframes. After exporting the modular rig from Autodesk Maya to Unreal Engine, the framework was integrated with Control Rig to support runtime transformation using a single transformation parameter. The results demonstrate that the proposed workflow can simplify the rigging process by separating transformation logic from manually animated keyframes. Because each body module remains independent, new transformation characters can be created by defining different target configurations while reusing the same modular rigging pipeline. This improves rig reusability and provides a flexible workflow for technical animation in real-time applications. However, the current implementation is a preliminary prototype and has been evaluated on a single cube-to-character transformation example. Future work will extend the framework to support multiple transformation characters, more complex hinge structures, and runtime performance evaluation within Unreal Engine.

A proof-of-concept prototype was implemented using a modular cube representation. The prototype demonstrates: Procedural cube generation. Modular body part organization. Python-based transformation mapping. Runtime-ready rig structure for Unreal Engine.

The transformation parameter provides continuous interpolation between cube and character states. The prototype indicates that the modular workflow can simplify authoring and improve rig reuse for transformation characters compared to manually animated keyframe workflows.

The framework is intended as a reusable rigging pipeline rather than a single transformation asset. Because body modules remain independent, different transformation characters can be created by defining new target configurations without rebuilding the entire rig.

This paper presented an origami-inspired modular rigging framework for real-time cube-to-character transformation. The proposed system combines procedural rig generation in Maya with Python-based module mapping and Unreal Engine Control Rig for runtime animation. Preliminary prototype development demonstrates the feasibility of a reusable transformation workflow without manually creating transformation keyframes. Future work includes completing the Maya implementation, expanding the framework to multiple transformation characters, and evaluating runtime performance in Unreal Engine.