← BACK TO SELECTED WORK

CREATURE RIGGING / CASE STUDY 01

A wing built
to unfold.

Automated Dragon Wing System

A dragon wing is more than a chain of joints. It is a moving relationship between fingers, a flexible membrane, and the controls an animator needs to shape a performance.

Explore the breakdown
THE WORKING RIG / MAYA VIEWPORTJANUARY 02, 2026
MY ROLE
Rig design & Python automation
THE TOOLKIT
Maya / Python / Matrix nodes
PROJECT FOCUS
Creature wing system

A convincing wing starts
with a clear structure.

The aim of this project was to make a complex wing easier to build and easier to animate. Instead of treating every small deformation as a separate task, I built a repeatable system in which the main structure drives the finer details.

THE CHALLENGE

Keep the wing connected

The membrane needs to respond as the fingers spread and fold, without becoming a separate set of controls to manage.

THE APPROACH

Build relationships first

Matrix nodes describe how the finger chains and membrane guides follow one another. Python builds the repeated parts.

THE FOCUS

Make iteration practical

The setup can be regenerated as the structure or deformation resolution changes, keeping the build process consistent.

Dragon wing geometry, finger chains and animation controls in the Maya viewport
THE WORKING RIG / MAYA VIEWPORT GUIDO GONZALEZ

THE SYSTEM AT A GLANCE

  1. 01Position the guides
  2. 02Build finger chains
  3. 03Shape the membrane
  4. 04Attach deformation joints

01 / THE BREAKDOWN

The movement between the bones.

When a dragon opens its wing, the fingers give it structure, but the membrane gives the movement its silhouette. A useful rig has to coordinate both. If the fingers spread while the skin between them stays behind, the wing no longer reads as one connected form.

Folding introduces a different problem. The same surface that stretches across an open wing needs to gather into a much smaller shape. That makes the relationship between neighboring fingers just as important as the rotation of each individual joint.

My approach was to separate the system into three parts: a finger structure, a set of guides for the webbing, and smaller joints that follow a supporting surface. Each part has a specific job. Together, they turn a few structural movements into a more detailed deformation.

02 / THE BREAKDOWN

Give each finger a direction.

The long bones in the wing work like fingers. Each chain needs a consistent direction as its guides move, and that direction needs to remain understandable when the rig is rebuilt. I use Maya’s aimMatrix nodes to express these orientation relationships.

A matrix describes a transform: where something is, how it is rotated, and how it is scaled. Working with matrices lets me pass that transform through the rig as one relationship, instead of building a separate connection for every channel.

In the setup below, the primary axis points along the finger. The secondary axis helps define how the chain twists around that direction. Choosing these axes deliberately is important: aiming at a target alone does not define every aspect of a joint’s orientation.

Inside the setup: aiming the finger guides
dragon_falanges.pyPYTHON
# dragon_falanges.py snippet
for i in range(len(self.guides)-1):
    aim_matrix = cmds.createNode("aimMatrix", name=f"{self.side}_{name}_AMX")

    # Setup primary and secondary axis
    cmds.setAttr(aim_matrix + ".primaryInputAxis", *self.primary_aim_vector, type="double3")
    cmds.setAttr(aim_matrix + ".secondaryInputAxis", *self.secondary_aim_vector, type="double3")

    # Connect matrices directly (no constraints)
    cmds.connectAttr(order[i][0] + ".worldMatrix[0]", aim_matrix + ".inputMatrix")
    cmds.connectAttr(order[i][1] + ".primaryTargetMatrix", aim_matrix + ".primaryTargetMatrix")

Project excerpt. This shows part of the setup, rather than a standalone script.

Two ways to pose the same wing

FK, or forward kinematics, lets the animator rotate the joints along a chain. IK, or inverse kinematics, lets a target control the chain’s end. They solve different posing needs: FK is useful for shaping an arc, while IK is useful when an end position matters.

The wing uses blendMatrix to blend between the FK and IK transforms before passing the result to the deformation joints. Keeping this relationship explicit makes the rig easier to inspect when something does not behave as expected. The blend is one part of the setup; it does not, on its own, replace pose matching when switching modes.

03 / THE BREAKDOWN

Make the webbing respond to the fingers.

The membrane is the flexible skin between two neighboring fingers. Rather than positioning every supporting point by hand, I derive a shared guide from the two finger transforms. As those fingers move apart or come together, the guide changes with them.

