Implemented exporting texture and model files (Models untested)

Author: Mindstormman06

docs/release-notes/0.0.2-beta.1.md

@@ -10,6 +10,7 @@
 - Select an active project to quick add files to
 - Font viewer
 - Set project root
+- Full export support in various formats (Textures, Models (untested))
 
 # TKMM Integration
 - TKMM option support

icons/outline-view-active.svg

@@ -364,6 +364,10 @@
         "command": "totk-editor.dumpExport",
         "title": "Export..."
       },
+      {
+        "command": "totk-editor.explorerExport",
+        "title": "Export..."
+      },
       {
         "command": "totk-editor.exportYaml",
         "title": "TKVSC: Export Current File to YAML"
@@ -621,12 +625,12 @@
         },
         {
           "command": "totk-editor.archiveExport",
-          "when": "view == totk-editor.archives && viewItem == archiveVirtualFile",
+          "when": "view == totk-editor.archives && (viewItem == archiveVirtualFile || viewItem == archiveFile || viewItem == archivePackage)",
           "group": "5_export@1"
         },
         {
           "command": "totk-editor.dumpExport",
-          "when": "view == totk-editor.gameDump && viewItem == dumpVirtualFile",
+          "when": "view == totk-editor.gameDump && (viewItem == dumpVirtualFile || viewItem == dumpFile || viewItem == dumpArchive)",
           "group": "5_export@1"
         },
         {
@@ -665,6 +669,11 @@
           "command": "totk-editor.archivePaste",
           "when": "totk-editor.archiveClipboardNotEmpty",
           "group": "9_cutcopypaste"
+        },
+        {
+          "command": "totk-editor.explorerExport",
+          "when": "resourceExtname == .txtg || resourceExtname == .bntx || resourceExtname == .bftex || resourceExtname == .byml || resourceExtname == .bgyml || resourceExtname == .bfmdl || resourceExtname == .bfska",
+          "group": "5_export@1"
         }
       ]
     },

icons/outline-view-inactive.svg

@@ -487,3 +487,29 @@ def render_texture_to_png(bntx_data: bytes, texture_name: str) -> str | None:
 
     _log(f"Saved PNG: {tmp_path}")
     return tmp_path
+
+def extract_texture_linear(bntx_data: bytes, texture_name: str) -> tuple[int, int, str, bytes, int, int] | None:
+    """Extract raw deswizzled linear bytes and metadata for native export."""
+    textures = _parse_textures(bntx_data)
+    tex = None
+    for t in textures:
+        if t.name == texture_name:
+            tex = t
+            break
+    if tex is None:
+        return None
+
+    fmt_name, bpp, blk_w, blk_h, decoder_key = _fmt_info(tex.format_id)
+    if tex.data_offset <= 0 or tex.data_size <= 0:
+        return None
+
+    raw_data = bntx_data[tex.data_offset : tex.data_offset + tex.data_size]
+
+    if tex.tile_mode == 1:
+        linear = _deswizzle_pitch_linear(tex.width, tex.height, blk_w, blk_h, bpp, raw_data)
+    else:
+        linear = _deswizzle_block_linear(
+            tex.width, tex.height, blk_w, blk_h, bpp, tex.block_height_log2, raw_data
+        )
+
+    return tex.width, tex.height, decoder_key, linear, tex.mip_count, tex.format_id

package.json

@@ -106,8 +106,13 @@ def _read_txtg_texture_result(file_data: bytes, texture_name: str, logical_path:
 
 
 def export_archive_file_to_temp(archive_path: str, internal_path: str, romfs_path: str = "") -> str:
-    file_data = read_archive_file_bytes(archive_path, internal_path, romfs_path)
-    file_name = Path(internal_path).name or "file.bin"
+    if not internal_path:
+        file_data = Path(archive_path).read_bytes()
+        file_name = Path(archive_path).name or "file.bin"
+    else:
+        file_data = read_archive_file_bytes(archive_path, internal_path, romfs_path)
+        file_name = Path(internal_path).name or "file.bin"
+        
     safe_name = "".join(ch if ch.isalnum() or ch in "._-" else "_" for ch in file_name)
     fd, tmp_path = tempfile.mkstemp(prefix="totk-tool-", suffix=f"-{safe_name}")
     with os.fdopen(fd, "wb") as out:
@@ -587,6 +592,142 @@ def main():
                     )
                 )
 
