File size: 10,026 Bytes
7d46f0e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4837eb2
7d46f0e
 
 
 
 
 
 
d5d4335
 
 
7d46f0e
 
 
 
 
 
 
 
 
9bd304c
 
 
 
 
7d46f0e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4837eb2
 
 
 
 
 
 
 
 
 
7d46f0e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
b94d130
 
 
 
7d46f0e
 
 
 
 
 
 
 
 
 
 
 
 
d5d4335
7d46f0e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
"""
Make-It-Animatable for 3dvalley.com: the free lane of Auto-rig
(https://3dvalley.com/tools/fix/auto-rig). A humanoid mesh in, the same mesh
back with a Mixamo-named skeleton and skin weights, as a GLB (and the FBX it
was exported as). One API endpoint for headless callers, plus a small demo UI.

Differs from jasongzy/Make-It-Animatable-v2's Space (code at the commit
deploy.sh pins) in these ways:
- rigging only: no animation step, so no Auto-Rig Pro add-on and no Mixamo
  animation files; the only Mixamo file is the skeleton template the bones
  are laid out on
- one GPU reservation per run instead of three: upstream's three
  @spaces.GPU calls would each reserve the 60 s default, 180 s in all, more
  than an anonymous visitor's daily quota, so they are imported without
  their decorators and run inside `_rig_on_gpu`
- the weights and the template are downloaded file by file, not by cloning
  the model repo and the dataset
- the output keeps the input's own position and size (Restore Global
  Transform) and its rest pose is reset to a T-pose
"""

import spaces  # isort:skip

import os
import queue
import shutil
import sys
import tempfile
import time
import types

import gradio as gr
import trimesh
from huggingface_hub import hf_hub_download

HERE = os.path.dirname(os.path.abspath(__file__))
CODE = os.path.join(HERE, "mia")
TOKEN = os.environ.get("HF_TOKEN")
os.environ["GRADIO_TEMP_DIR"] = os.path.join(tempfile.gettempdir(), "gradio")
MAX_INPUT_FACES = 300_000
# What trimesh reads from one uploaded file: the input is loaded with it to merge duplicate vertices (below).
# FBX it cannot read, and a .gltf usually keeps its data in files of its own.
INPUT_TYPES = [".glb", ".obj", ".ply", ".stl"]

# The upstream code reads its files relative to its own folder: the three
# v2 checkpoints (Apache-2.0) and the Mixamo skeleton template (from the
# author's gated dataset; the Space's token has accepted its terms).
for name in ("bw_joints.pth", "joints_coarse.pth", "pose.pth"):
    target = os.path.join(CODE, "output", "best", "v2", name)
    if not os.path.isfile(target):
        os.makedirs(os.path.dirname(target), exist_ok=True)
        shutil.copy(hf_hub_download("jasongzy/Make-It-Animatable", f"output/best/v2/{name}", token=TOKEN), target)
# FBX2glTF turns the rig's FBX into the GLB. An upload to the Space does not
# keep a file's executable bit, so it is set again here (upstream's install.sh does the same).
_converter = os.path.join(CODE, "util", "FBX2glTF")
if os.path.isfile(_converter):
    os.chmod(_converter, 0o755)
template = os.path.join(CODE, "data", "Mixamo", "bones.fbx")
if not os.path.isfile(template):
    os.makedirs(os.path.dirname(template), exist_ok=True)
    shutil.copy(hf_hub_download("jasongzy/Mixamo", "bones.fbx", repo_type="dataset", token=TOKEN), template)

# Upstream decorates each model call with @spaces.GPU. Imported under a
# stand-in whose GPU decorator does nothing, they become plain functions that
# `_rig_on_gpu` calls inside one reservation; the real module is put back.
_real_spaces = sys.modules["spaces"]
_stand_in = types.ModuleType("spaces")
_stand_in.GPU = lambda fn=None, **_: fn if callable(fn) else (lambda inner: inner)
sys.modules["spaces"] = _stand_in
sys.path.insert(0, CODE)
try:
    import app_v2 as mia  # noqa: E402
finally:
    sys.modules["spaces"] = _real_spaces

# The steps return Gradio updates keyed by the upstream UI's components, which
# are built in its init_blocks(); this app has its own UI, so plain keys stand in.
for _name in (
    "state",
    "output_joints_coarse",
    "output_normed_input",
    "output_sample",
    "output_joints",
    "output_bw",
    "output_rest_vis",
    "output_rest_lbs",
    "output_anim_vis",
    "output_anim",
):
    setattr(mia, _name, f"_{_name}")

# Models on cuda at module level: init_models() places them on the device,
# which ZeroGPU emulates here and attaches for real inside the reservation.
mia.init_models()
os.chdir(CODE)

from upsampler_theme import UPSAMPLER_CSS, UPSAMPLER_THEME, footer_html, header_html  # noqa: E402

REST_POSES = {"As it stands": "No", "T-pose": "T-pose", "A-pose": "A-pose"}


def _rig_duration(model_file, rest_pose="As it stands", fingers=True):
    # A warm run is a few seconds of network passes on 32,768 sampled points
    # plus the blend weights of every vertex; declare a typical run, not the
    # worst case (spaces/README.md, ZeroGPU rule 3).
    return 20


@spaces.GPU(duration=_rig_duration)
def _rig_on_gpu(db):
    """Joint localisation, blend weights, bones and pose: the three networks, one reservation."""
    mia.preprocess(db)
    mia.infer(True, db)
    return db


