Function materialize_inline_meshes

Scripts/clean_meshes.py:220–290

Rewrite `` `` (MuJoCo's inline-data form) to `` `` by emitting an OBJ next to the rest of the mesh assets. Returns the number of inline meshes materialized. MuJoCo accepts meshes declared inline via ``vertex`` (flat list of 3-tuple floats

(root, mesh_base: Path)

    elif elem.tag == "compiler":
        # Paths are now baked into each file=, so clear the dir prefixes.
        for attr in ("meshdir", "texturedir", "assetdir"):
            new_elem.attrib.pop(attr, None)

    for child in list(elem):
        _append_expanded(new_elem, child, src_dir, root_dir,
                         meshdir, texturedir, assetdir, visited)


def flatten_includes(root, root_dir: Path):
    """Resolve every <include> into a single self-contained <mujoco> tree.

    gym-aloha (and many MJCF models) split a robot across <include> fragments
    rooted in <mujocoinclude>, including files referenced from inside <worldbody>.
    Unreal&#x27;s importer must see one flat document so all <asset>/<compiler>/body
    content is visible and there is exactly one worldbody. Returns the new root
    element (a <mujoco>). No-op-equivalent for files without includes.
    """
    md, txd, ad = _compiler_dirs(root)
    visited = set()
    new_root = ET.Element("mujoco", dict(root.attrib))
    for child in list(root):
        _append_expanded(new_root, child, root_dir, root_dir, md, txd, ad, visited)
    return new_root


def materialize_inline_meshes(root, mesh_base: Path) -> int:
    """Rewrite ``<mesh vertex="..." face="...">`` (MuJoCo&#x27;s inline-data form)
    to ``<mesh file="...">`` by emitting an OBJ next to the rest of the
    mesh assets. Returns the number of inline meshes materialized.

    MuJoCo accepts meshes declared inline via ``vertex`` (flat list of
    3-tuple floats) and ``face`` (flat list of 3-tuple ints) attributes
    instead of an external ``file``. Unreal's importer can't follow the
    inline form, so we synthesize a real OBJ on disk and rewrite the
    ``<mesh>`` element to point at it. The downstream conversion phase
    then produces a GLB companion just like any other ``file=`` mesh.
    """
    materialized = 0
    mesh_base.mkdir(parents=True, exist_ok=True)
    for mesh_el in list(root.iter("mesh")):
        if mesh_el.get("file"):
            continue
        vertex_attr = mesh_el.get("vertex")
        face_attr = mesh_el.get("face")
        if not vertex_attr or not face_attr:
            continue

        name = mesh_el.get("name")
        if not name:
            print(f"  x Inline mesh has no name; skipping (cannot synthesize filename)")
            continue

        try:
            verts = _parse_floats(vertex_attr)
            faces = [int(t) for t in face_attr.replace(",", " ").split() if t]
        except ValueError as e:
            print(f"  x Failed to parse vertex/face for '{name}': {e}")
            continue