+            elif command == "export-converted":
+                internal_path = sys.argv[3]
+                target_ext = sys.argv[4].lower()
+                if internal_path:
+                    file_data = read_archive_file_bytes(archive_path, internal_path, romfs_path)
+                    logical_path = internal_path
+                else:
+                    file_data = Path(archive_path).read_bytes()
+                    logical_path = archive_path
+                    
+                kind = _file_kind(logical_path, file_data, romfs_path)
+                
+                out_path = export_archive_file_to_temp(archive_path, internal_path, romfs_path)
+                
+                if target_ext in [".png", ".jpg", ".jpeg", ".bmp", ".tga", ".dds"]:
+                    png_path = None
+                    is_txtg = kind == "txtg" or logical_path.lower().endswith(".txtg") or file_data[4:8] == b"6PK0"
+                    
+                    bntx_data = None
+                    tex_name = None
+                    
+                    if is_txtg:
+                        from txtg_reader import read_txtg_texture_result
+                        tex_name = Path(logical_path).name or "texture"
+                        res = read_txtg_texture_result(file_data, tex_name)
+                        png_path = res.get("pngPath")
+                    else:
+                        bntx_ctx = _resolve_bntx_for_read(archive_path, internal_path, romfs_path)
+                        if bntx_ctx is not None:
+                            bntx_data, tex_name = bntx_ctx
+                            from bntx_renderer import render_texture_to_png
+                            png_path = render_texture_to_png(bntx_data, tex_name)
+                            
+                    if png_path:
+                        try:
+                            from PIL import Image
+                            img = Image.open(png_path)
+                            fd, cvt_path = tempfile.mkstemp(prefix="totk-cvt-", suffix=target_ext)
+                            os.close(fd)
+                            
+                            if target_ext == ".dds":
+                                native_dds_bytes = None
+                                if not is_txtg and bntx_data is not None and tex_name is not None:
+                                    from bntx_renderer import extract_texture_linear
+                                    extracted = extract_texture_linear(bntx_data, tex_name)
+                                    if extracted is not None:
+                                        tex_width, tex_height, decoder_key, linear, mip_count, format_id = extracted
+                                        if decoder_key.startswith("bc"):
+                                            dxgi_map = {
+                                                0x1A: 72 if (format_id & 0xFF) == 0x06 else 71,
+                                                0x1B: 75 if (format_id & 0xFF) == 0x06 else 74,
+                                                0x1C: 78 if (format_id & 0xFF) == 0x06 else 77,
+                                                0x1D: 81 if (format_id & 0xFF) == 0x02 else 80,
+                                                0x1E: 84 if (format_id & 0xFF) == 0x02 else 83,
+                                                0x1F: 96 if (format_id & 0xFF) == 0x02 else 95,
+                                                0x20: 99 if (format_id & 0xFF) == 0x06 else 98,
+                                            }
+                                            dxgi_format = dxgi_map.get(format_id >> 8)
+                                            if dxgi_format is not None:
+                                                header = bytearray(148)
+                                                header[0:4] = b"DDS "
+                                                header[4:8] = (124).to_bytes(4, "little")
+                                                header[8:12] = (0x1 | 0x2 | 0x4 | 0x1000 | 0x80000).to_bytes(4, "little") 
+                                                header[12:16] = tex_height.to_bytes(4, "little")
+                                                header[16:20] = tex_width.to_bytes(4, "little")
+                                                header[20:24] = len(linear).to_bytes(4, "little") 
+                                                header[24:28] = (1).to_bytes(4, "little") 
+                                                header[28:32] = (mip_count).to_bytes(4, "little") 
+                                                
+                                                header[76:80] = (32).to_bytes(4, "little") 
+                                                header[80:84] = (0x4).to_bytes(4, "little") 
+                                                header[84:88] = b"DX10"
+                                                
+                                                header[108:112] = (0x1000).to_bytes(4, "little") 
+                                                
+                                                header[128:132] = dxgi_format.to_bytes(4, "little")
+                                                header[132:136] = (3).to_bytes(4, "little") 
+                                                header[136:140] = (0).to_bytes(4, "little") 
+                                                header[140:144] = (1).to_bytes(4, "little") 
+                                                header[144:148] = (0).to_bytes(4, "little") 
+                                                
+                                                native_dds_bytes = bytes(header) + linear
+
+                                if native_dds_bytes is not None:
+                                    with open(cvt_path, "wb") as f:
+                                        f.write(native_dds_bytes)
+                                else:
+                                    img = img.convert("RGBA")
+                                    width, height = img.size
+                                    pixels = img.tobytes("raw", "RGBA")
+                                    header = bytearray(128)
+                                    header[0:4] = b"DDS "
+                                    header[4:8] = (124).to_bytes(4, "little")
+                                    header[8:12] = (0x100F).to_bytes(4, "little") 
+                                    header[12:16] = height.to_bytes(4, "little")
+                                    header[16:20] = width.to_bytes(4, "little")
+                                    header[20:24] = (width * 4).to_bytes(4, "little")
+                                    header[24:28] = (1).to_bytes(4, "little")
+                                    header[28:32] = (1).to_bytes(4, "little")
+                                    header[76:80] = (32).to_bytes(4, "little")
+                                    header[80:84] = (0x41).to_bytes(4, "little")
+                                    header[88:92] = (32).to_bytes(4, "little")
+                                    header[92:96] = (0x000000FF).to_bytes(4, "little")
+                                    header[96:100] = (0x0000FF00).to_bytes(4, "little")
+                                    header[100:104] = (0x00FF0000).to_bytes(4, "little")
+                                    header[104:108] = (0xFF000000).to_bytes(4, "little")
+                                    header[108:112] = (0x1000).to_bytes(4, "little")
+                                    with open(cvt_path, "wb") as f:
+                                        f.write(header)
+                                        f.write(pixels)
+                            else:
+                                if target_ext in [".jpg", ".jpeg"] and img.mode in ("RGBA", "P"):
+                                    img = img.convert("RGB")
+                                img.save(cvt_path)
+                                
+                            img.close()
+                            os.unlink(png_path)
+                            if os.path.exists(out_path):
+                                os.unlink(out_path)
+                            out_path = cvt_path
+                        except Exception:
+                            import traceback
+                            traceback.print_exc()
+                            out_path = png_path
+                                
+                elif target_ext in [".yaml", ".yml"]:
+                    if kind == "byml" or kind == "bgyml":
+                        yaml_text = read_byml_content(file_data, internal_path, romfs_path)
+                        fd, yaml_path = tempfile.mkstemp(prefix="totk-cvt-", suffix=target_ext)
+                        os.close(fd)
+                        Path(yaml_path).write_text(yaml_text, encoding="utf-8")
+                        os.unlink(out_path)
+                        out_path = yaml_path
+                
+                print(json.dumps({"path": out_path}))
+
             elif command == "write-raw":
                 internal_path = sys.argv[3]
                 encoded = sys.stdin.read()

