Add IW6 image scanner and raw-image viewer

Introduce IW6 GfxImage scanning and UI support for inline image-like assets. Adds IW6GfxImageScanner to locate flat-binary GfxImage structs and IW6GfxImageInfo metadata, plus unit tests validating detection and heuristics. Add RawFileImageViewerForm to display/save raw-file JPEG/PNG/BMP/GIF/TIFF/ICO bytes and wire it into the main UI (double-click tree to open, tooltip updated, text editor shows hint for image rawfiles). Update Ghosts parsing: GhostsAssetWalker now emits RawFileNodes for image pool entries and pairs scanner-discovered GfxImage structs into records; GhostsZoneLayout pairing was made name-aware (image extensions route to image-typed slots, with spill-to-fallback behavior). Minor UI/status string tweaks to better describe IW6 flat-binary assets.

Author: primetime43

Call of Duty FastFile Editor/Call of Duty FastFile Editor.csproj.user

@@ -16,6 +16,9 @@
     <Compile Update="UI\ImagePreviewForm.cs">
       <SubType>Form</SubType>
     </Compile>
+    <Compile Update="UI\RawFileImageViewerForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
     <Compile Update="UI\RawFileSearcherForm.cs">
       <SubType>Form</SubType>
     </Compile>

Call of Duty FastFile Editor/UI/MainWindowForm.Designer.cs

@@ -1001,16 +1001,36 @@ private void filesTreeView_BeforeSelect(object sender, TreeViewCancelEventArgs e
             _previousSelectedNode = filesTreeView.SelectedNode;
         }
 
