src/rig_package/parser/bpy.py

# pyright: reportAttributeAccessIssue=false
from collections import defaultdict
from numpy import ndarray
from PIL import Image
from typing import Optional, Tuple, Dict, List

import bpy # type: ignore
import logging
import numpy as np
import os
import trimesh

from .abstract import AbstractParser
from ..info.asset import Asset
from mathutils import Vector, Matrix # type: ignore

class BpyParser(AbstractParser):
    
    @classmethod
    def load(cls, filepath: str, **kwargs) -> Asset:
        """
        Args:
        
            use_material: if False, do not try loading (baked) textures and vertex_colors. Default True.
            
            resolution: baked image resolution, default 512.
        """
        clean_bpy()
        load(filepath=filepath, **kwargs)

        collection = bpy.data.collections.get("glTF_not_exported")
        if collection is not None and collection.objects is not None:
            for obj in list(collection.objects):
                bpy.data.objects.remove(obj, do_unlink=True)

        armature = get_armature()
        if armature is None:
            bones = None
            joint_names = None
            parents = None
            lengths = None
            matrix_world = np.eye(4)
            matrix_local = None
            matrix_basis = None
            armature_name = None
        else:
            bones = armature.pose.bones # list of PoseBone
            joint_names = [b.name for b in bones]
            parents = []
            lengths = []
            matrix_world = np.array(armature.matrix_world)
            
            matrix_local = []
            for pbone in bones:
                matrix_local.append(np.array(pbone.bone.matrix_local))
                parents.append(joint_names.index(pbone.parent.name) if pbone.parent is not None else -1)
                lengths.append(pbone.bone.length)
            matrix_local = np.stack(matrix_local, axis=0)
            parents = np.array(parents, dtype=np.int32)
            lengths = np.array(lengths, dtype=np.float32)
            
            matrix_basis = get_matrix_basis(armature, bones=bones)
            armature_name = armature.name
        mesh_dict = extract_mesh(
            bones=bones,
            use_material=kwargs.get('use_material', True),
            resolution=kwargs.get('resolution', 512),
        )
        
        return Asset(
            vertices=mesh_dict['vertices'],
            faces=mesh_dict['faces'],
            vertex_normals=mesh_dict['vertex_normals'],
            face_normals=mesh_dict['face_normals'],
            vertex_bias=mesh_dict['vertex_bias'],
            face_bias=mesh_dict['face_bias'],
            mesh_names=mesh_dict['mesh_names'],
            joint_names=joint_names,
            parents=parents,
            lengths=lengths,
            matrix_world=matrix_world,
            matrix_local=matrix_local,
            matrix_basis=matrix_basis,
            armature_name=armature_name,
            skin=mesh_dict['skin'],
            uvs=mesh_dict['uvs'],
            texture=mesh_dict['texture'],
            texture_slot=mesh_dict['texture_slot'],
            _vertex_colors=mesh_dict['_vertex_colors'],
            have_texture=mesh_dict['have_texture'],
        )
    
    @classmethod
    def export(cls, asset: Asset, filepath: str, **kwargs):
        """
        If export obj, kwargs:
            precision: int=6, number of decimal places for vertex coordinates
        
        Otherwise, export fbx/glb/gltf using bpy, kwargs:
            extrude_scale: float=0.5, if there is no tails in asset, first calculate the average length between parents and sons, then the length of leaf bone is l*extrude_scale. Otherwise do not affect final results.
            
            connect_tail_to_unique_child: bool=False, if True, the tail of a bone with only one child will be exactly at the head of its child.
            
            extrude_from_parent: bool=False, if True, the orientation of the leaf bone will be the same as its parent.
            
            group_per_vertex: int=-1, number of the largest weights to keep for each vertex. -1 means keep all.
            
            add_root: bool=False, if True, add a root bone at (0, 0, 0).
            
            do_not_normalize: bool=False, if True, do not normalize the skinning weights.
            
            collection_name: str='new_collection', name of the new collection to store objects.
            
            add_leaf_bones: bool=False, if True, add a leaf bone at the end of each bone.
        """
        ext = os.path.splitext(filepath)[1].lower()
        if ext == '.obj':
            cls.export_obj(asset, filepath, **kwargs)
        elif ext == 'ply':
            cls.export_ply(asset, filepath, **kwargs)
        else:
            cls.export_asset(asset, filepath, **kwargs)
    
    @classmethod
    def export_obj(
        cls,
        asset: Asset,
        filepath: str,
        precision: int=6,
        use_pc: bool=False,
        use_normal: bool=False,
        use_skeleton: bool=False,
        normal_size: float=0.01,
    ):
        """
        Export the asset as an .obj file. This will ignore skeleton and skinning.
        
        Args:
            use_normal: export normals
            
            use_skeleton: export skeleton
        """
        asset._build_bias()
        if asset.vertices is None or asset.vertex_bias is None:
            raise ValueError("do not have vertices or vertex_bias")
        if use_normal and asset.vertex_normals is None:
            raise ValueError("use_normal is True but do not have vertex_normals")
        if not filepath.lower().endswith('.obj'):
            filepath += ".obj"
        faces = asset.faces
        mesh_names = asset.mesh_names
        if mesh_names is None:
            mesh_names = [f"mesh_{i}" for i in range(asset.P)]
        cls._safe_make_dir(filepath)
        file = open(filepath, 'w')
        lines = []
        tot = 0
        if use_skeleton:
            raise NotImplementedError()
        for i, mesh_name in enumerate(mesh_names):
            lines.append(f'o {mesh_name}\n')
            if use_normal:
                s = asset.get_vertex_slice(i)
                for v, n in zip(asset.vertices[s], asset.vertex_normals[s]): # type: ignore
                    vv = v + n * normal_size
                    lines.append(f'v {v[0]:.{precision}f} {v[2]:.{precision}f} {-v[1]:.{precision}f}\n')
                    lines.append(f'v {vv[0]:.{precision}f} {vv[2]:.{precision}f} {-vv[1]:.{precision}f}\n')
                    lines.append(f'v {vv[0]:.{precision}f} {vv[2]:.{precision}f} {-vv[1]+0.000001:.{precision}f}\n')
                    lines.append(f"f {tot+1} {tot+2} {tot+3}\n")
                    tot += 3
            else:
                for v in asset.vertices[asset.get_vertex_slice(i)]:
                    lines.append(f'v {v[0]:.{precision}f} {v[2]:.{precision}f} {-v[1]:.{precision}f}\n')
                if faces is not None and use_pc == False:
                    for f in faces[asset.get_face_slice(i)]:
                        lines.append(f"f {f[0]+1} {f[1]+1} {f[2]+1}\n")
        file.writelines(lines)
        file.close()
    
    @classmethod
    def export_ply(
        cls,
        asset: Asset,
        filepath: str,
        use_pc: bool=False,
        render_skin_id: Optional[int]=None,
    ):
        """
        Export the asset as an .ply file. This will ignore skeleton and skinning.
        """
        import open3d as o3d
        asset._build_bias()
        if asset.vertices is None or asset.vertex_bias is None:
            raise ValueError("do not have vertices or vertex_bias")
        if not filepath.lower().endswith('.ply'):
            filepath += ".ply"
        faces = asset.faces
        if use_pc:
            faces = None
        mesh_names = asset.mesh_names
        if mesh_names is None:
            mesh_names = [f"mesh_{i}" for i in range(asset.P)]
        cls._safe_make_dir(filepath)
        
        if render_skin_id is not None:
            if asset.skin is None:
                raise ValueError("render_skin_id is not None, but skin of asset is None")
            t = asset.skin[:, render_skin_id]
            colors = np.stack([
                np.clip(1.5*t-0.5, 0, 1),
                np.clip(1.5-np.abs(2*t-1), 0, 1),
                np.clip(1-1.5*t, 0, 1),
            ], axis=1)
        else:
            colors = None
        if faces is None:
            pcd = o3d.geometry.PointCloud()
            pcd.points = o3d.utility.Vector3dVector(asset.vertices)
            if colors is not None:
                pcd.colors = o3d.utility.Vector3dVector(colors)
            o3d.io.write_point_cloud(filepath, pcd)
        else:
            mesh = o3d.geometry.TriangleMesh()
            mesh.vertices = o3d.utility.Vector3dVector(asset.vertices)
            mesh.triangles = o3d.utility.Vector3iVector(faces)
            if colors is not None:
                mesh.vertex_colors = o3d.utility.Vector3dVector(colors)
            o3d.io.write_triangle_mesh(filepath, mesh)
    
    @classmethod
    def export_asset(cls, asset: Asset, filepath: str, do_not_export: bool=False, **kwargs):
        clean_bpy()
        images = kwargs.pop('images', None)
        x_offset = kwargs.pop('x_offset', 0)
        collection = make_asset(asset=asset, **kwargs)
        if do_not_export == True:
            return
        if images is not None:
            if isinstance(images, ndarray) and images.ndim==4:
                images = [images[i] for i in range(images.shape[0])]
            if not isinstance(images, list):
                images = [images]
            add_images_as_planes(
                images=images,
                collection=collection,
                y=1,
                z_offset=2,
                plane_half_size=1,
                x_offset=x_offset,
                x_stride=2,
            )
        cls._safe_make_dir(filepath)
        
        _, ext = os.path.splitext(filepath)
        ext = ext.lower()[1:]
        if ext == 'fbx':
            if asset.joints is not None and asset.matrix_basis is not None:
                logging.warning("Exporting animation, but fbx format is deprecated because the rest pose will not be exported in bpy4.2. Use glb/gltf format instead. See: https://blender.stackexchange.com/questions/273398/blender-export-fbx-lose-the-origin-rest-pose.")
            export_dir = os.path.join("tmp_bpy", os.path.dirname(filepath))
            os.makedirs(export_dir, exist_ok=True)
            for img in bpy.data.images:
                if img.source == 'GENERATED' or img.filepath == '':
                    img_path = os.path.join(export_dir, img.name + ".png")
                    img.filepath_raw = img_path
                    img.file_format = 'PNG'
                    img.save()
            bpy.ops.export_scene.fbx(filepath=filepath, check_existing=False, add_leaf_bones=kwargs.get('add_leaf_bones', False), path_mode='COPY', embed_textures=True, mesh_smooth_type="FACE")
        elif ext == 'glb' or ext == 'gltf':
            bpy.ops.export_scene.gltf(filepath=filepath)
        elif ext == 'blend':
            import math
            for w in bpy.context.window_manager.windows:
                for a in w.screen.areas:
                    if a.type == 'VIEW_3D':
                        a.spaces.active.shading.type = 'MATERIAL'
                        for region in a.regions:
                            if region.type != 'WINDOW':
                                continue
                            rv3d = a.spaces.active.region_3d
                            rv3d.view_perspective = 'ORTHO'
                            from mathutils import Quaternion
                            rv3d.view_rotation = Quaternion(
                                (1, 0, 0),  # axis
                                math.pi / 2
                            )
                            center=(0.0, 1.0, 0.0)
                            distance=10.0
                            rv3d.view_location = Vector(center)
                            rv3d.view_distance = distance
            bpy.ops.wm.save_as_mainfile(filepath=filepath)
        else:
            raise ValueError(f"Unsupported format: {ext}")
    
    @classmethod
    def _safe_make_dir(cls, path: str):
        if os.path.dirname(path) == '':
            return
        os.makedirs(os.path.dirname(path), exist_ok=True)

