Fixed a couple bugs in the texture tools

Author: Mindstormman06

python/bntx_editor.py

@@ -147,12 +147,11 @@ def rename_texture(self, old_name: str, new_name: str):
     # -- DDS import ----------------------------------------------------------
 
     def import_dds(self, name: str, dds_bytes: bytes):
-        """Replace a texture's image data from a DDS file, in place.
+        """Replace a texture's image data from a DDS file.
 
-        The DDS must match the target texture's compression format family and
-        dimensions. The image data is re-swizzled and written over the existing
-        block-linear data, leaving the BNTX structure (string pool, relocation
-        table, pointers) untouched so the file stays valid.
+        The DDS must match the target texture's compression format family.
+        Dimensions and mip count may differ from the original; larger imports
+        relocate image data to the end of the file.
         """
         import dds_io
         import texture_swizzle as tsw
@@ -163,9 +162,6 @@ def import_dds(self, name: str, dds_bytes: bytes):
         d = ptr + 0x10
 
         cur_format = self._read_fmt("I", d + self._OFF_FORMAT)
-        cur_width = self._read_fmt("i", d + self._OFF_WIDTH)
-        cur_height = self._read_fmt("i", d + self._OFF_HEIGHT)
-        cur_mip_count = self._read_fmt("H", d + self._OFF_MIP_COUNT)
         cur_image_size = self._read_fmt("I", d + self._OFF_IMAGE_SIZE)
         cur_alignment = self._read_fmt("I", d + self._OFF_ALIGNMENT) or 512
         tile_mode = self._read_fmt("H", d + self._OFF_TILE_MODE)
@@ -198,42 +194,50 @@ def import_dds(self, name: str, dds_bytes: bytes):
                 f"Format mismatch: texture is {cur_key.upper()} but DDS is {dds.key.upper()}. "
                 f"Re-export the DDS as {cur_key.upper()}."
             )
-        if dds.width != cur_width or dds.height != cur_height:
-            raise BntxImportError(
-                f"Size mismatch: texture is {cur_width}x{cur_height} but DDS is "
-                f"{dds.width}x{dds.height}. Resize the DDS to match."
-            )
 
         bpb, blk_w, blk_h = dds.block_info
 
-        # Use as many mips as fit in the existing data region (no structural growth).
-        max_mips = min(dds.mip_count, cur_mip_count)
-        combined, _offsets, bh_log2, image_size = tsw.swizzle_surface_mipmaps(
+        max_mips = dds.mip_count
+        combined, offsets, bh_log2, image_size = tsw.swizzle_surface_mipmaps(
             dds.width, dds.height, blk_w, blk_h, bpb, max_mips, dds.mips[:max_mips], cur_alignment
         )
 
         data_base = self._data_base(d)
         if data_base <= 0 or data_base + cur_image_size > len(self._data):
             raise BntxImportError("Texture image data is outside the file bounds.")
-        if len(combined) > cur_image_size:
-            raise BntxImportError(
-                "Imported data is larger than the original texture region; "
-                "replacing with more mip levels than the original is not supported."
-            )
-
-        # Overwrite in place and zero any trailing slack so stale bytes do not leak.
-        self._data[data_base : data_base + len(combined)] = combined
-        if len(combined) < cur_image_size:
-            self._data[data_base + len(combined) : data_base + cur_image_size] = b"\x00" * (
-                cur_image_size - len(combined)
-            )
 
-        # Refresh the (already-relocated) mip pointer values for the mips we wrote.
         ptr_array = self._mip_ptr_array_addr(d)
+
+        if len(combined) <= cur_image_size:
+            # Overwrite in place and zero any trailing slack so stale bytes do not leak.
+            self._data[data_base : data_base + len(combined)] = combined
+            if len(combined) < cur_image_size:
+                self._data[data_base + len(combined) : data_base + cur_image_size] = b"\x00" * (
+                    cur_image_size - len(combined)
+                )
+            write_base = data_base
+            stored_image_size = image_size
+        else:
+            # Larger mip chain: relocate image data to the end of the file.
+            align = cur_alignment or 512
+            write_base = len(self._data)
+            pad = (align - (write_base % align)) % align
+            if pad:
+                self._data.extend(b"\x00" * pad)
+                write_base = len(self._data)
+            self._data.extend(combined)
+            if image_size > len(combined):
+                self._data.extend(b"\x00" * (image_size - len(combined)))
+            stored_image_size = image_size
+            self.file_size = len(self._data)
+
         for i in range(max_mips):
-            self._write_fmt("q", ptr_array + i * 8, data_base + _offsets[i])
+            self._write_fmt("q", ptr_array + i * 8, write_base + offsets[i])
 
+        self._write_fmt("i", d + self._OFF_WIDTH, dds.width)
+        self._write_fmt("i", d + self._OFF_HEIGHT, dds.height)
         self._write_fmt("H", d + self._OFF_MIP_COUNT, max_mips)
+        self._write_fmt("I", d + self._OFF_IMAGE_SIZE, stored_image_size)
 
         # Preserve the existing block-height layout bits, refresh the low 3 bits.
         layout = self._read_fmt("I", d + self._OFF_LAYOUT)

src/archiveFsCommands.ts

@@ -1168,7 +1168,7 @@ export function registerArchiveFileCommands(context: vscode.ExtensionContext): v
                 }
                 const targetUri = entry.resourceUri;
                 if (isBntxOrTexToGo(targetUri)) {
-                    void vscode.window.showWarningMessage('Replace is not supported for BNTX or TexToGo files.');
+                    await vscode.commands.executeCommand('totk-editor.importTextureDds', targetUri);
                     return;
                 }
 

src/extension.ts

@@ -1257,7 +1257,7 @@ export async function activate(context: vscode.ExtensionContext) {
                     };
                     const onImport = isReadOnly ? undefined : () => importDdsIntoTexture(uri);
                     const onExport = () => exportFromArchiveSelection([uri]);
-                    openTextureViewer(texName, raw, diskArchive, filePath, onSaveCallback, onImport, onExport);
+                    openTextureViewer(texName, raw, diskArchive, filePath, onSaveCallback, onImport, onExport, uri.fsPath);
                 } else {
                     void vscode.window.showErrorMessage('Failed to load texture preview.');
                 }

src/textureViewer.ts

@@ -3,8 +3,15 @@ import type { BntxTextureResult, BntxChannelInfo, BntxImageInfo, BntxMiscInfo }
 import * as fs from 'fs';
 import * as path from 'path';
 
+interface PanelCallbacks {
+    onSave?: (data: any) => Promise<void>;
+    onImport?: () => Promise<void>;
+    onExport?: () => Promise<void>;
+}
+
 const panels = new Map<string, vscode.WebviewPanel>();
 const panelTempFiles = new Map<string, string>();
+const panelCallbacks = new Map<string, PanelCallbacks>();
 let extensionUri: vscode.Uri | undefined;
 
 export function initTextureViewer(extUri: vscode.Uri): void {
@@ -18,11 +25,14 @@ export function openTextureViewer(
     filePath?: string,
     onSave?: (data: any) => Promise<void>,
     onImport?: () => Promise<void>,
-    onExport?: () => Promise<void>
+    onExport?: () => Promise<void>,
+    panelKey?: string,
 ): void {
-    const key = textureName;
+    const key = panelKey ?? textureName;
+    panelCallbacks.set(key, { onSave, onImport, onExport });
+
     const existing = panels.get(key);
-    
+
     if (existing) {
         // We are replacing the content of an existing panel.
         // Clean up the previous temp file so it doesn't leak.
@@ -32,7 +42,7 @@ export function openTextureViewer(
                 fs.unlinkSync(oldTempFile);
             } catch { }
         }
-        
+
         if (result.pngPath) {
             panelTempFiles.set(key, result.pngPath);
         } else {
@@ -66,6 +76,7 @@ export function openTextureViewer(
     panels.set(key, panel);
     panel.onDidDispose(() => {
         panels.delete(key);
+        panelCallbacks.delete(key);
         const currentTempFile = panelTempFiles.get(key);
         if (currentTempFile) {
             try {
@@ -76,24 +87,25 @@ export function openTextureViewer(
     });
 
     panel.webview.onDidReceiveMessage(async (message) => {
-        if (message.type === 'save-metadata' && onSave) {
+        const callbacks = panelCallbacks.get(key);
+        if (message.type === 'save-metadata' && callbacks?.onSave) {
             try {
-                await onSave(message.data);
+                await callbacks.onSave(message.data);
                 vscode.window.showInformationMessage('Texture metadata saved successfully!');
             } catch (e) {
                 const err = e instanceof Error ? e.message : String(e);
                 vscode.window.showErrorMessage(`Failed to save metadata: ${err}`);
             }
-        } else if (message.type === 'import-dds' && onImport) {
+        } else if (message.type === 'import-dds' && callbacks?.onImport) {
             try {
-                await onImport();
+                await callbacks.onImport();
             } catch (e) {
                 const err = e instanceof Error ? e.message : String(e);
                 vscode.window.showErrorMessage(`DDS import failed: ${err}`);
             }
-        } else if (message.type === 'export-dds' && onExport) {
+        } else if (message.type === 'export-dds' && callbacks?.onExport) {
             try {
-                await onExport();
+                await callbacks.onExport();
             } catch (e) {
                 const err = e instanceof Error ? e.message : String(e);
                 vscode.window.showErrorMessage(`DDS export failed: ${err}`);
@@ -379,8 +391,8 @@ function buildHtml(result: BntxTextureResult, webview: vscode.Webview, isReadOnl
     </div>
     <div class="props-panel">
         <div style="margin-bottom: 12px; display: flex; gap: 8px; justify-content: flex-end; flex-wrap: wrap;">
-            ${allowExport ? `<button class="save-btn" onclick="exportDds()">Export DDS</button>` : ''}
-            ${allowImport && !isReadOnly ? `<button class="save-btn" onclick="importDds()">Import DDS</button>` : ''}
+            ${allowExport ? `<button class="save-btn" onclick="exportDds()">Export Texture</button>` : ''}
+            ${allowImport && !isReadOnly ? `<button class="save-btn" onclick="importDds()">Import Texture</button>` : ''}
             ${!isReadOnly ? `<button class="save-btn" onclick="saveMetadata()">Save Changes</button>` : ''}
         </div>
         ${metaSections}