feat: add xbox mesh importing

Author: mixiate

README.md

@@ -15,5 +15,6 @@ Blender 4.1.1 is supported.
 - CFP file compression
 - Mesh cleanup option
 - File search directory option
+- Import console version meshes (Xbox only)
 
 You can find out how to use the add-on in the [wiki](https://github.com/mixsims/ts1-blender-io/wiki).

addons/io_scene_ts1/__init__.py

@@ -4,7 +4,7 @@
     "name": "The Sims 1 3D Formats",
     "description": "Imports and exports The Sims 1 meshes and animations.",
     "author": "mix",
-    "version": (1, 0, 3),
+    "version": (1, 1, 0),
     "blender": (4, 1, 0),
     "location": "File > Import-Export",
     "warning": "",
@@ -34,13 +34,13 @@ class TS1IOImport(bpy.types.Operator, bpy_extras.io_utils.ImportHelper):
 
     bl_idname: str = "import.bcf"
     bl_label: str = "Import The Sims 1 meshes and animations"
-    bl_description: str = "Import a cmx or bcf file from The Sims 1"
+    bl_description: str = "Import a cmx/bcf or xbm file from The Sims 1"
     bl_options: typing.ClassVar[set[str]] = {'UNDO'}
 
     filename_ext = ".cmx.bcf"
 
     filter_glob: bpy.props.StringProperty(  # type: ignore[valid-type]
-        default="*.cmx;*.cmx.bcf",
+        default="*.xbm;*.cmx;*.cmx.bcf",
         options={'HIDDEN'},
     )
     files: bpy.props.CollectionProperty(  # type: ignore[valid-type]
@@ -214,7 +214,7 @@ def draw(self, _: bpy.context) -> None:
 
 def menu_import(self: bpy.types.TOPBAR_MT_file_import, _: bpy.context) -> None:
     """Add an entry to the import menu."""
-    self.layout.operator(TS1IOImport.bl_idname, text="The Sims 1 (.cmx/.bcf)")
+    self.layout.operator(TS1IOImport.bl_idname, text="The Sims 1 (.cmx/.bcf/.xbm)")
 
 
 def menu_export(self: bpy.types.TOPBAR_MT_file_export, _: bpy.context) -> None:
@@ -234,9 +234,17 @@ class TS1IOAddonPreferences(bpy.types.AddonPreferences):
         default="",
     )
 
+    file_search_directory_xbox: bpy.props.StringProperty(  # type: ignore[valid-type]
+        name="Xbox Textures",
+        description="Directory that will be searched to find textures for xbox meshes",
+        subtype='DIR_PATH',
+        default="",
+    )
+
     def draw(self, _: bpy.context) -> None:
         """Draw the addon preferences ui."""
         self.layout.prop(self, "file_search_directory")
+        self.layout.prop(self, "file_search_directory_xbox")
 
 
 classes = (

addons/io_scene_ts1/import_ts1.py

@@ -8,12 +8,14 @@
 import mathutils
 import pathlib
 import re
+import contextlib
 
 
 from . import bcf
 from . import bmf
 from . import cfp
 from . import cmx
+from . import xbm
 from . import skn
 from . import texture_loader
 from . import utils
@@ -531,7 +533,113 @@ def import_skill(  # noqa: C901 PLR0912 PLR0915
     armature_object.animation_data.action = original_action
 
 
-def import_files(  # noqa: C901 PLR0912 PLR0913
+def import_xbox_model(  # noqa: C901 PLR0912 PLR0915
+    context: bpy.types.Context,
+    logger: logging.Logger,
+    file_path: pathlib.Path,
+    xbox_texture_file_list: list[pathlib.Path],
+) -> None:
+    """Import an xbox model file."""
+    try:
+        model_desc = xbm.read_file(file_path)
+    except utils.FileReadError as _:
+        logger.info(f"Could not load xbox mesh {file_path}")  # noqa: G004
+        return
+
+    file_collection = bpy.data.collections.get(model_desc.name)
+    if file_collection is None:
+        file_collection = bpy.data.collections.new(model_desc.name)
+
+    if file_collection.name not in context.collection.children:
+        context.collection.children.link(file_collection)
+
+    for object_index, object_desc in enumerate(model_desc.objects):
+        object_collection_name = f"{model_desc.name} {object_index}"
+
+        object_collection = bpy.data.collections.get(object_collection_name)
+        if object_collection is None:
+            object_collection = bpy.data.collections.new(object_collection_name)
+
+        if object_collection.name not in file_collection.children:
+            file_collection.children.link(object_collection)
+
+        for mesh_index, mesh_desc in enumerate(object_desc.meshes):
+            mesh_name = f"{model_desc.name} {object_index} {mesh_index}"
+
+            mesh = bpy.data.meshes.new(mesh_name)
+            obj = bpy.data.objects.new(mesh_name, mesh)
+
+            object_collection.objects.link(obj)
+
+            b_mesh = bmesh.new()
+
+            for vertex in mesh_desc.positions:
+                position = mathutils.Vector(vertex.position)
+                b_mesh.verts.new(position)
+
+            b_mesh.verts.ensure_lookup_table()
+            b_mesh.verts.index_update()
+
+            if len(mesh_desc.faces):
+                for i in range(len(mesh_desc.faces) - 2):
+                    with contextlib.suppress(ValueError):
+                        b_mesh.faces.new(
+                            (
+                                b_mesh.verts[mesh_desc.faces[i + 2]],
+                                b_mesh.verts[mesh_desc.faces[i + 1]],
+                                b_mesh.verts[mesh_desc.faces[i + 0]],
+                            ),
+                        )
+
+            deform_layer = b_mesh.verts.layers.deform.verify()
+
+            for index, strip in enumerate(mesh_desc.strips):
+                vertex_group = obj.vertex_groups.new(name=str(index))
+
+                for i in range(strip[0], strip[1] - 2):
+                    vert_a = b_mesh.verts[i + 0]
+                    vert_b = b_mesh.verts[i + 1]
+                    vert_c = b_mesh.verts[i + 2]
+
+                    vert_a[deform_layer][vertex_group.index] = 1.0
+                    vert_b[deform_layer][vertex_group.index] = 1.0
+                    vert_c[deform_layer][vertex_group.index] = 1.0
+
+                    if vert_a.co != vert_b.co and vert_a.co != vert_c.co and vert_b.co != vert_c.co:  # noqa: PLR1714
+                        b_mesh.faces.new((vert_a, vert_b, vert_c))
+
+            if len(mesh_desc.uvs):
+                uv_layer = b_mesh.loops.layers.uv.verify()
+                for face in b_mesh.faces:
+                    for loop in face.loops:
+                        loop[uv_layer].uv = mesh_desc.uvs[loop.vert.index]
+
+            b_mesh.to_mesh(mesh)
+            b_mesh.free()
+
+            if len(mesh_desc.normals) > 0:
+                mesh.normals_split_custom_set_from_vertices(mesh_desc.normals)
+
+                for polygon in mesh.polygons:
+                    if polygon.normal.dot(mathutils.Vector(mesh_desc.normals[polygon.vertices[0]])) < 0.0:
+                        polygon.flip()
+
+                mesh.normals_split_custom_set_from_vertices(mesh_desc.normals)
+
+                mesh.update()
+
+            texture_id_string = f'{mesh_desc.texture_id:x}'
+            for file_path in xbox_texture_file_list:
+                if file_path.stem.endswith(texture_id_string):
+                    texture_loader.create_material(obj, file_path.stem, file_path)
+
+            if not obj.data.materials:
+                for file_path in xbox_texture_file_list:
+                    if file_path.stem.lower().startswith(f"{model_desc.name.lower()} "):
+                        texture_loader.create_material(obj, file_path.stem, file_path)
+
+
+def import_files(  # noqa: C901 PLR0912 PLR0913 PLR0915
     context: bpy.types.Context,
     logger: logging.Logger,
     file_paths: list[pathlib.Path],
@@ -640,3 +748,15 @@ def import_files(  # noqa: C901 PLR0912 PLR0913
         for bcf_file_path, bcf_file in bcf_files:
             for skill in bcf_file.skills:
                 import_skill(context, logger, bcf_file_path.parent, animation_file_list, skill)
+
+    file_search_directory_xbox = pathlib.Path(
+        context.preferences.addons["io_scene_ts1"].preferences.file_search_directory_xbox,
+    )
+    if file_search_directory_xbox == "":
+        file_search_directory_xbox = file_paths[0].parent
+    file_list_xbox = list(file_search_directory_xbox.glob("*.png"))
+
+    for file_path in file_paths:
+        match file_path.suffix:
+            case ".xbm":
+                import_xbox_model(context, logger, file_path, file_list_xbox)

addons/io_scene_ts1/texture_loader.py

@@ -299,9 +299,9 @@ def create_material(obj: bpy.types.Object, texture_name: str, texture_file_path:
             principled_bsdf.inputs[2].default_value = 1.0
             principled_bsdf.inputs[12].default_value = 0.0
 
-            if texture_file_path.suffix.lower() == ".tga":
+            if texture_file_path.suffix.lower() == ".tga" or texture_file_path.suffix.lower() == ".png":
                 material.node_tree.links.new(image_node.outputs[1], principled_bsdf.inputs[4])
-                material.blend_method = 'BLEND'
+                material.blend_method = 'HASHED'
 
     if material.name not in obj.data.materials:
         obj.data.materials.append(material)