def clean_bpy():
    """Clean all the data in bpy."""
    bpy.ops.outliner.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True)
    data_types = [
        bpy.data.actions,
        bpy.data.armatures,
        bpy.data.cameras,
        bpy.data.collections,
        bpy.data.curves,
        bpy.data.images,
        bpy.data.lights,
        bpy.data.materials,
        bpy.data.meshes,
        bpy.data.objects,
        bpy.data.textures,
        bpy.data.worlds,
        bpy.data.node_groups,
    ]
    for data_collection in data_types:
        for item in data_collection:
            data_collection.remove(item)

def load(filepath: str, **kwargs):
    """Load a 3D file into bpy."""
    _, ext = os.path.splitext(filepath)
    ext = ext.lower()[1:]
    if not os.path.exists(filepath):
        raise RuntimeError(f"file does not exist: {filepath}")
    
    if ext == "obj":
        bpy.ops.wm.obj_import(filepath=filepath)
    elif ext == "fbx":
        bpy.ops.import_scene.fbx(
            filepath=filepath,
            ignore_leaf_bones=kwargs.get('ignore_leaf_bones', False),
            use_image_search=kwargs.get('use_image_search', False),
        )
    elif ext == "glb" or ext == "gltf":
        bpy.ops.import_scene.gltf(filepath=filepath)
        
        col_name = "glTF_not_exported"
        if col_name in bpy.data.collections:
            col = bpy.data.collections[col_name]
            for obj in col.objects:
                bpy.data.objects.remove(obj, do_unlink=True)
            bpy.data.collections.remove(col)

    elif ext == "dae":
        bpy.ops.wm.collada_import(filepath=filepath)
    elif ext == "blend":
        with bpy.data.libraries.load(filepath) as (data_from, data_to):
            data_to.objects = data_from.objects
        for obj in data_to.objects:
            if obj is not None:
                bpy.context.collection.objects.link(obj)
    elif ext == "bvh":
        bpy.ops.import_anim.bvh(filepath=filepath)
    else:
        raise ValueError(f"unsupported type: {ext}")

