dmodel functions

    def create_all_drawable_models(self):
        """Create all drawable models and parent them to the drawable."""
        if not self.materials:
            self.create_materials()

        for models_group, lod_level in zip(self.cwxml.drawable_model_groups, list(LODLevel)):
            for model_cwxml in models_group:
                self.create_drawable_model(model_cwxml, lod_level)
                # armature = None
                # if self.cwxml.has_skeleton() and not self.uses_external_skeleton:
                #     armature = self.bpy_object

                # model_converter = ModelCWXMLConverter(
                #     model_cwxml, lod_level, self.materials, armature, self.bones_cwxml)

                # model = model_converter.create_bpy_object()
                # model.parent = self.bpy_object

    def create_materials(self):
        """Create all materials from this drawable's cwxml shader group."""
        for shader_cwxml in self.cwxml.shader_group.shaders:
            material = ShaderCWXMLConverter(
                shader_cwxml, self.filepath, self.cwxml.shader_group.texture_dictionary).create_bpy_object()
            self.materials.append(material)

    def create_drawable_model(self, model_cwxml: ydrxml.DrawableModelItem, lod_level: int):
        geometry_objs = []

        for geometry_cwxml in model_cwxml.geometries:
            name = SOLLUMZ_UI_NAMES[SollumType.DRAWABLE_MODEL]
            geometry = GeometryCWXMLConverter(
                geometry_cwxml, self.materials).create_bpy_object(name, self.bones)

            geometry_objs.append(geometry)

        model_object = join_objects(geometry_objs)

        model_object.drawable_model_properties.sollum_lod = lod_level
        model_object.drawable_model_properties.render_mask = model_cwxml.render_mask
        model_object.drawable_model_properties.unknown_1 = model_cwxml.unknown_1
        model_object.drawable_model_properties.flags = model_cwxml.flags

        if self.cwxml.has_skeleton() and not self.uses_external_skeleton:
            self.parent_drawable_model_bones(
                model_object, model_cwxml.bone_index)

    def parent_drawable_model_bones(self, model_object: bpy.types.Object, bone_index: int):
        """Set drawable model parent bone based on its bone index."""
        armature = self.bpy_object

        if armature.type != "ARMATURE":
            return

        parent_bone_name = None
        has_bone_translation = False

        if len(armature.pose.bones) > bone_index:
            parent_bone_name = armature.pose.bones[bone_index].name
            translation: Vector = self.bones_cwxml[bone_index].translation

            if translation is not None and translation.magnitude > 0:
                has_bone_translation = True

        if parent_bone_name is not None:
            # Preserve transforms after parenting
            original_world_mat = model_object.matrix_world.copy()

            model_object.parent_type = "BONE"
            model_object.parent_bone = parent_bone_name

            if has_bone_translation is False:
                model_object.matrix_world = original_world_mat