+        /// <summary>
+        /// Double-clicking an image-extension raw file (jpg/png/bmp/gif/tiff/ico)
+        /// opens it in a modal image viewer. Non-image files fall through —
+        /// the text editor on the right is the normal view for those.
+        /// </summary>
+        private void filesTreeView_NodeMouseDoubleClick(object? sender, TreeNodeMouseClickEventArgs e)
+        {
+            if (e.Node?.Tag is not RawFileNode node) return;
+            if (!RawFileImageViewerForm.IsImageRawFile(node.FileName)) return;
+            using var viewer = new RawFileImageViewerForm(node);
+            viewer.ShowDialog(this);
+        }
+
         /// <summary>
         /// Handles actions after selecting a new TreeView node, loading the corresponding file content.
         /// </summary>
         private void filesTreeView_AfterSelect(object sender, TreeViewEventArgs e)
         {
             if (e.Node?.Tag is RawFileNode selectedNode)
             {
-                // Load the file content into the editor without retriggering TextChanged
+                // Load the file content into the editor without retriggering TextChanged.
+                // For image-extension raw files with no text content, show a hint so the
+                // user knows to double-click for the modal viewer (rather than seeing
+                // a blank panel and assuming nothing's there).
+                string display = selectedNode.RawFileContent ?? string.Empty;
+                if (string.IsNullOrEmpty(display) && RawFileImageViewerForm.IsImageRawFile(selectedNode.FileName))
+                    display = $"-- {selectedNode.FileName}{Environment.NewLine}-- Image file ({selectedNode.MaxSize:N0} bytes). Double-click in the tree to open the image viewer.";
+
                 textEditorControlEx1.TextChanged -= textEditorControlEx1_TextChanged;
-                textEditorControlEx1.SetTextAndRefresh(selectedNode.RawFileContent ?? string.Empty);
+                textEditorControlEx1.SetTextAndRefresh(display);
                 textEditorControlEx1.TextChanged += textEditorControlEx1_TextChanged;
 
                 // Update UI
@@ -4178,10 +4198,26 @@ private void LoadAssetPoolIntoListView()
                 string dataStart = "-";
                 string dataEnd = "-";
                 string size = "-";
-                // Determine appropriate status message based on asset type
+                // Determine appropriate status message based on asset type.
+                // For Ghosts (IW6), the older games' "External reference (data in
+                // another zone)" default is misleading: tracing patch_ui_mp.ff
+                // showed 472/510 image-typed entries have FFFFFFFF pointer
+                // placeholders, meaning the engine expects their bodies inline
+                // in *this* zone — they're flat-binary GfxImage structs +
+                // texture data, not external references. We just don't have a
+                // parser for the IW6 image struct yet.
                 string status;
                 bool isSupportedType = isRawFile || isLocalize || isMenuFile || isTechSet || isXAnim || isStringTable || isWeapon || isImage;
-                if (isSupportedType)
+                bool isGhosts = _openedFastFile.IsGhostsFile;
+                if (isGhosts && isImage)
+                {
+                    status = "Flat-binary GfxImage (IW6 image parser not implemented)";
+                }
+                else if (isGhosts && isSupportedType)
+                {
+                    status = "Flat-binary asset (IW6 content parser not implemented)";
+                }
+                else if (isSupportedType)
                 {
                     status = "External reference (data in another zone)";
                 }
@@ -4294,7 +4330,9 @@ private void LoadAssetPoolIntoListView()
 
                 // Generic fallback: if no typed parser claimed this record but the
                 // walker resolved its name + body offsets (Ghosts non-rawfile types
-                // land here), surface them directly from the ZoneAssetRecord.
+                // land here), surface them directly from the ZoneAssetRecord. The
+                // walker sets AdditionalData to a descriptive string ("GfxImage
+                // 256×256 (color / 2D)" etc.) — use it verbatim as the status.
                 if (!isParsed && !string.IsNullOrEmpty(record.Name) && record.HeaderStartOffset > 0)
                 {
                     isParsed = true;
@@ -4303,8 +4341,8 @@ private void LoadAssetPoolIntoListView()
                     dataEnd = $"0x{record.AssetDataEndOffset:X}";
                     size = $"0x{record.Size:X}";
                     status = !string.IsNullOrEmpty(record.AdditionalData)
-                        ? $"{record.AdditionalData} (no content parser)"
-                        : "Located, no content parser";
+                        ? record.AdditionalData
+                        : "Located";
                 }
 
                 lvi.SubItems.Add(dataStart);

Call of Duty FastFile Editor/UI/MainWindowForm.cs

@@ -0,0 +1,183 @@
+using Call_of_Duty_FastFile_Editor.Models;
+using System.Drawing.Imaging;
+
+namespace Call_of_Duty_FastFile_Editor.UI
+{
+    /// <summary>
+    /// Modal viewer for raw files whose bytes are a native image format
+    /// (JPEG, PNG, BMP, GIF, TIFF, ICO). Unlike <see cref="ImagePreviewForm"/>
+    /// — which decodes the IW <c>image</c> asset type and handles DXT etc. —
+    /// this viewer just hands the bytes to <see cref="Bitmap"/> which handles
+    /// the standard formats natively. Used for the surprisingly common case
+    /// of `.jpg`/`.png` etc. shipped as <c>rawfile</c> assets inside FFs
+    /// (e.g. Ghosts <c>ui_mp/ingamestore/img_store_*.jpg</c>).
+    /// </summary>
+    public class RawFileImageViewerForm : Form
+    {
+        private readonly RawFileNode _node;
+        private readonly PictureBox _pictureBox;
+        private readonly Label _infoLabel;
+        private readonly Label _statusLabel;
+        private readonly Button _saveButton;
+
+        /// <summary>Image extensions <see cref="Bitmap"/> can decode directly.</summary>
+        private static readonly HashSet<string> SupportedExtensions = new(StringComparer.OrdinalIgnoreCase)
+        {
+            ".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tif", ".tiff", ".ico"
+        };
+
+        /// <summary>True if <paramref name="fileName"/> has an extension that
+        /// can be decoded by <see cref="Bitmap"/> natively.</summary>
+        public static bool IsImageRawFile(string? fileName)
+        {
+            if (string.IsNullOrEmpty(fileName)) return false;
+            return SupportedExtensions.Contains(Path.GetExtension(fileName));
+        }
+
+        public RawFileImageViewerForm(RawFileNode node)
+        {
+            _node = node;
+            Text = $"Image Preview — {node.FileName}";
+            Size = new Size(900, 700);
+            StartPosition = FormStartPosition.CenterParent;
+            MinimumSize = new Size(400, 300);
+
+            _infoLabel = new Label
+            {
+                Dock = DockStyle.Top,
+                // Two lines of Consolas 9pt + 10px top/bottom padding = ~58.
+                // Use 64 for comfortable headroom so descenders/wider fonts
+                // don't clip on high-DPI displays.
+                Height = 64,
+                Padding = new Padding(10),
+                BackColor = SystemColors.ControlLight,
+                Font = new Font("Consolas", 9),
+            };
+
+            var bottomPanel = new Panel { Dock = DockStyle.Bottom, Height = 35 };
+            _statusLabel = new Label
+            {
+                Dock = DockStyle.Fill,
+                Padding = new Padding(5),
+                TextAlign = ContentAlignment.MiddleLeft,
+            };
+            _saveButton = new Button
+            {
+                Text = "Save As…",
+                Dock = DockStyle.Right,
+                Width = 110,
+                Enabled = false,
+            };
+            _saveButton.Click += SaveButton_Click;
+            bottomPanel.Controls.Add(_statusLabel);
+            bottomPanel.Controls.Add(_saveButton);
+
+            _pictureBox = new PictureBox
+            {
+                Dock = DockStyle.Fill,
+                SizeMode = PictureBoxSizeMode.Zoom,
+                BackColor = Color.DarkGray,
+            };
+
+            Controls.Add(_pictureBox);
+            Controls.Add(bottomPanel);
+            Controls.Add(_infoLabel);
+
+            LoadImage();
+        }
+
+        private void LoadImage()
+        {
+            byte[]? bytes = _node.RawFileBytes;
+            if (bytes == null || bytes.Length == 0)
+            {
+                _infoLabel.Text = $"Name: {_node.FileName}\nSize: 0 bytes";
+                _statusLabel.Text = "No bytes available.";
+                _statusLabel.ForeColor = Color.Red;
+                return;
+            }
+
+            try
+            {
+                // Copy the bytes into the MemoryStream because Bitmap keeps a
+                // reference to the underlying stream for its lifetime — we
+                // can't dispose the stream until the bitmap is gone. Easiest
+                // is to keep the stream alive by attaching it to the bitmap's
+                // Tag, but since this is a short-lived modal we just leave
+                // the stream around for the form's lifetime.
+                var ms = new MemoryStream(bytes, writable: false);
+                var bitmap = new Bitmap(ms);
+                _pictureBox.Image = bitmap;
+                _saveButton.Enabled = true;
+
+                _infoLabel.Text =
+                    $"Name: {_node.FileName}\n" +
+                    $"Format: {bitmap.RawFormat}  |  Dimensions: {bitmap.Width} × {bitmap.Height}  |  Bytes: {bytes.Length:N0}";
+                _statusLabel.Text = "Image decoded successfully.";
+                _statusLabel.ForeColor = Color.DarkGreen;
+            }
+            catch (Exception ex)
+            {
+                _infoLabel.Text = $"Name: {_node.FileName}\nSize: {bytes.Length:N0} bytes";
+                _statusLabel.Text = $"Could not decode as image: {ex.Message}";
+                _statusLabel.ForeColor = Color.Red;
+            }
+        }
+
+        /// <summary>
+        /// Save As writes the <b>original</b> bytes verbatim (preserves the
+        /// FF-shipped format byte-for-byte). If the user picks a different
+        /// extension we re-encode through <see cref="Bitmap.Save(string, ImageFormat)"/>.
+        /// </summary>
+        private void SaveButton_Click(object? sender, EventArgs e)
+        {
+            using var dlg = new SaveFileDialog
+            {
+                Title = "Save Image",
+                FileName = Path.GetFileName(_node.FileName),
+                Filter = "Original Bytes|*.*|PNG|*.png|JPEG|*.jpg|Bitmap|*.bmp|GIF|*.gif",
+                DefaultExt = Path.GetExtension(_node.FileName)?.TrimStart('.') ?? "png",
+            };
+            if (dlg.ShowDialog(this) != DialogResult.OK) return;
+
+            try
+            {
+                string outExt = Path.GetExtension(dlg.FileName).ToLowerInvariant();
+                string srcExt = Path.GetExtension(_node.FileName).ToLowerInvariant();
+                // If the output extension matches the source, dump bytes verbatim.
+                // Otherwise re-encode through the bitmap.
+                if (outExt == srcExt || dlg.FilterIndex == 1 /* "Original Bytes" */)
+                {
+                    File.WriteAllBytes(dlg.FileName, _node.RawFileBytes ?? Array.Empty<byte>());
+                }
+                else
+                {
+                    ImageFormat fmt = outExt switch
+                    {
+                        ".jpg" or ".jpeg" => ImageFormat.Jpeg,
+                        ".bmp" => ImageFormat.Bmp,
+                        ".gif" => ImageFormat.Gif,
+                        _ => ImageFormat.Png,
+                    };
+                    _pictureBox.Image!.Save(dlg.FileName, fmt);
+                }
+                _statusLabel.Text = $"Saved to: {dlg.FileName}";
+                _statusLabel.ForeColor = Color.DarkGreen;
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show($"Failed to save image: {ex.Message}", "Save Error",
+                    MessageBoxButtons.OK, MessageBoxIcon.Error);
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                _pictureBox?.Image?.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+    }
+}

Call of Duty FastFile Editor/UI/RawFileImageViewerForm.cs

@@ -76,7 +76,14 @@ public static WalkResult Walk(byte[] zoneData, List<ZoneAssetRecord>? records, i
                 record.AdditionalData         = $"Ghosts pool-walked ({(h.IsLong ? "long" : "short")} header)";
                 records[i] = record;
 
-                if (record.AssetType_Ghosts == GhostsAssetTypePS3.rawfile)
+                // Emit a RawFileNode for any wrapped body the editor can
+                // surface to the user. rawfile entries are the obvious case;
+                // image entries paired by name-aware pairing (JPGs etc.) also
+                // become RawFileNodes so the Raw Files tab + image viewer
+                // pick them up. scriptfile / mptype / aitype bodies are left
+                // metadata-only — the editor doesn't currently expose them.
+                if (record.AssetType_Ghosts == GhostsAssetTypePS3.rawfile
+                    || record.AssetType_Ghosts == GhostsAssetTypePS3.image)
                     result.RawFileNodes.Add(BuildWrappedNode(zoneData, h));
             }
 
@@ -106,7 +113,35 @@ public static WalkResult Walk(byte[] zoneData, List<ZoneAssetRecord>? records, i
                 result.RawFileNodes.Add(BuildLuaFileNode(zoneData, lua));
             }
 
-            result.Resolved        = pairing.PairedCount + luaPaired;
+            // Pair image pool entries with scanned GfxImage structs — flat-binary
+            // bodies that have no signature, so the scanner finds them by their
+            // inline name preceded by a FFFFFFFF NamePtr placeholder. Image
+            // entries already paired with a zlib-wrapped JPG body (by the
+            // name-aware wrapped-header pairing) keep that pairing; the GfxImage
+            // pass only fills in image records that are still unresolved.
+            var gfxImages = IW6GfxImageScanner.Locate(zoneData);
+            int gfxIdx = 0, gfxPaired = 0;
+            for (int i = 0; i < records.Count && gfxIdx < gfxImages.Count; i++)
+            {
+                if (records[i].AssetType_Ghosts != GhostsAssetTypePS3.image) continue;
+                if (!string.IsNullOrEmpty(records[i].Name)) continue; // already paired (JPG)
+                var img = gfxImages[gfxIdx++];
+
+                var record = records[i];
+                record.HeaderStartOffset      = img.StructOffset;
+                record.HeaderEndOffset        = img.NameOffset;
+                record.AssetDataStartPosition = img.StructOffset;
+                record.AssetDataEndOffset     = img.NameOffset + img.Name.Length;
+                record.AssetRecordEndOffset   = img.NameOffset + img.Name.Length;
+                record.Name                   = img.Name;
+                record.Size                   = IW6GfxImageScanner.StructSize;
+                record.AdditionalData         =
+                    $"GfxImage {img.Width}×{img.Height} ({IW6GfxImageScanner.SemanticName(img.Semantic)} / {IW6GfxImageScanner.MapTypeName(img.MapType)})";
+                records[i] = record;
+                gfxPaired++;
+            }
+
+            result.Resolved        = pairing.PairedCount + luaPaired + gfxPaired;
             result.Unresolved      = Math.Max(0, records.Count - result.Resolved);
             result.UnpairedHeaders = pairing.UnpairedHeaders + Math.Max(0, luaFiles.Count - luaIdx);