def get_armature():
    """Get the armature object in the current scene."""
    armatures = [obj for obj in bpy.context.scene.objects if obj.type == 'ARMATURE']
    if len(armatures) == 0:
        return None
    return armatures[0]

def get_all_shader_nodes(meshes, resolution: int) -> Tuple[Dict, ndarray]:
    name_to_image = {}
    have_texture = []
    order = []
    for obj in meshes:
        order.append(obj.name)
        mesh = obj.data
        # TODO: handle geometry node texture
        if len(mesh.uv_layers) == 0:
            have_texture.append(False)
            continue
        ok = False
        for slot in obj.material_slots:
            material = slot.material
            if material.name in name_to_image:
                ok = True
                continue
            if material is None or material.node_tree is None:
                continue
            node_tree = material.node_tree
            nodes = node_tree.nodes
            links = node_tree.links
            
            for node in nodes:
                # TODO: different shader nodes
                # blender can only bake diffuse texture
                if node.type == "BSDF_PRINCIPLED":
                    base_input = node.inputs["Base Color"]
                    if not base_input.is_linked:
                        continue
                    diffuse_node = nodes.new("ShaderNodeBsdfDiffuse")
                    diffuse_node.location = node.location
                    link = base_input.links[0]
                    links.new(link.from_socket, diffuse_node.inputs["Color"])
                    for out_link in node.outputs["BSDF"].links:
                        links.new(diffuse_node.outputs["BSDF"], out_link.to_socket)
                    nodes.remove(node)
            
            image = bpy.data.images.new("tmp_bake", resolution, resolution)
            tex_node = nodes.new("ShaderNodeTexImage")
            tex_node.image = image
            nodes.active = tex_node
            name_to_image[material.name] = image
            ok = True
        have_texture.append(ok)
    have_texture = np.array(have_texture, dtype=bool)
    return name_to_image, have_texture

def get_vertex_colors(mesh) -> ndarray|None:
    N = len(mesh.vertices)
    v_vertex_group = None
    if len(mesh.color_attributes) > 0:
        vcol = mesh.color_attributes[0]
        v_vertex_group = np.ones((N, 3), dtype=np.float32)
        for loop_idx, loop in enumerate(mesh.loops):
            r, g, b, a = vcol.data[loop_idx].color
            v_vertex_group[loop.vertex_index] = [r, g, b]
        return v_vertex_group
    else:
        return None

def get_all_texture_correspondence(meshes, name_to_image: Dict) -> Tuple[Dict[str, ndarray], Dict[str, ndarray]]:
    name_to_id = {s: [] for s in name_to_image}
    name_to_uv = {s: [] for s in name_to_image}
    tri_index = 0
    tot = 0
    for obj in meshes:
        mesh = obj.data
        if len(mesh.uv_layers) == 0:
            continue
        uv_layer = mesh.uv_layers.active.data
        for poly in mesh.polygons:
            if len(obj.material_slots)==0:
                continue
            mat = obj.material_slots[poly.material_index].material
            if mat.name not in name_to_image:
                continue
            start = poly.loop_start
            total = poly.loop_total
            v0 = start
            for v1 in range(start+1, start+total-1):
                v2 = v1 + 1
                def f(i):
                    nonlocal tri_index, tot
                    uv = uv_layer[i].uv
                    name_to_id[mat.name].append(tot)
                    name_to_uv[mat.name].append([uv.x%1.0, uv.y%1.0])
                    tri_index += 1
                    tot += 1
                f(v0)
                f(v1)
                f(v2)
    name_to_id = {s: np.array(name_to_id[s], dtype=np.int32) for s in name_to_id}
    name_to_uv = {s: np.stack(name_to_uv[s], dtype=np.float32) if len(name_to_uv[s]) > 0 else np.zeros((0, 2), dtype=np.float32) for s in name_to_uv}
        
    return name_to_id, name_to_uv