def rig(model_file, rest_pose="As it stands", fingers=True):
    """A humanoid model → the same model with a skeleton and skin weights: (GLB, FBX)."""
    if not model_file:
        raise gr.Error("Upload a 3D model of a humanoid character first.")
    path = model_file if isinstance(model_file, str) else model_file.name
    if os.path.splitext(path)[1].lower() not in INPUT_TYPES:
        raise gr.Error(f"Upload a {', '.join(t[1:].upper() for t in INPUT_TYPES)} file.")
    started = time.time()
    # A folder of its own per run: handlers run at once, and upstream names its outputs after the input file.
    work = tempfile.mkdtemp(prefix="rig-")
    source = os.path.join(work, "model.glb")
    # The weights are matched to Blender's mesh vertex by vertex, and Blender's glTF import merges vertices that
    # are exact duplicates (same place, normal and UV). A model with such duplicates (Quaternius' Casual,
    # 2026-11-08) then had more weights than vertices and failed. They are merged first, the same way; vertices
    # that differ in their UV or normal stay apart, so textures and hard edges are kept.
    mesh = trimesh.load(path, force="mesh")
    if not isinstance(mesh, trimesh.Trimesh) or len(mesh.faces) == 0:
        raise gr.Error("Upload a 3D model with a surface: this file has no faces.")
    mesh.merge_vertices(merge_tex=False, merge_norm=False)
    mesh.export(source)
    db = mia.DB()
    mia.fix_random()
    mia.prepare_input(source, is_gs=False, opacity_threshold=0.0, db=db, export_temp=False)
    if db.faces is not None and len(db.faces) > MAX_INPUT_FACES:
        raise gr.Error(f"The model has {len(db.faces):,} faces; rigging takes up to {MAX_INPUT_FACES:,}. Reduce it first.")
    db = _rig_on_gpu(db)
    mia.vis(bw_fix=True, bw_vis_bone="LeftArm", no_fingers=not fingers, restore_global=True, db=db)
    pose = REST_POSES.get(rest_pose, "No")
    mia.vis_blender(
        reset_to_rest=True,
        remove_fingers=not fingers,
        rest_pose_type=pose if pose != "No" else None,
        ignore_pose_parts=[],
        animation_file=None,
        retarget=False,
        inplace=False,
        restore_global=True,
        db=db,
    )
    # The GLB is the one Blender writes itself, in the rest pose (upstream's "Rest Pose" preview): FBX2glTF's
    # conversion of the FBX came out mirrored, its faces inside out (2026-11-07). FBX2glTF's is the fallback.
    glb = db.rest_vis_path if db.rest_vis_path and os.path.isfile(db.rest_vis_path) else db.anim_vis_path
    fbx = db.anim_path
    if not (glb and os.path.isfile(glb) and fbx and os.path.isfile(fbx)):
        raise gr.Error("The rig could not be exported. Try a single, closed character model.")
    print(f"rigged {os.path.basename(path)} in {time.time() - started:.1f} s")
    return glb, fbx


with gr.Blocks(title="Make-It-Animatable - Free AI Auto Rigging for 3D Characters") as demo:
    gr.HTML(header_html(
        "Make-It-Animatable: Free AI Auto Rigging",
        "Upload a humanoid character and get it back rigged: a Mixamo-named skeleton and skin weights, as GLB and FBX.",
    ))
    with gr.Row():
        with gr.Column():
            model_in = gr.File(label="3D model (GLB, OBJ, PLY or STL)", file_types=INPUT_TYPES)
            with gr.Accordion("Settings", open=False):
                rest_in = gr.Radio(list(REST_POSES), value="As it stands", label="The pose it stands in")
                fingers_in = gr.Checkbox(value=True, label="Finger bones")
            rig_btn = gr.Button("Rig", variant="primary")
        with gr.Column():
            glb_out = gr.Model3D(label="Rigged model (GLB)", clear_color=[0, 0, 0, 0], height=420)
            fbx_out = gr.File(label="Rigged model (FBX)")
    rig_btn.click(rig, inputs=[model_in, rest_in, fingers_in], outputs=[glb_out, fbx_out], api_name="rig")
    gr.HTML(footer_html(
        "Make-It-Animatable rigs a humanoid 3D character in seconds: it places the joints of a Mixamo-compatible "
        "skeleton, fingers included, paints the skin weights of every vertex and returns the model as a GLB and an "
        "FBX ready to animate in Blender, Unity, Unreal or Godot, or with any Mixamo animation.",
        "https://3dvalley.com/tools/fix/auto-rig",
        "free AI auto rigging",
    ))


if __name__ == "__main__":
    # No concurrency limit of our own: see spaces/README.md, ZeroGPU rules 1 and 2.
    demo.queue().launch(
        theme=UPSAMPLER_THEME,
        css=UPSAMPLER_CSS,
        ssr_mode=False,
        show_error=True,
        max_threads=200,
        allowed_paths=[tempfile.gettempdir()],
        prevent_thread_lock=True,
    )
    # Blender (bpy) runs on the main thread only: upstream's export step hands
    # its work to this loop through a queue when called from a request thread.
    print("Main thread entering the Blender task loop")
    while True:
        try:
            task = mia.blender_task_queue.get()
        except KeyboardInterrupt:
            break
        if task is None:
            continue
        args, event, result_box = task
        try:
            import app_blender

            app_blender.main(args)
        except Exception as error:  # handed back to the request that asked
            import traceback

            traceback.print_exc()
            result_box.append(error)
        finally:
            event.set()