The excerpt uses wtAddMatrix with equal weights. For the translation component, this gives a position halfway between the two inputs. It provides a useful reference for the webbing, but it should not be confused with a complete simulation of how real skin stretches or folds.

This distinction matters to the design. The rig is a controlled deformation system: it gives the membrane a repeatable relationship to the bones. The final appearance still depends on the surface layout, joint placement, skin weights, and the pose the animator chooses.

Inside the setup: a shared membrane guide
membran_module.pyPYTHON
# membran_module.py - calculating the mid-point
mid_position = cmds.createNode("wtAddMatrix", name=f"..._WTM")

# Connect both finger matrices
cmds.connectAttr(joint_one + ".worldMatrix[0]", mid_position + ".wtMatrix[0].matrixIn")
cmds.connectAttr(joint_two + ".worldMatrix[0]", mid_position + ".wtMatrix[1].matrixIn")

# Weight them equally (0.5) to find the center
cmds.setAttr(mid_position + ".wtMatrix[0].weightIn", 0.5)
cmds.setAttr(mid_position + ".wtMatrix[1].weightIn", 0.5)

Project excerpt. This shows part of the setup, rather than a standalone script.

04 / THE BREAKDOWN

Let the smaller joints follow a surface.

The broad movement of the wing is not enough to describe every part of the membrane. To distribute deformation across the webbing, I generate a NURBS surface based on the finger positions and place smaller joints across that surface.

Think of the surface as a flexible sheet with its own coordinate grid. The U coordinate describes one direction across the sheet, and V describes the other. A UV pin gives a joint a specific place on that sheet to follow as its shape changes.

The script distributes these attachment points across rows and columns. Each pin supplies an output matrix, which is connected to the corresponding joint’s offsetParentMatrix. This connects the joint’s placement to the surface without adding a separate parent transform for every attachment.

Inside the setup: distributing UV attachments
uv_pins.pyPYTHON
# Generating UV pins dynamically
for i in range(u_row):
    for index in range(v_row):

        # Normalize the coordinates based on row count
        u_val = float(i) / (u_row - 1)
        v_val = float(index) / (v_row - 1)

        cmds.setAttr(f"{uv_pin}.coordinate[{count}].coordinateU", u_val)
        cmds.setAttr(f"{uv_pin}.coordinate[{count}].coordinateV", v_val)

        # Connect to joint offset
        cmds.connectAttr(f"{uv_pin}.outputMatrix[{count}]", f"{joint}.offsetParentMatrix")

Project excerpt. This shows part of the setup, rather than a standalone script.

The number of attachment points is a design choice. More joints give the skinning stage more places to distribute weights, but they also increase the amount of data and evaluation in the rig. The goal is enough resolution for the deformation, rather than the highest possible joint count.

05 / THE BREAKDOWN

A build process that can be repeated.

A scripted rig is valuable when it makes the next iteration easier. Once the guides define the structure, Python creates the recurring node connections and attachment patterns. This removes much of the repetitive setup work from the rebuilding process.

For example, changing the number of membrane joints should not mean reconnecting every UV pin by hand. The grid can be regenerated from its row and column settings. That makes it easier to compare a lighter setup with a more detailed one while keeping the underlying approach the same.

I think of this as separating the design decisions from the assembly work. The decisions still need attention: guide placement, axes, surface shape, and skinning all affect the result. Automation makes those decisions easier to revisit because the repetitive steps are handled consistently.

06 / THE BREAKDOWN

What this project taught me.

This project brought several rigging ideas together around one concrete problem: making the space between the bones behave as part of the wing. Breaking that problem into smaller systems helped me reason about it and explain why each connection exists.

The strongest part of the approach is the repeatable build. It gives me a practical way to revisit the finger structure and membrane resolution without treating every version as a new manual setup. Matrix nodes also make the transform relationships visible within Maya’s dependency graph.

A next step would be to explore how the membrane behaves in more tightly folded poses, including corrective shapes or collision-aware adjustments. Those are possible extensions, rather than features of the current setup. For now, the focus is a modular foundation that can be posed, inspected, and refined.

EXPLORE ANOTHER PROJECT

gcSkinclusterIO

Keeping skin weights through a rig rebuild.

Read the breakdown ↗

LET’S TALK RIGGING

A question, an idea,
or a new challenge?

guidogoca@gmail.com ↗