def extract_mesh(bones=None, use_material: bool=True, resolution: int=512):
    """
    Extract vertices, face_normals, faces and skinning(if possible).
    """
    meshes = []
    for v in bpy.data.objects:
        if v.type == 'MESH':
            # skip bad meshes
            if np.abs(np.linalg.det(np.array(v.matrix_world)))**0.333333333333 < 1e-6:
                continue
            if v.parent is not None:
                if np.abs(np.linalg.det(np.array(v.parent.matrix_world)))**0.333333333333 < 1e-6:
                    continue
            meshes.append(v)
    
    index = {}
    if bones is not None:
        for (id, pbone) in enumerate(bones):
            index[pbone.name] = id
        total_bones = len(bones)
    else:
        total_bones = None
    
    mesh_names_list = []
    vertices_list = []
    faces_list = []
    skin_list = []
    vertex_bias = []
    face_bias = []
    cur_vertex_bias = 0
    cur_face_bias = 0
    for obj in meshes:
        # directly apply mesh's transformation because armature operates on the transformed mesh
        if obj.parent is not None:
            m = np.linalg.inv(np.array(obj.parent.matrix_world)) @ np.array(obj.matrix_world)
        else:
            m = np.eye(4)
        matrix_world_rot = m[:3, :3]
        matrix_world_bias = m[:3, 3]
        rot = matrix_world_rot
        total_vertices = len(obj.data.vertices)
        vertices = np.zeros((3, total_vertices))
        if total_bones is not None:
            skin_weight = np.zeros((total_vertices, total_bones))
        else:
            skin_weight = np.zeros((1, 1))
        obj_verts = obj.data.vertices
        obj_group_names = [g.name for g in obj.vertex_groups]
        
        # get faces and normals
        faces = []
        normals = []
        loops = obj.data.loops
        polygons = obj.data.polygons
        for poly in polygons:
            start = poly.loop_start
            total = poly.loop_total
            verts = [loops[i].vertex_index for i in range(start, start + total)]
            v0 = verts[0]
            n = rot @ poly.normal
            for v1, v2 in zip(verts[1:], verts[2:]):
                faces.append((v0, v1, v2))
                normals.append(n)

        faces = np.asarray(faces, dtype=np.int32).reshape(-1, 3)
        normals = np.asarray(normals, dtype=np.float32).reshape(-1, 3)
        
        vg_lut = {}
        for v in obj_verts:
            for g in v.groups:
                vg_lut[(v.index, g.group)] = g.weight
        
        coords = np.array([v.co for v in obj_verts]).reshape(-1, 3)
        rot_np = np.array(rot)
        coords = (rot_np @ coords.T).T + matrix_world_bias
        
        vertices[0:3, :coords.shape[0]] = coords.T
        
        # extract skin
        if bones is not None:
            for bone in bones:
                if bone.name not in obj_group_names:
                    continue
                gidx = obj.vertex_groups[bone.name].index
                col = index[bone.name]
                for v in obj_verts:
                    w = vg_lut.get((v.index, gidx))
                    if w is not None:
                        skin_weight[v.index, col] = w
        
        vertices = vertices.T
        mesh_names_list.append(obj.name)
        vertices_list.append(vertices)
        faces_list.append(faces+cur_vertex_bias) # add bias to faces
        if total_bones is not None:
            skin_list.append(skin_weight)
        cur_vertex_bias += len(vertices)
        cur_face_bias += len(faces)
        vertex_bias.append(cur_vertex_bias)
        face_bias.append(cur_face_bias)
    
    vertices = np.vstack(vertices_list) if len(vertices_list) > 0 else np.zeros((0, 3), dtype=np.float32)
    faces = np.vstack(faces_list) if len(faces_list) > 0 else np.zeros((0, 3), dtype=np.int32)
    mesh = trimesh.Trimesh(vertices=vertices, faces=faces, process=False, maintain_order=True)
    vertex_normals = mesh.vertex_normals
    face_normals = mesh.face_normals
    
    uvs = None
    texture = None
    texture_slot = None
    _vertex_colors = None
    have_texture = None
    if use_material and len(meshes) > 0:
        name_to_image, have_texture = get_all_shader_nodes(meshes, resolution=resolution)
    else:
        name_to_image = {}
        have_texture = {}
    if len(name_to_image) > 0:
        name_to_id, name_to_uv = get_all_texture_correspondence(meshes, name_to_image)
        bpy.ops.object.select_all(action='DESELECT')
        for obj in meshes:
            obj.select_set(True)
        bpy.context.view_layer.objects.active = meshes[0]
        if bpy.context.mode != 'OBJECT':
            bpy.ops.object.mode_set(mode='OBJECT')
        
        ############################ baked image will be black if uv is out of [0, 1]^2
        for obj in meshes:
            mesh = obj.data
            if len(mesh.uv_layers) == 0:
                continue
            uv_layer = mesh.uv_layers.active.data
            for loop_uv in uv_layer:
                u, v = loop_uv.uv
                loop_uv.uv = (u % 1.0, v % 1.0)
        ############################
        
        for i in range(len(have_texture)):
            if not have_texture[i]:
                v = get_vertex_colors(meshes[i].data)
                if _vertex_colors is None:
                    _vertex_colors = np.ones((vertices.shape[0], 3), dtype=np.float32)
                if i == 0:
                    _vertex_colors[:vertex_bias[0]] = v
                else:
                    _vertex_colors[vertex_bias[i-1]:vertex_bias[i]] = v
        _vertex_colors = np.nan_to_num(_vertex_colors) if _vertex_colors is not None else None

        # bake
        bpy.context.scene.render.engine = 'CYCLES'
        bpy.context.scene.cycles.bake_type = 'DIFFUSE'
        bpy.context.scene.render.bake.use_pass_direct = False
        bpy.context.scene.render.bake.use_pass_indirect = False
        bpy.context.scene.render.bake.use_pass_color = True
        # bpy.ops.object.bake(type='DIFFUSE')
        valid_objects = [
            obj for obj in bpy.context.selected_objects
            if obj.type == 'MESH' and obj.data.uv_layers
        ]
        bpy.ops.object.select_all(action='DESELECT')
        for obj in valid_objects:
            obj.select_set(True)
        if valid_objects:
            bpy.context.view_layer.objects.active = valid_objects[0]
            try:
                bpy.ops.object.bake(type='DIFFUSE')
            except:
                logging.warning("Baking failed!!!")
        
        bpy.ops.object.select_all(action='DESELECT')
        
        # ######################
        # debug: export baked images to ./tmp_delete/1.png, 2.png, ...
        # dbg_dir = os.path.join(os.getcwd(), "tmp_delete")
        # os.makedirs(dbg_dir, exist_ok=True)
        # for idx, img in enumerate(name_to_image.values(), start=1):
        #     img.filepath_raw = os.path.join(dbg_dir, f"{idx}.png")
        #     img.file_format = 'PNG'
        #     img.save()
        # ######################

        bpy.ops.object.select_all(action='DESELECT')
        
        # concat textures
        images = []
        where = {}
        for name, img in name_to_image.items():
            where[name] = len(images)
            images.append(img)
        
        num_images = len(images)
        texture = np.ones((resolution, resolution*num_images, 3), dtype=np.float32) # white texture
        texture_slot = np.zeros(len(faces)*3, dtype=np.int32)
        uvs = np.zeros((len(faces)*3, 2), dtype=np.float32)
        for i, img in enumerate(images):
            pixels = np.array(img.pixels[:], dtype=np.float32)
            pixels = pixels.reshape(resolution, resolution, 4)[..., :3]
            texture[:, i*resolution:(i+1)*resolution, :] = pixels
        
        for name in name_to_id:
            id = name_to_id[name]
            uv = name_to_uv[name]
            pos = where[name]
            uv[:, 0] = uv[:, 0] / num_images + pos / num_images 
            uvs[id] = uv
            texture_slot[id] = pos
        uvs = uvs % 1.0
    
    return {
        'mesh_names': np.array(mesh_names_list),
        'vertices': vertices,
        'faces': faces,
        'face_normals': face_normals,
        'vertex_normals': vertex_normals,
        'skin': np.vstack(skin_list) if len(skin_list) > 0 else None,
        'vertex_bias': np.array(vertex_bias),
        'face_bias': np.array(face_bias),
        'uvs': uvs,
        'texture': texture,
        'texture_slot': texture_slot,
        '_vertex_colors': _vertex_colors,
        'have_texture': have_texture,
    }