python/bntx_renderer.py

@@ -20,6 +20,7 @@
     0x202: ("BC1_UNORM", 8, 4, 4, "bc1"),
     0x203: ("BC1_SRGB", 8, 4, 4, "bc1"),
     0x302: ("BC1_UNORM", 8, 4, 4, "bc1"),
+    0x303: ("BC1_SRGB", 8, 4, 4, "bc1"),
     0x505: ("BC3_SRGB", 16, 4, 4, "bc3"),
     0x602: ("BC4_UNORM", 8, 4, 4, "bc4"),
     0x606: ("BC4_UNORM", 8, 4, 4, "bc4"),
@@ -429,19 +430,25 @@ def format_id(self, value: int):
 
     @property
     def texture_setting2(self) -> int:
+        if len(self._data) < 0x48:
+            return 0
         return struct.unpack_from("<I", self._data, 0x44)[0]
 
     @texture_setting2.setter
     def texture_setting2(self, value: int):
-        struct.pack_into("<I", self._data, 0x44, value)
+        if len(self._data) >= 0x48:
+            struct.pack_into("<I", self._data, 0x44, value)
 
     @property
     def texture_setting4(self) -> int:
+        if len(self._data) < 0x50:
+            return 0
         return struct.unpack_from("<I", self._data, 0x4C)[0]
 
     @texture_setting4.setter
     def texture_setting4(self, value: int):
