Give texture material discovery to the textures feature

list_materials / material_of / Material moved from textures/ui/model.rs to
textures/materials.rs, reading the VFS directly rather than through the UI
asset grid. The VFS listing helpers (vfs_files, join_entry, leaf,
normalize_extensions) moved out of panels/controls/grid.rs to a neutral
sbc/vfs.rs, so the domain no longer depends on panel UI. The now-orphaned
ASSETS const is dropped.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: gajop

docs/porting/01-wip-refactor-plan.md

@@ -24,6 +24,10 @@ receives small, reviewable domain slices rather than architectural cleanup.
   under `panels/{controls,dialogs,cursor,fields,runtime,theme}`.
 - Duplicate model-factory registration now panics with the model's type name,
   as duplicate command registration already does (`Models::build`).
+- Texture material discovery is feature-owned: `Material` / `list_materials`
+  moved to `textures/materials.rs`, reading the VFS directly. The VFS listing
+  helpers moved out of the grid to a neutral `sbc/vfs.rs`, so the domain no
+  longer depends on UI code.
 
 ## Remaining
 
@@ -42,13 +46,6 @@ project-IO/workspace module (`io_registries`, `paths` exist but still sit inside
 project editor stay in `project/`. This is TODO #16; it stops each saving
 feature depending on the whole Project feature.
 
-### Texture material ownership
-
-`list_materials` / `material_of` still live in `textures/ui/model.rs`. Move
-material discovery/parsing into the `textures` feature proper; the editor
-consumes it. Texture/material ownership must not be trapped in a panel editor
-before the Textures domain transfers.
-
 ### Split the E2ERun monolith
 
 `tools/e2e/runner.py` (~1150 lines) into engine-session lifecycle, input,

native/src/sbc/mod.rs

@@ -31,3 +31,4 @@ mod message_handler;
 mod rml;
 pub mod sbc;
 mod tests;
+pub(crate) mod vfs;

native/src/sbc/panels/brush.rs

@@ -22,10 +22,6 @@ pub(crate) fn non_empty(value: String) -> Option<String> {
     (!value.is_empty()).then_some(value)
 }
 
-/// The direct thumbnail grids use full VFS paths. Asset fields instead pass a
-/// relative root to `AssetPicker`, which now defaults to this pack itself.
-pub(crate) const ASSETS: &str = "springboard/assets/core";
-
 /// One action button: a caption, the image icon, and the brush it activates.
 #[derive(Clone, Copy)]
 pub(crate) struct BrushAction {

native/src/sbc/panels/controls/grid.rs

@@ -14,6 +14,7 @@ use std::rc::Rc;
 use spring_native::prelude::{Error, NativeInterfaceRef};
 
 use crate::sbc::panels::field::{bind_tooltip, bind_tooltip_markup, element_by_id, escape_rml};
+use crate::sbc::vfs::{join_entry, leaf, normalize_extensions, vfs_files};
 
 /// Enough empty cells to fill out the widest row the panel can hold, so a short
 /// last row keeps its items at their natural size.
@@ -522,72 +523,10 @@ fn vfs_sub_dirs(interface: &NativeInterfaceRef, dir: &str) -> Vec<String> {
     names
 }
 
-/// File names directly under `dir`, matching one of `extensions`. The VFS's own
-/// Extensions are matched as `.ext`, so a field may write either `png` or `.png`
-/// and both listers agree. They disagreed before, and a dotted list silently
-/// matched nothing.
-fn normalize_extensions(extensions: &[&str]) -> Vec<String> {
-    extensions
-        .iter()
-        .map(|ext| ext.trim_start_matches('.').to_lowercase())
-        .collect()
-}
-
-/// `DirList`, as Lua's `Path.DirList` uses.
-fn vfs_files(interface: &NativeInterfaceRef, dir: &str, extensions: &[&str]) -> Vec<String> {
-    let extensions = normalize_extensions(extensions);
-    let Ok(paths) = interface.vfs().dir_list_names(dir, "*", "", false) else {
-        return Vec::new();
-    };
-    let mut names: Vec<String> = paths
-        .iter()
-        .filter_map(|path| {
-            let name = leaf(path)?;
-            let matches = extensions.is_empty()
-                || extensions.iter().any(|ext| {
-                    name.to_lowercase()
-                        .ends_with(&format!(".{}", ext.to_lowercase()))
-                });
-            matches.then_some(name)
-        })
-        .collect();
-    names.sort();
-    names.dedup();
-    names
-}
-
-/// The last component of a VFS path, with any trailing slash dropped.
-fn leaf(path: &str) -> Option<String> {
-    let name = path.trim_end_matches('/').rsplit('/').next()?.to_string();
-    (!name.is_empty()).then_some(name)
-}
-
-/// Join a directory with an entry the engine returned.
-///
-/// The engine hands back entries already prefixed with the directory, so
-/// joining unconditionally yields `bitmaps/bitmaps/foo.bmp` and the texture
-/// fails to load. Only join when the entry is a bare name.
-fn join_entry(dir: &str, name: &str) -> String {
-    if dir.is_empty() || name.contains('/') {
-        name.trim_end_matches('/').to_string()
-    } else {
-        format!("{}/{}", dir.trim_end_matches('/'), name)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn entry_paths_are_not_doubled() {
-        // The engine hands back `bitmaps/foo.bmp` inside `bitmaps`.
-        assert_eq!(join_entry("bitmaps", "bitmaps/foo.bmp"), "bitmaps/foo.bmp");
-        assert_eq!(join_entry("bitmaps", "foo.bmp"), "bitmaps/foo.bmp");
-        assert_eq!(join_entry("", "foo.bmp"), "foo.bmp");
-        assert_eq!(join_entry("a", "a/b/"), "a/b");
-    }
-
     #[test]
     fn parent_dir_walks_up_and_stops_at_the_root() {
         assert_eq!(parent_dir("a/b/c"), Some("a/b".to_string()));

native/src/sbc/textures/materials.rs

@@ -0,0 +1,96 @@
+//! Brush-material discovery: grouping the files under `brush_textures/` into
+//! materials by channel suffix. Owned by the textures feature; the editor UI
+//! consumes it.
+
+use std::collections::BTreeMap;
+
+use spring_native::prelude::NativeInterfaceRef;
+
+use crate::sbc::vfs::{join_entry, vfs_files};
+
+/// A material's channels, as `TextureManager.materialTextures` defines them: one
+/// texture per channel, found by suffix next to the diffuse.
+///
+/// `normal` is a channel of every material but has no enable toggle, exactly as
+/// Lua skips it when it builds the checkboxes.
+pub(crate) const CHANNELS: &[(&str, &str, bool)] = &[
+    ("diffuse", "Diffuse", true),
+    ("specular", "Specular", true),
+    ("normal", "Normal", false),
+    ("emission", "Emission", true),
+    ("refl", "Refl", true),
+];
+
+const IMAGE_EXTS: &[&str] = &[".png", ".jpg", ".tga", ".dds", ".bmp"];
+
+const ROOT: &str = "springboard/assets/core/brush_textures";
+
+/// One material: its name, and the channel textures that exist for it.
+#[derive(Clone)]
+pub(crate) struct Material {
+    /// The bare material name (`dirt1`), which is what the picker shows.
+    pub(crate) name: String,
+    pub(crate) channels: BTreeMap<String, String>,
+}
+
+/// The material a texture belongs to: its file name with the channel suffix
+/// stripped, and without the directory. `.../brush_textures/dirt1_diffuse.png`
+/// is the `diffuse` of `dirt1`.
+fn material_of(path: &str) -> Option<(String, &'static str)> {
+    let file = path.rsplit('/').next()?;
+    let stem = file.rsplit_once('.').map(|(s, _)| s).unwrap_or(file);
+    for (channel, _, _) in CHANNELS {
+        if let Some(base) = stem.strip_suffix(&format!("_{channel}")) {
+            return Some((base.to_string(), channel));
+        }
+    }
+    None
+}
+
+/// Group the files under `brush_textures/` into materials. A material exists if
+/// it has a diffuse; the other channels are optional, which is why the picker
+/// shows which ones were found.
+pub(crate) fn list_materials(interface: &NativeInterfaceRef) -> Vec<Material> {
+    let mut found: BTreeMap<String, BTreeMap<String, String>> = BTreeMap::new();
+
+    for name in vfs_files(interface, ROOT, IMAGE_EXTS) {
+        let path = join_entry(ROOT, &name);
+        if let Some((material, channel)) = material_of(&path) {
+            found
+                .entry(material)
+                .or_default()
+                .insert(channel.to_string(), path);
+        }
+    }
+
+    found
+        .into_iter()
+        .filter(|(_, channels)| channels.contains_key("diffuse"))
+        .map(|(name, channels)| Material { name, channels })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The VFS hands back full paths, so the material's name is the file's, not
+    /// the path's -- every material was captioned "springboard" until it was.
+    #[test]
+    fn a_material_is_named_after_its_file_not_its_path() {
+        let (name, channel) =
+            material_of("springboard/assets/core/brush_textures/dirt1_diffuse.png").unwrap();
+        assert_eq!(name, "dirt1");
+        assert_eq!(channel, "diffuse");
+
+        let (name, channel) =
+            material_of("springboard/assets/core/brush_textures/cement_normal.png").unwrap();
+        assert_eq!(name, "cement");
+        assert_eq!(channel, "normal");
+    }
+
+    #[test]
+    fn a_texture_with_no_channel_suffix_belongs_to_no_material() {
+        assert!(material_of("brush_textures/readme.png").is_none());
+    }
+}

native/src/sbc/textures/mod.rs

@@ -1,4 +1,5 @@
 pub(crate) mod commands;
+pub(crate) mod materials;
 mod model;
 pub(crate) mod ops;
 mod project;

native/src/sbc/textures/ui/layout.rs

@@ -5,10 +5,11 @@ use crate::sbc::panels::editor_base::section_rml;
 use crate::sbc::panels::runtime::Item;
 use crate::sbc::rml::{element_by_id, escape_rml};
 
+use crate::sbc::textures::materials::list_materials;
+
 use super::model::TexField::*;
 use super::model::{
-    enabled_name, list_materials, material_tooltip, toggle_channels, TexField, TextureUiModel,
-    ADD_BRUSH_ID,
+    enabled_name, material_tooltip, toggle_channels, TexField, TextureUiModel, ADD_BRUSH_ID,
 };
 
 fn section_markup(id: &str, caption: &str) -> String {

native/src/sbc/textures/ui/model.rs

@@ -4,15 +4,16 @@ use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::rc::Rc;
 
-use crate::sbc::panels::brush::{non_empty, BrushAction, BrushActions, ASSETS};
-use crate::sbc::panels::controls::grid::{list_assets, GridView};
+use crate::sbc::panels::brush::{non_empty, BrushAction, BrushActions};
+use crate::sbc::panels::controls::grid::GridView;
 use crate::sbc::panels::field::FieldValue;
 use crate::sbc::panels::fields::{BooleanField, ChoiceField, ColorField, NumericField};
 use crate::sbc::panels::runtime::{
     AssetGrid, AssetGridDef, Brush, EditorModel, FieldMut, FieldRef, TableEntry, TableModel,
 };
 use crate::sbc::rml::escape_rml;
 use crate::sbc::states::{BrushKind, BrushSettings};
+use crate::sbc::textures::materials::{Material, CHANNELS};
 
 /// Blend modes, in the order `texture_editor.lua` lists them.
 const MODES: &[&str] = &[
@@ -74,21 +75,6 @@ pub(super) const ACTIONS: &[BrushAction] = &[
     },
 ];
 
-/// A material's channels, as `TextureManager.materialTextures` defines them: one
-/// texture per channel, found by suffix next to the diffuse.
-///
-/// `normal` is a channel of every material but has no enable toggle, exactly as
-/// Lua skips it when it builds the checkboxes.
-const CHANNELS: &[(&str, &str, bool)] = &[
-    ("diffuse", "Diffuse", true),
-    ("specular", "Specular", true),
-    ("normal", "Normal", false),
-    ("emission", "Emission", true),
-    ("refl", "Refl", true),
-];
-
-const IMAGE_EXTS: &[&str] = &[".png", ".jpg", ".tga", ".dds", ".bmp"];
-
 /// The engine exposes at most four DNTS (splat normal) channels.
 pub(super) const DNTS_COUNT: i32 = 4;
 
@@ -99,14 +85,6 @@ pub(super) fn toggle_channels() -> impl Iterator<Item = &'static str> {
         .map(|(channel, _, _)| *channel)
 }
 
-/// One material: its name, and the channel textures that exist for it.
-#[derive(Clone)]
-pub(super) struct Material {
-    /// The bare material name (`dirt1`), which is what the picker shows.
-    pub(super) name: String,
-    pub(super) channels: BTreeMap<String, String>,
-}
-
 pub(super) struct SavedBrush {
     pub(super) id: String,
     pub(super) material: String,
@@ -115,46 +93,6 @@ pub(super) struct SavedBrush {
 
 pub(super) const ADD_BRUSH_ID: &str = "__add_saved_brush__";
 
-/// The material a texture belongs to: its file name with the channel suffix
-/// stripped, and without the directory. `.../brush_textures/dirt1_diffuse.png`
-/// is the `diffuse` of `dirt1`.
-fn material_of(path: &str) -> Option<(String, &'static str)> {
-    let file = path.rsplit('/').next()?;
-    let stem = file.rsplit_once('.').map(|(s, _)| s).unwrap_or(file);
-    for (channel, _, _) in CHANNELS {
-        if let Some(base) = stem.strip_suffix(&format!("_{channel}")) {
-            return Some((base.to_string(), channel));
-        }
-    }
-    None
-}
-
-/// Group the files under `brush_textures/` into materials. A material exists if
-/// it has a diffuse; the other channels are optional, which is why the picker
-/// shows which ones were found.
-pub(super) fn list_materials(interface: &NativeInterfaceRef) -> Vec<Material> {
-    let root = format!("{ASSETS}/brush_textures");
-    let mut found: BTreeMap<String, BTreeMap<String, String>> = BTreeMap::new();
-
-    for item in list_assets(interface, &root, IMAGE_EXTS) {
-        if item.is_directory {
-            continue;
-        }
-        if let Some((name, channel)) = material_of(&item.id) {
-            found
-                .entry(name)
-                .or_default()
-                .insert(channel.to_string(), item.id.clone());
-        }
-    }
-
-    found
-        .into_iter()
-        .filter(|(_, channels)| channels.contains_key("diffuse"))
-        .map(|(name, channels)| Material { name, channels })
-        .collect()
-}
-
 pub(super) fn material_tooltip(material: &Material) -> String {
     let channel = |name: &str, title: &str| {
         let (color, mark) = if material.channels.contains_key(name) {
@@ -677,26 +615,6 @@ pub(super) fn enabled_name(channel: &str) -> String {
 mod tests {
     use super::*;
 
-    /// The VFS hands back full paths, so the material's name is the file's, not
-    /// the path's -- every material was captioned "springboard" until it was.
-    #[test]
-    fn a_material_is_named_after_its_file_not_its_path() {
-        let (name, channel) =
-            material_of("springboard/assets/core/brush_textures/dirt1_diffuse.png").unwrap();
-        assert_eq!(name, "dirt1");
-        assert_eq!(channel, "diffuse");
-
-        let (name, channel) =
-            material_of("springboard/assets/core/brush_textures/cement_normal.png").unwrap();
-        assert_eq!(name, "cement");
-        assert_eq!(channel, "normal");
-    }
-
-    #[test]
-    fn a_texture_with_no_channel_suffix_belongs_to_no_material() {
-        assert!(material_of("brush_textures/readme.png").is_none());
-    }
-
     #[test]
     fn normal_is_a_channel_but_has_no_toggle() {
         let toggles: Vec<&str> = toggle_channels().collect();