def get_matrix_basis(armature, bones=None):
    if bones is None or len(bones) == 0:
        return None
    actions = bpy.data.actions
    if actions is None or len(actions) == 0:
        return None
    J = len(bones)
    all_frames = []
    
    if not hasattr(armature, 'animation_data') or armature.animation_data is None:
        return None
    orig_action = armature.animation_data.action
    for action in actions:
        armature.animation_data.action = action
        start = int(action.frame_range[0])
        end   = int(action.frame_range[1])
        for frame in range(start, end + 1):
            bpy.context.scene.frame_set(frame)
            mat = np.zeros((J, 4, 4), dtype=np.float32)
            for j, pbone in enumerate(bones):
                mat[j] = np.array(pbone.matrix_basis) # remember to normalize rot (in case matrix_local != identity)
            all_frames.append(mat)
    armature.animation_data.action = orig_action
    m = np.stack(all_frames, axis=0)
    
    mask = np.linalg.det(m[..., :3, :3]) > 1e-6
    m[~mask] = np.eye(4)
    m[..., :3, :3] = m[..., :3, :3] / np.linalg.norm(m[..., :3, :3], axis=-2, keepdims=True)
    return m

###################################
# DIRTY DEBUG CODE BEGIN
###################################
def _to_rgb_uint8(img):
    """PIL.Image or np.ndarray -> (H, W, 3) uint8"""
    if isinstance(img, Image.Image):
        img = np.array(img)
    if img.ndim == 2:
        img = np.repeat(img[..., None], 3, axis=-1)
    elif img.ndim == 3:
        
        if img.shape[2] == 1:
            img = np.repeat(img, 3, axis=-1)
        elif img.shape[2] == 4:
            img = img[..., :3]
    assert img.ndim == 3 and img.shape[2] == 3
    return img.astype(np.uint8)

def _create_plane_mesh(name: str, x: float, y: float, z: float, x_offset: float, z_offset: float, collection):
    """(-x+offset, y, -z+offset) to (x+offset, y, z+offset)"""
    mesh = bpy.data.meshes.new(name)
    verts = [
        (-x+x_offset, y,  z+z_offset),
        ( x+x_offset, y,  z+z_offset),
        ( x+x_offset, y, -z+z_offset),
        (-x+x_offset, y, -z+z_offset),
    ]
    mesh.from_pydata(verts, [], [(0, 1, 2, 3)])
    mesh.update()
    mesh.uv_layers.new(name="UVMap")
    uv_data = mesh.uv_layers.active.data
    uv_data[0].uv = (0.0, 0.0)
    uv_data[1].uv = (1.0, 0.0)
    uv_data[2].uv = (1.0, 1.0)
    uv_data[3].uv = (0.0, 1.0)
    obj = bpy.data.objects.new(name, mesh)
    collection.objects.link(obj)
    return obj