-        struct.pack_into("<I", self._data, 0x4C, value)
+        if len(self._data) >= 0x50:
+            struct.pack_into("<I", self._data, 0x4C, value)
 
     def replace_image_data(self, raw_surfaces: list[bytes]):
         """

python/totk_bridge.py

@@ -0,0 +1,25 @@
+import sys
+import tempfile
+from pathlib import Path
+
+# Add the python directory to sys.path
+sys.path.append(str(Path('e:/Nintendo Stuff/TOTK/TOTK Searcher Dev/totk-vscode/totk-vscode/python').resolve()))
+
+from bntx_renderer import get_texture_metadata, render_texture_to_png
+from txtg_reader import read_txtg_texture_result
+
+def test_render():
+    romfs_path = "e:/Nintendo Stuff/ROMS/Switch/Tears Dump/romfs"
+    bntx_path = romfs_path + "/TexToGo/Armor_001_Lower_Alb.1.txtg"
+    try:
+        data = Path(bntx_path).read_bytes()
+        res = read_txtg_texture_result(data, "Armor_001_Lower_Alb.1")
+        if res.get("pngPath"):
+            print(f"Generated PNG at: {res['pngPath']}")
+        else:
+            print(f"Failed to generate PNG: {res.get('error')}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    test_render()

python/txtg_reader.py

@@ -0,0 +1,32 @@
+import sys
+from pathlib import Path
+
+# Add the python directory to sys.path
+sys.path.append(str(Path('e:/Nintendo Stuff/TOTK/TOTK Searcher Dev/totk-vscode/totk-vscode/python').resolve()))
+
+from bntx_renderer import get_texture_metadata, render_texture_to_png
+
+def test_render():
+    romfs_path = "e:/Nintendo Stuff/ROMS/Switch/Tears Dump/romfs"
+    bntx_path = romfs_path + "/Armor/Armor_001_Lower.bntx"
+    try:
+        data = Path(bntx_path).read_bytes()
+        from bntx_renderer import _parse_textures
+        textures = _parse_textures(data)
+        for tex in textures:
+            print(f"Texture: {tex.name}, {tex.width}x{tex.height}")
+            png_path = render_texture_to_png(data, tex.name)
+            
+            from PIL import Image
+            img = Image.open(png_path)
+            print(f"  Generated PNG size: {img.size}")
+            
+            meta = get_texture_metadata(data, tex.name)
+            print(f"  Metadata size: {meta['imageInfo']['width']}x{meta['imageInfo']['height']}")
+            break
+            
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    test_render()

scratch.py

@@ -0,0 +1,23 @@
+import sys
+from PIL import Image
+
+def check():
+    img = Image.open(r"C:\Users\Aiden\AppData\Local\Temp\totk-txtg-46ue49e_-Armor_001_Lower_Alb.1.png")
+    pixels = img.load()
+    w, h = img.size
+    
+    # Check last 10 columns for transparency
+    for x in range(w - 20, w):
+        transparent = True
+        for y in range(h):
+            if img.mode == 'RGBA':
+                if pixels[x, y][3] > 0:
+                    transparent = False
+                    break
+        if transparent:
+            print(f"Column {x} is fully transparent!")
+        else:
+            print(f"Column {x} has data.")
+
+if __name__ == "__main__":
+    check()