def _create_material_from_np(name, img_np):
    h, w, _ = img_np.shape
    rgba = np.ones((h, w, 4), dtype=np.uint8) * 255
    rgba[..., :3] = img_np
    img = bpy.data.images.new(
        name=name,
        width=w,
        height=h,
        alpha=False,
        float_buffer=False,
    )
    img.pixels = (rgba.reshape(-1) / 255.0).tolist()
    mat = bpy.data.materials.new(name + "_mat")
    mat.use_nodes = True
    nodes = mat.node_tree.nodes
    links = mat.node_tree.links
    nodes.clear()
    tex = nodes.new("ShaderNodeTexImage")
    tex.image = img
    bsdf = nodes.new("ShaderNodeBsdfPrincipled")
    out = nodes.new("ShaderNodeOutputMaterial")
    links.new(tex.outputs["Color"], bsdf.inputs["Base Color"])
    links.new(bsdf.outputs["BSDF"], out.inputs["Surface"])
    img.pack()
    return mat

def add_images_as_planes(
    images,
    collection,
    y: float=1.0,
    x_offset: float=0.0,
    z_offset: float=2.0,
    plane_half_size: float=1.0,
    x_stride: float=2.0,
):
    for i, img in enumerate(images):
        rgb = _to_rgb_uint8(img)
        obj = _create_plane_mesh(
            name=f"ImagePlane_{i}",
            x=plane_half_size,
            y=y,
            z=plane_half_size,
            x_offset=i*x_stride+x_offset,
            z_offset=z_offset,
            collection=collection,
        )
        mat = _create_material_from_np(f"Image_{i}", rgb)
        obj.data.materials.append(mat)

###################################
# DIRTY DEBUG CODE END
###################################

def set_vertex_colors(mesh, vertex_colors, layer_name: str="vertex_colors", mat_name: str="mat_vertex_colors"):
    mesh.materials.clear()
    vcol = mesh.color_attributes.new(name=layer_name, type="BYTE_COLOR", domain="POINT")
    if vcol is not None:
        assert len(mesh.vertices) == len(vertex_colors), "length of vertex_colors does not match mesh.vertices"
        for j in range(len(vertex_colors)):
            r, g, b = vertex_colors[j]
            vcol.data[j].color = (r, g, b, 1.0)
        mat = bpy.data.materials.new(mat_name)
        mat.use_nodes = True
        
        nt = mat.node_tree
        nodes = nt.nodes
        links = nt.links
        nodes.clear()
        
        attr_node = nodes.new("ShaderNodeAttribute")
        attr_node.attribute_name = layer_name
        attr_node.location = (-600, 0)
        
        bsdf = nodes.new("ShaderNodeBsdfPrincipled")
        bsdf.location = (-300, 0)
        
        output = nodes.new("ShaderNodeOutputMaterial")
        output.location = (0, 0)
        
        links.new(attr_node.outputs["Color"], bsdf.inputs["Base Color"])
        links.new(bsdf.outputs["BSDF"], output.inputs["Surface"])
        
        mesh.materials.append(mat)
    mesh.update()

# one mesh, one uv, multiple textures
def set_texture(meshes, uvs: ndarray, texture: ndarray, slots: ndarray, have_texture: ndarray, uv_name: str="uv", mat_name: str="mat"):
    assert uvs.shape[0] == slots.shape[0]
    
    h, w_full, _ = texture.shape
    num_images = w_full // h
    if num_images == 0:
        return
    w = w_full // num_images
    
    images = []
    materials = []
    for i in range(num_images):
        image = bpy.data.images.new(
            name=f"{mat_name}_{i}",
            width=w,
            height=h,
        )
        
        rgba = np.ones((h, w, 4), dtype=np.float32)
        rgba[:, :, :3] = texture[:, i*w:(i+1)*w, :]
        image.pixels = rgba.flatten()
        images.append(image)
        
        mat = bpy.data.materials.new(f"{mat_name}_{i}")
        mat.use_nodes = True
        
        nt = mat.node_tree
        nodes = nt.nodes
        links = nt.links
        nodes.clear()
        
        tex_node = nodes.new("ShaderNodeTexImage")
        tex_node.image = image
        tex_node.location = (-600, 0)
        
        bsdf = nodes.new("ShaderNodeBsdfPrincipled")
        bsdf.location = (-300, 0)
        
        output = nodes.new("ShaderNodeOutputMaterial")
        output.location = (0, 0)
        
        links.new(tex_node.outputs["Color"], bsdf.inputs["Base Color"])
        links.new(bsdf.outputs["BSDF"], output.inputs["Surface"])
        
        materials.append(mat)
    
    tri_index = 0
    for i, mesh in enumerate(meshes):
        if not have_texture[i]:
            # TODO: faster?
            for poly in mesh.polygons:
                start = poly.loop_start
                total = poly.loop_total
                tri_index += (total-2) * 3
            continue
        mesh.materials.clear()
    
        for mat in materials:
            mesh.materials.append(mat)
        while len(mesh.uv_layers) > 0:
            mesh.uv_layers.remove(mesh.uv_layers[0])
        uv_layer = mesh.uv_layers.new(name=uv_name)
        mesh.uv_layers.active = uv_layer
        uv_data = uv_layer.data
        
        for poly in mesh.polygons:
            start = poly.loop_start
            total = poly.loop_total
            
            loops = list(range(start, start + total))
            v0 = loops[0]
            first_slot = slots[tri_index]
            if first_slot >= num_images:
                first_slot = 0
            poly.material_index = first_slot
            for i in range(1, total - 1):
                v1 = loops[i]
                v2 = loops[i + 1]
                for loop_id in (v0, v1, v2):
                    u, v = uvs[tri_index]
                    u = u * num_images - poly.material_index
                    uv_data[loop_id].uv = (u, v)
                    tri_index += 1
            mesh.update()

def make_asset(
    asset: Asset,
    extrude_scale: float=0.5,
    connect_tail_to_unique_child: bool=False,
    extrude_from_parent: bool=False,
    use_simple_tails: bool=False,
    group_per_vertex: int=-1,
    add_root: bool=False,
    do_not_normalize: bool=False,
    collection_name: str='new_collection',
    use_vertices: bool=True,
    use_faces: bool=True,
    use_animation: bool=True,
    use_material: bool=True,
):
    """
    Args:
    
        extrude_scale: float=0.5, if there is no tails in asset, first calculate the average length between parents and sons, then the length of leaf bone is l*extrude_scale. Otherwise do not affect final results.
        
        connect_tail_to_unique_child: bool=False, if True, the tail of a bone with only one child will be exactly at the head of its child.
        
        extrude_from_parent: bool=False, if True, the orientation of the leaf bone will be the same as its parent.
        
        use_simple_tails: if True, add tails along the axis.
        
        group_per_vertex: int=-1, number of the largest weights to keep for each vertex. -1 means keep all.
        
        add_root: bool=False, if True, add a root bone at (0, 0, 0).
        
        do_not_normalize: bool=False, if True, do not normalize the skinning weights.
        
        collection_name: str='new_collection', name of the new collection to store objects.
        
        use_vertices: bool=True, if False, do not export vertices.
        
        use_faces: bool=True, if False, do not export faces.
        
        use_animation: bool=True, if False, do not export animation.
        
        use_material: bool=True, if False, do not export material.
    """
    
    def to_matrix(x: ndarray):
        return Matrix((x[0, :], x[1, :], x[2, :], x[3, :]))
    
    collection = bpy.data.collections.new(collection_name)
    bpy.context.scene.collection.children.link(collection)
    
    # 1. if there are meshes, make meshes
    objects = []
    if use_vertices and asset.vertices is not None:
        if asset.mesh_names is not None:
            mesh_names = asset.mesh_names
        else:
            mesh_names = [f"mesh_{i}" for i in range(asset.P)]
        
        meshes = []
        for i in range(asset.P):
            mesh = bpy.data.meshes.new(mesh_names[i])
            meshes.append(mesh)
            v = asset.vertices[asset.get_vertex_slice(i)]
            if not use_faces or (asset.faces is None or asset.face_bias is None or asset.vertex_bias is None):
                mesh.from_pydata(v, [], [])
            else:
                if i == 0:
                    mesh.from_pydata(v, [], asset.faces[asset.get_face_slice(i)])
                else:
                    mesh.from_pydata(v, [], asset.faces[asset.get_face_slice(i)]-asset.vertex_bias[i-1])
            if use_material and asset._vertex_colors is not None:
                if asset.have_texture is None or not asset.have_texture[i]:
                    set_vertex_colors(mesh, asset._vertex_colors[asset.get_vertex_slice(i)], layer_name=f"vcol_{i}", mat_name=f"mat_vcol_{i}")
            mesh.update()
            
            # make object from mesh
            object = bpy.data.objects.new(mesh_names[i], mesh)
            objects.append(object)
            
            # add object to scene collection
            collection.objects.link(object)
        if use_material and asset.uvs is not None and asset.texture is not None and asset.texture_slot is not None and asset.have_texture is not None:
            set_texture(meshes, asset.uvs, asset.texture, asset.texture_slot, asset.have_texture)
    
    # 2. if there is armature, process tails and make armature
    armature = None
    armature_name = 'Armature'
    joint_names = asset.joint_names if asset.joint_names is not None else [f"bone_{i}" for i in range(asset.J)]
    if asset.joints is not None and asset.parents is not None:
        
        joints = asset.joints
        length_sum = 0.
        sons = defaultdict(list)
        for i in range(len(asset.parents)):
            p = asset.parents[i]
            if p == -1:
                continue
            sons[p].append(i)
            length_sum += np.linalg.norm(joints[i] - joints[p])
        if asset.J <= 1:
            length = 1.0
        else:
            length_avg = length_sum / max(len(asset.parents) - 1, 1)
            length = length_avg * extrude_scale
        
        tails = asset.tails
        if use_simple_tails and tails is None:
            asset.lengths = np.ones((asset.J)) * length
            tails = asset.tails
            connect_tail_to_unique_child = False
            extrude_from_parent = False
        if tails is None:
            tails = joints.copy()
            connect_tail_to_unique_child = True
            extrude_from_parent = True
        
        root_tail = False
        root_id = asset.root
        
        for i in range(len(asset.parents)):
            p = asset.parents[i]
            if p == -1:
                continue
            d = np.linalg.norm(joints[i] - joints[p])
            if d <= length * 1e-2:
                max_d = max(length, 1e-5)
                joints[i] += np.random.randn(3) * max_d * 1e-2
        if connect_tail_to_unique_child:
            for i in range(len(asset.parents)):
                if len(sons[i]) == 1:
                    child = sons[i][0]
                    tails[i] = joints[child]
                    if root_id == i:
                        root_tail = True
        
        if extrude_from_parent:
            for i in range(len(asset.parents)):
                if len(sons[i]) != 1 and asset.parents[i] != -1:
                    p = asset.parents[i]
                    d = joints[i] - joints[p]
                    if np.linalg.norm(d) < 1e-6:
                        d = np.array([0., 0., 1.]) # in case son.head == parent.head
                    else:
                        d = d / np.linalg.norm(d)
                    tails[i] = joints[i] + d * length
        if root_tail is False:
            tails[root_id] = joints[root_id] + np.array([0., 0., length])
        bpy.ops.object.armature_add(enter_editmode=True)
        armature = bpy.data.armatures.get('Armature')
        armature_name = asset.armature_name if asset.armature_name is not None else 'Armature'
        armature.name = armature_name
        bpy.data.objects['Armature'].name = armature_name
        
        edit_bones = armature.edit_bones
        
        if add_root:
            bone_root = edit_bones.get('Bone')
            root_name = 'Root'
            x = 0
            while root_name in joint_names:
                root_name = f'Root_{x}'
                x += 1
            bone_root.name = root_name
            bone_root.tail = Vector((joints[0, 0], joints[0, 1], joints[0, 2]))
        else:
            bone_root = edit_bones.get('Bone')
            bone_root.name = joint_names[0]
            bone_root.head = Vector((joints[0, 0], joints[0, 1], joints[0, 2]))
            bone_root.tail = Vector((tails[0, 0], tails[0, 1], tails[0, 2]))
        
        def extrude_bone(
            edit_bones,
            name: str,
            parent_name: str,
            head: Tuple[float, float, float],
            tail: Tuple[float, float, float],
        ):
            bone = edit_bones.new(name)
            bone.head = Vector((head[0], head[1], head[2]))
            bone.tail = Vector((tail[0], tail[1], tail[2]))
            bone.name = name
            parent_bone = edit_bones.get(parent_name)
            bone.parent = parent_bone
            bone.use_connect = False
            assert not np.isnan(head).any(), f"nan found in head of bone {name}"
            assert not np.isnan(tail).any(), f"nan found in tail of bone {name}"
        
        for u in asset.dfs_order:
            if add_root is False and u==0:
                continue
            pname = joint_names[u] if asset.parents[u] == -1 else joint_names[asset.parents[u]]
            extrude_bone(edit_bones, joint_names[u], pname, joints[u], tails[u])
        bpy.ops.object.mode_set(mode='OBJECT')
    
    # 3. if there is skin, set vertex groups
    if asset.skin is not None and armature is not None and len(objects) > 0:
        if bpy.context.mode != 'OBJECT':
            bpy.ops.object.mode_set(mode='OBJECT')
        armature_obj = bpy.data.objects.get(armature_name)
        if not armature_obj:
            raise ValueError(f"Armature {armature_name} not found")
        all_objects = bpy.data.objects 
        for i in range(len(objects)):
            skin_slice = asset.skin[asset.get_vertex_slice(i)]
            ob_name = mesh_names[i]
            ob = all_objects.get(ob_name)
            if ob is None:
                continue
            ob.select_set(True)
            armature_obj.select_set(True)
            bpy.ops.object.parent_set(type='ARMATURE_NAME')
            argsorted = np.argsort(-skin_slice, axis=1)
            current_group_per_vertex = min(group_per_vertex, skin_slice.shape[1])
            if group_per_vertex == -1:
                current_group_per_vertex = skin_slice.shape[-1]
            top_indices = argsorted[:, :current_group_per_vertex]
            row_indices = np.arange(skin_slice.shape[0])[:, None]
            top_weights = skin_slice[row_indices, top_indices]
            if not do_not_normalize:
                weight_sums = top_weights.sum(axis=1, keepdims=True)
                weight_sums[weight_sums == 0] = 1.0 
                top_weights /= weight_sums
            vg_lookup = []
            for j_name in joint_names:
                vg = ob.vertex_groups.get(j_name)
                if not vg:
                    vg = ob.vertex_groups.new(name=j_name)
                vg_lookup.append(vg)
            for v in range(len(skin_slice)):
                for k in range(current_group_per_vertex):
                    joint_idx = top_indices[v, k]
                    weight_val = top_weights[v, k]
                    vg_lookup[joint_idx].add([v], weight_val, 'REPLACE')
    
    if armature_name in bpy.data.objects:
        armature = bpy.data.objects[armature_name]
        armature.select_set(True)
        if asset.matrix_world is not None:
            matrix_world = to_matrix(asset.matrix_world)
        else:
            matrix_world = to_matrix(np.eye(4))
        armature.matrix_world = matrix_world
    
    # 4. if there is animation, set keyframes
    if use_animation and asset.matrix_basis is not None and asset.matrix_local is not None and armature is not None:
        matrix_basis = asset.matrix_basis
        matrix_local = asset.matrix_local
        objects = bpy.data.objects
        for o in bpy.context.selected_objects:
            o.select_set(False)
        frames = matrix_basis.shape[0]
        
        # change matrix_local
        bpy.context.view_layer.objects.active = armature
        bpy.ops.object.mode_set(mode='EDIT')
        for (id, name) in enumerate(joint_names):
            # matrix_local of pose bone
            bpy.context.active_object.data.edit_bones.get(name).matrix = to_matrix(matrix_local[id])
        bpy.ops.object.mode_set(mode='OBJECT')
        for (id, name) in enumerate(joint_names):
            pbone = armature.pose.bones.get(name)
            for frame in range(frames):
                bpy.context.scene.frame_set(frame + 1)
                q = to_matrix(matrix_basis[frame, id])
                if pbone.rotation_mode == "QUATERNION":
                    pbone.rotation_quaternion = q.to_quaternion()
                    pbone.keyframe_insert(data_path = 'rotation_quaternion')
                else:
                    pbone.rotation_euler = q.to_euler()
                    pbone.keyframe_insert(data_path = 'rotation_euler')
                pbone.location = q.to_translation()
                pbone.keyframe_insert(data_path = 'location')
        bpy.ops.object.mode_set(mode='OBJECT')
    return collection