Welt-Texturen aus der .glb statt aus assets/textures/
Der Loader zieht jetzt die baseColorTexture jedes Materials aus dem BIN-Chunk und dekodiert sie (PNG, via png-Crate) → model::Texture mit Pixeln. Die Namenskonvention "Materialname = Dateiname" und der assets/textures/-Pfad für Welt-Texturen entfallen; assets/textures/ bleibt nur noch für UI/Fonts/Platzhalter. - engine::image: neuer, geteilter RGBA8-Image-Typ (aus tga.rs gezogen) plus PNG-Decoder. tga.rs liefert weiter denselben Typ. - gltf: material -> texture -> image -> bufferView auflösen, Bild aus BIN dekodieren; fehlt ein Glied, bleibt image None (Platzhalter). KHR_texture_transform (Blenders Mapping-Node) wird beim Laden in die UVs eingebacken. - model::Model: materials: Vec<String> -> textures: Vec<Texture>. - render: die Pixel je Schlüssel aus den Modellen sammeln (erstes Vorkommen gewinnt, Schlüssel ohne Bild -> Platzhalter). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0196AM4UyAJEXVtPvp5DdKr8
This commit is contained in:
irrlicht
co-authored by
Claude Sonnet 5
Claude Sonnet 5
parent
937fbd6ede
commit
fc3494466e
Generated
+81
@@ -18,6 +18,12 @@ version = "0.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
|
||||
|
||||
[[package]]
|
||||
name = "adler2"
|
||||
version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
|
||||
|
||||
[[package]]
|
||||
name = "ahash"
|
||||
version = "0.8.12"
|
||||
@@ -410,6 +416,15 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crc32fast"
|
||||
version = "1.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8498c871161e1742aaa9d52551b2d6ebdd4c3d45a3be423e3728f33b955be550"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-utils"
|
||||
version = "0.8.21"
|
||||
@@ -496,12 +511,32 @@ dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fdeflate"
|
||||
version = "0.3.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
|
||||
dependencies = [
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "find-msvc-tools"
|
||||
version = "0.1.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
|
||||
|
||||
[[package]]
|
||||
name = "flate2"
|
||||
version = "1.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
|
||||
dependencies = [
|
||||
"crc32fast",
|
||||
"miniz_oxide 0.9.1",
|
||||
"zlib-rs",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "foldhash"
|
||||
version = "0.1.5"
|
||||
@@ -967,6 +1002,26 @@ version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
|
||||
|
||||
[[package]]
|
||||
name = "miniz_oxide"
|
||||
version = "0.8.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
|
||||
dependencies = [
|
||||
"adler2",
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "miniz_oxide"
|
||||
version = "0.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
|
||||
dependencies = [
|
||||
"adler2",
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "naga"
|
||||
version = "29.0.3"
|
||||
@@ -1436,6 +1491,19 @@ version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
|
||||
|
||||
[[package]]
|
||||
name = "png"
|
||||
version = "0.18.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
|
||||
dependencies = [
|
||||
"bitflags 2.13.0",
|
||||
"crc32fast",
|
||||
"fdeflate",
|
||||
"flate2",
|
||||
"miniz_oxide 0.8.9",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "polling"
|
||||
version = "3.11.0"
|
||||
@@ -1792,6 +1860,12 @@ version = "2.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
|
||||
|
||||
[[package]]
|
||||
name = "simd-adler32"
|
||||
version = "0.3.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
|
||||
|
||||
[[package]]
|
||||
name = "simd_cesu8"
|
||||
version = "1.1.1"
|
||||
@@ -2321,6 +2395,7 @@ version = "0.1.0"
|
||||
dependencies = [
|
||||
"bladeink",
|
||||
"bytemuck",
|
||||
"png",
|
||||
"pollster",
|
||||
"serde_json",
|
||||
"tinyaudio",
|
||||
@@ -2986,6 +3061,12 @@ dependencies = [
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zlib-rs"
|
||||
version = "0.6.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12"
|
||||
|
||||
[[package]]
|
||||
name = "zmij"
|
||||
version = "1.0.21"
|
||||
|
||||
@@ -6,6 +6,7 @@ edition = "2024"
|
||||
[dependencies]
|
||||
bladeink = "1.2.5"
|
||||
bytemuck = { version = "1.25.0", features = ["derive"] }
|
||||
png = "0.18.1"
|
||||
pollster = "0.4.0"
|
||||
serde_json = "1"
|
||||
tinyaudio = { version = "2", default-features = false, features = ["pulse"] }
|
||||
|
||||
@@ -7,13 +7,18 @@ Start in der Konsole gemeldet (`[model]`, `[audio]`, `[tex]`, …).
|
||||
|
||||
- **Format:** glTF Binary (`.glb`) nach `assets/maps/props/` — alle Dateien
|
||||
dort werden beim Start geladen (anderer Ordner: `cargo run -- --maps <dir>`).
|
||||
- **Beim Export anhaken:** „Include → Custom Properties" (sonst kommen
|
||||
keine der Properties unten an!).
|
||||
- **Beim Export anhaken:** „Include → Custom Properties" (sonst fehlen die
|
||||
Properties unten) **und** „Include → Textures" / „Data → Images"
|
||||
(sonst fehlen die Texturen).
|
||||
- **Maßstab:** 1 Blender-Meter = 1 Engine-Meter. Augenhöhe 1,6 m,
|
||||
Türen/Durchgänge ≥ 2 m hoch und ≥ 0,8 m breit denken.
|
||||
- **Material-Name = Textur-Name:** Material `holz` → `assets/textures/holz.tga`.
|
||||
Fehlt die Textur (oder das Material), erscheint die Platzhalter-Textur.
|
||||
- **Texturen:** TGA, unkomprimiert oder RLE, 24/32 bit.
|
||||
- **Texturen:** Bild im Material als Base Color zuweisen — es wird beim
|
||||
Export in die `.glb` eingebettet und mitgeladen (kein `assets/textures/`
|
||||
mehr). Format **PNG** (Export „Images: PNG" oder „Automatic"). Fehlt das
|
||||
Bild, erscheint die Platzhalter-Textur.
|
||||
- **Kacheln / Skalieren:** über einen **Mapping-Node** vor dem
|
||||
Image-Texture-Node (Location/Scale). Die Engine backt das
|
||||
(`KHR_texture_transform`) beim Laden in die UVs ein.
|
||||
|
||||
### Custom Properties auf Mesh-Objekten
|
||||
|
||||
|
||||
+1
-1
@@ -79,7 +79,7 @@ mod tests {
|
||||
use crate::engine::model::{Empty, Props};
|
||||
|
||||
fn model(empties: Vec<Empty>) -> Model {
|
||||
Model { objects: Vec::new(), empties, materials: Vec::new() }
|
||||
Model { objects: Vec::new(), empties, textures: Vec::new() }
|
||||
}
|
||||
|
||||
fn empty(name: &str, pos: [f32; 3], props: &[(&str, &str)]) -> Empty {
|
||||
|
||||
@@ -380,7 +380,7 @@ mod tests {
|
||||
test_cube("Deko", [5.0, 5.0, 5.0], None, None),
|
||||
],
|
||||
empties: Vec::new(),
|
||||
materials: vec![String::new()],
|
||||
textures: Vec::new(),
|
||||
};
|
||||
let mut w = CollisionWorld::empty();
|
||||
w.add_model(&model);
|
||||
|
||||
+191
-16
@@ -10,14 +10,21 @@
|
||||
//! Dreiecks-Primitives (Mode 4, Default) mit `POSITION`/`TEXCOORD_0`
|
||||
//! (float) und optionalen Indizes (u8/u16/u32). Node-Transforms (Matrix
|
||||
//! oder T·R·S, samt Hierarchie) werden in die Vertices eingebacken.
|
||||
//! Material-*Name* = Texturname; glTF-eigene Texturen/PBR bleiben ungenutzt.
|
||||
//!
|
||||
//! Texturen: die `baseColorTexture` jedes Materials wird aus dem BIN-Chunk
|
||||
//! geholt und dekodiert (PNG, wie Blender es einbettet) → `model::Texture`.
|
||||
//! `KHR_texture_transform` (Blenders Mapping-Node) wird beim Laden in die UVs
|
||||
//! eingebacken. Der Rest von glTFs PBR-Modell bleibt ungenutzt.
|
||||
//!
|
||||
//! Achsen: glTF ist per Spezifikation Y-up/−Z-forward — unser System,
|
||||
//! Blenders Exporter konvertiert selbst. Maßstab 1:1.
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
use crate::engine::model::{apply_props, fill_missing_normals, norm, Empty, Model, Object, Props};
|
||||
use crate::engine::image::{self, Image};
|
||||
use crate::engine::model::{apply_props, fill_missing_normals, norm, Empty, Model, Object, Props, Texture};
|
||||
|
||||
pub fn load(path: &str) -> Result<Model, String> {
|
||||
let bytes = std::fs::read(path).map_err(|e| format!("gltf load {path}: {e}"))?;
|
||||
@@ -52,7 +59,7 @@ pub fn parse_glb(bytes: &[u8]) -> Result<Model, String> {
|
||||
}
|
||||
|
||||
fn build(doc: &Value, bin: &[u8]) -> Result<Model, String> {
|
||||
let mut model = Model { objects: Vec::new(), empties: Vec::new(), materials: Vec::new() };
|
||||
let mut model = Model { objects: Vec::new(), empties: Vec::new(), textures: Vec::new() };
|
||||
|
||||
// Szenen-Wurzeln (Default-Szene, sonst 0) rekursiv ablaufen; die
|
||||
// Welt-Transform wächst dabei Parent → Kind.
|
||||
@@ -62,9 +69,109 @@ fn build(doc: &Value, bin: &[u8]) -> Result<Model, String> {
|
||||
let Some(i) = r.as_u64() else { continue; };
|
||||
walk_node(doc, bin, i as usize, IDENTITY, &mut model)?;
|
||||
}
|
||||
resolve_textures(doc, bin, &mut model);
|
||||
Ok(model)
|
||||
}
|
||||
|
||||
/// Nach dem Walk tragen die `tri_mats` rohe glTF-Material-Indizes
|
||||
/// (`usize::MAX` = kein Material). Daraus die deduplizierte Texturliste bauen
|
||||
/// (erste-Sicht-Reihenfolge) und die `tri_mats` auf ihre Indizes umschreiben.
|
||||
fn resolve_textures(doc: &Value, bin: &[u8], model: &mut Model) {
|
||||
let mut order: Vec<usize> = Vec::new();
|
||||
let mut local: HashMap<usize, usize> = HashMap::new();
|
||||
for o in &model.objects {
|
||||
for &m in &o.tri_mats {
|
||||
local.entry(m).or_insert_with(|| { order.push(m); order.len() - 1 });
|
||||
}
|
||||
}
|
||||
model.textures = order.iter().map(|&raw| build_texture(doc, bin, raw)).collect();
|
||||
for o in &mut model.objects {
|
||||
for m in &mut o.tri_mats { *m = local[m]; }
|
||||
}
|
||||
}
|
||||
|
||||
/// Das `model::Texture` für einen rohen glTF-Material-Index:
|
||||
/// `material → pbrMetallicRoughness.baseColorTexture → texture → image`, Bild
|
||||
/// aus dem BIN-Chunk dekodiert. Fehlt ein Glied, bleibt `image: None` (der
|
||||
/// Konsument nimmt seinen Platzhalter), der Schlüssel wird trotzdem gesetzt.
|
||||
fn build_texture(doc: &Value, bin: &[u8], raw_mat: usize) -> Texture {
|
||||
if raw_mat == usize::MAX {
|
||||
return Texture { key: String::new(), image: None };
|
||||
}
|
||||
let mat = &doc["materials"][raw_mat];
|
||||
let mat_name = mat["name"].as_str().unwrap_or("");
|
||||
let tex_ref = &mat["pbrMetallicRoughness"]["baseColorTexture"];
|
||||
let img_node = tex_ref["index"].as_u64()
|
||||
.and_then(|t| doc["textures"][t as usize]["source"].as_u64())
|
||||
.map(|s| &doc["images"][s as usize]);
|
||||
let Some(img_node) = img_node else {
|
||||
return Texture { key: mat_name.to_string(), image: None };
|
||||
};
|
||||
let key = img_node["name"].as_str()
|
||||
.filter(|s| !s.is_empty())
|
||||
.unwrap_or(mat_name)
|
||||
.to_string();
|
||||
let image = decode_embedded_image(doc, bin, img_node, &key);
|
||||
Texture { key, image }
|
||||
}
|
||||
|
||||
/// Ein `images[]`-Node aus dem BIN-Chunk dekodieren. Externe Dateien und
|
||||
/// Daten-URIs unterstützt der GLB-Pfad nicht — sie werden gemeldet.
|
||||
fn decode_embedded_image(doc: &Value, bin: &[u8], node: &Value, key: &str) -> Option<Image> {
|
||||
let Some(view) = node["bufferView"].as_u64() else {
|
||||
eprintln!("[tex] {key}: Bild ohne bufferView (externe Datei/Daten-URI wird nicht gelesen)");
|
||||
return None;
|
||||
};
|
||||
let bytes = match buffer_view_bytes(doc, bin, view as usize) {
|
||||
Ok(b) => b,
|
||||
Err(e) => { eprintln!("[tex] {key}: {e}"); return None; }
|
||||
};
|
||||
match image::decode(bytes, node["mimeType"].as_str().unwrap_or("")) {
|
||||
Ok(img) => Some(img),
|
||||
Err(e) => { eprintln!("[tex] {key}: {e}"); None }
|
||||
}
|
||||
}
|
||||
|
||||
/// Rohe Bytes eines bufferViews (ohne Accessor-Stride) aus dem BIN-Chunk.
|
||||
fn buffer_view_bytes<'a>(doc: &Value, bin: &'a [u8], view: usize) -> Result<&'a [u8], String> {
|
||||
let v = &doc["bufferViews"][view];
|
||||
if v.is_null() { return Err(format!("bufferView {view} fehlt")); }
|
||||
let off = v["byteOffset"].as_u64().unwrap_or(0) as usize;
|
||||
let len = v["byteLength"].as_u64().ok_or("bufferView ohne byteLength")? as usize;
|
||||
bin.get(off..off + len).ok_or_else(|| "bufferView ragt aus dem BIN-Chunk".into())
|
||||
}
|
||||
|
||||
/// KHR_texture_transform einer Textur-Referenz — hier landet Blenders
|
||||
/// Mapping-Node. Fehlt die Extension: `None`.
|
||||
struct UvTransform {
|
||||
offset: [f32; 2],
|
||||
scale: [f32; 2],
|
||||
rotation: f32,
|
||||
}
|
||||
|
||||
fn uv_transform(tex_ref: &Value) -> Option<UvTransform> {
|
||||
let x = &tex_ref["extensions"]["KHR_texture_transform"];
|
||||
if x.is_null() { return None; }
|
||||
Some(UvTransform {
|
||||
offset: vecn::<2>(&x["offset"], [0.0, 0.0]),
|
||||
scale: vecn::<2>(&x["scale"], [1.0, 1.0]),
|
||||
rotation: x["rotation"].as_f64().unwrap_or(0.0) as f32,
|
||||
})
|
||||
}
|
||||
|
||||
impl UvTransform {
|
||||
/// `uv' = translation · rotation · scale · uv` (KHR-Referenz: die
|
||||
/// Rotationsmatrix dreht mit negativem Winkel).
|
||||
fn apply(&self, uv: [f32; 2]) -> [f32; 2] {
|
||||
let (a, b) = (uv[0] * self.scale[0], uv[1] * self.scale[1]);
|
||||
let (s, c) = self.rotation.sin_cos();
|
||||
[
|
||||
c * a + s * b + self.offset[0],
|
||||
-s * a + c * b + self.offset[1],
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
fn walk_node(doc: &Value, bin: &[u8], idx: usize, parent: M4, model: &mut Model) -> Result<(), String> {
|
||||
let node = &doc["nodes"][idx];
|
||||
if node.is_null() { return Err(format!("Node {idx} fehlt")); }
|
||||
@@ -80,7 +187,7 @@ fn walk_node(doc: &Value, bin: &[u8], idx: usize, parent: M4, model: &mut Model)
|
||||
verts: Vec::new(), uvs: Vec::new(), normals: Vec::new(),
|
||||
tris: Vec::new(), tri_mats: Vec::new(),
|
||||
};
|
||||
append_mesh(doc, bin, mesh as usize, world, &mut o, &mut model.materials)?;
|
||||
append_mesh(doc, bin, mesh as usize, world, &mut o)?;
|
||||
fill_missing_normals(&mut o); // Primitives ohne NORMAL
|
||||
apply_props(&mut o); // collide-/signal-Regeln (siehe engine::model)
|
||||
if !o.tris.is_empty() { model.objects.push(o); }
|
||||
@@ -104,8 +211,7 @@ fn walk_node(doc: &Value, bin: &[u8], idx: usize, parent: M4, model: &mut Model)
|
||||
/// Alle Dreiecks-Primitives eines glTF-Meshes (Welt-transformiert) an ein
|
||||
/// Objekt anhängen. Nicht-Dreiecks-Modes werden gemeldet und übersprungen.
|
||||
fn append_mesh(
|
||||
doc: &Value, bin: &[u8], mesh: usize, world: M4,
|
||||
o: &mut Object, materials: &mut Vec<String>,
|
||||
doc: &Value, bin: &[u8], mesh: usize, world: M4, o: &mut Object,
|
||||
) -> Result<(), String> {
|
||||
for prim in doc["meshes"][mesh]["primitives"].as_array().into_iter().flatten() {
|
||||
if prim["mode"].as_u64().unwrap_or(4) != 4 {
|
||||
@@ -125,14 +231,10 @@ fn append_mesh(
|
||||
None => vec![[0.0, 0.0, 0.0]; positions.len()],
|
||||
};
|
||||
|
||||
// Material-Name → geteilte Namensliste; ohne Material "".
|
||||
let mat_name = prim["material"].as_u64()
|
||||
.and_then(|m| doc["materials"][m as usize]["name"].as_str())
|
||||
.unwrap_or("");
|
||||
let mi = materials.iter().position(|m| m == mat_name).unwrap_or_else(|| {
|
||||
materials.push(mat_name.to_string());
|
||||
materials.len() - 1
|
||||
});
|
||||
// Rohen glTF-Material-Index behalten; resolve_textures baut daraus
|
||||
// nach dem Walk die deduplizierte Texturliste und schreibt die
|
||||
// tri_mats auf deren Indizes um. usize::MAX = kein Material.
|
||||
let raw_mat = prim["material"].as_u64().map_or(usize::MAX, |m| m as usize);
|
||||
|
||||
let base = o.verts.len();
|
||||
let nm = normal_matrix(world);
|
||||
@@ -141,6 +243,14 @@ fn append_mesh(
|
||||
o.uvs.push(*uv);
|
||||
o.normals.push(norm(transform3(nm, *n)));
|
||||
}
|
||||
// KHR_texture_transform (Blenders Mapping-Node) in die UVs dieses
|
||||
// Primitives einbacken — der Shader bleibt UV-agnostisch.
|
||||
if raw_mat != usize::MAX {
|
||||
let tex_ref = &doc["materials"][raw_mat]["pbrMetallicRoughness"]["baseColorTexture"];
|
||||
if let Some(xf) = uv_transform(tex_ref) {
|
||||
for uv in &mut o.uvs[base..] { *uv = xf.apply(*uv); }
|
||||
}
|
||||
}
|
||||
|
||||
let idxs: Vec<usize> = match prim["indices"].as_u64() {
|
||||
Some(a) => read_indices(doc, bin, a as usize)?,
|
||||
@@ -151,7 +261,7 @@ fn append_mesh(
|
||||
return Err(format!("{}: Index außerhalb der Positionen", o.name));
|
||||
}
|
||||
o.tris.push([base + t[0], base + t[1], base + t[2]]);
|
||||
o.tri_mats.push(mi);
|
||||
o.tri_mats.push(raw_mat);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
@@ -431,7 +541,10 @@ mod tests {
|
||||
assert_eq!(d.verts[1], [11.0, 0.0, 0.0]); // Translation eingebacken
|
||||
// signal-Property ohne Collider → Betretens-Zone, wird nie gerendert.
|
||||
assert!(!d.visible && !d.collider);
|
||||
assert_eq!(m.materials, vec!["carpet".to_string()]);
|
||||
// Material "carpet" ohne baseColorTexture → Schlüssel gesetzt, kein Bild.
|
||||
assert_eq!(m.textures.len(), 1);
|
||||
assert_eq!(m.textures[0].key, "carpet");
|
||||
assert!(m.textures[0].image.is_none());
|
||||
|
||||
// Kind erbt die Parent-Transform (10, 0, 0);
|
||||
// collide="proxy" → unsichtbarer Collider.
|
||||
@@ -491,4 +604,66 @@ mod tests {
|
||||
v1[4] = 1; // Version patchen
|
||||
assert!(parse_glb(&v1).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn embedded_png_is_decoded_and_uv_transform_baked_in() {
|
||||
// 2×2-RGB-PNG (schwarz, rot, grün, blau) in den BIN-Chunk legen.
|
||||
let mut png_bytes = Vec::new();
|
||||
{
|
||||
let mut enc = png::Encoder::new(&mut png_bytes, 2, 2);
|
||||
enc.set_color(png::ColorType::Rgb);
|
||||
enc.set_depth(png::BitDepth::Eight);
|
||||
enc.write_header().unwrap()
|
||||
.write_image_data(&[0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255])
|
||||
.unwrap();
|
||||
}
|
||||
let mut bin = sample_bin();
|
||||
while !bin.len().is_multiple_of(4) { bin.push(0); }
|
||||
let img_off = bin.len();
|
||||
bin.extend_from_slice(&png_bytes);
|
||||
|
||||
let json = format!(r#"{{
|
||||
"asset": {{"version": "2.0"}},
|
||||
"scene": 0,
|
||||
"scenes": [{{"nodes": [0]}}],
|
||||
"nodes": [{{"name": "Boden", "mesh": 0}}],
|
||||
"meshes": [{{"primitives": [{{
|
||||
"attributes": {{"POSITION": 0, "TEXCOORD_0": 1, "NORMAL": 2}},
|
||||
"indices": 3, "material": 0
|
||||
}}]}}],
|
||||
"materials": [{{"name": "Bodenmat", "pbrMetallicRoughness": {{"baseColorTexture": {{
|
||||
"index": 0,
|
||||
"extensions": {{"KHR_texture_transform": {{"scale": [2.0, 4.0], "offset": [0.5, 0.0]}}}}
|
||||
}}}}}}],
|
||||
"textures": [{{"source": 0}}],
|
||||
"images": [{{"name": "boden_tex", "mimeType": "image/png", "bufferView": 4}}],
|
||||
"accessors": [
|
||||
{{"bufferView": 0, "componentType": 5126, "count": 3, "type": "VEC3"}},
|
||||
{{"bufferView": 1, "componentType": 5126, "count": 3, "type": "VEC2"}},
|
||||
{{"bufferView": 2, "componentType": 5126, "count": 3, "type": "VEC3"}},
|
||||
{{"bufferView": 3, "componentType": 5123, "count": 3, "type": "SCALAR"}}
|
||||
],
|
||||
"bufferViews": [
|
||||
{{"buffer": 0, "byteOffset": 0, "byteLength": 36}},
|
||||
{{"buffer": 0, "byteOffset": 36, "byteLength": 24}},
|
||||
{{"buffer": 0, "byteOffset": 60, "byteLength": 36}},
|
||||
{{"buffer": 0, "byteOffset": 96, "byteLength": 6}},
|
||||
{{"buffer": 0, "byteOffset": {img_off}, "byteLength": {png_len}}}
|
||||
],
|
||||
"buffers": [{{"byteLength": {bin_len}}}]
|
||||
}}"#, img_off = img_off, png_len = png_bytes.len(), bin_len = bin.len());
|
||||
|
||||
let m = parse_glb(&glb(&json, &bin)).unwrap();
|
||||
|
||||
assert_eq!(m.textures.len(), 1);
|
||||
let t = &m.textures[0];
|
||||
assert_eq!(t.key, "boden_tex"); // glTF-Bildname, nicht Materialname
|
||||
let img = t.image.as_ref().expect("PNG dekodiert");
|
||||
assert_eq!((img.width, img.height), (2, 2));
|
||||
assert_eq!(&img.rgba[0..8], &[0, 0, 0, 255, 255, 0, 0, 255]);
|
||||
|
||||
// KHR_texture_transform eingebacken: UV (1,1) → (1·2 + 0.5, 1·4) = (2.5, 4.0).
|
||||
let uv = m.objects[0].uvs[2];
|
||||
assert!((uv[0] - 2.5).abs() < 1e-5 && (uv[1] - 4.0).abs() < 1e-5, "{uv:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
//! RGBA8-`Image` — der geteilte Pixel-Container der Engine, dazu der Decoder
|
||||
//! für eingebettete glTF-Bilder. Immer 32 bit, Ursprung oben-links, fertig
|
||||
//! konvertiert; der Aufrufer macht nur noch das Sampling (und damit die
|
||||
//! UV-Konvention) selbst.
|
||||
//!
|
||||
//! [`decode`] liest die Bilder, die Blender beim glTF-Export in die `.glb`
|
||||
//! packt (PNG). TGA-Dateien (UI, Fonts) laufen über [`super::tga`] und liefern
|
||||
//! denselben `Image`-Typ.
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Image {
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
/// `width * height * 4`, Ursprung oben-links.
|
||||
pub rgba: Vec<u8>,
|
||||
}
|
||||
|
||||
/// Ein eingebettetes glTF-Bild dekodieren. `mime` ist der glTF-`mimeType`
|
||||
/// (darf leer sein — dann entscheidet die Datei-Signatur). Unterstützt wird
|
||||
/// nur PNG; JPEG/WebP werden gemeldet, nicht dekodiert.
|
||||
pub fn decode(bytes: &[u8], mime: &str) -> Result<Image, String> {
|
||||
const PNG_MAGIC: &[u8] = b"\x89PNG\r\n\x1a\n";
|
||||
let is_png = mime == "image/png" || (mime.is_empty() && bytes.starts_with(PNG_MAGIC));
|
||||
if !is_png {
|
||||
let what = if mime.is_empty() { "unbekanntes Format" } else { mime };
|
||||
return Err(format!("{what} — nur PNG (in Blender „Images: PNG“ beim glTF-Export)"));
|
||||
}
|
||||
decode_png(bytes)
|
||||
}
|
||||
|
||||
fn decode_png(bytes: &[u8]) -> Result<Image, String> {
|
||||
let mut decoder = png::Decoder::new(std::io::Cursor::new(bytes));
|
||||
// EXPAND hebt Palette/Low-Bit-Grau auf 8 bit, ALPHA erzwingt einen
|
||||
// Alpha-Kanal, STRIP_16 wirft die zweite Byte-Hälfte weg. Damit bleiben
|
||||
// als Ausgabe nur noch RGBA8 und Grau+Alpha8.
|
||||
decoder.set_transformations(
|
||||
png::Transformations::EXPAND | png::Transformations::ALPHA | png::Transformations::STRIP_16,
|
||||
);
|
||||
let mut reader = decoder.read_info().map_err(|e| format!("PNG: {e}"))?;
|
||||
let mut buf = vec![0u8; reader.output_buffer_size().ok_or("PNG: Bild zu groß")?];
|
||||
let info = reader.next_frame(&mut buf).map_err(|e| format!("PNG: {e}"))?;
|
||||
let (width, height) = (info.width, info.height);
|
||||
let src = &buf[..info.buffer_size()];
|
||||
let n = (width as usize) * (height as usize);
|
||||
|
||||
let rgba = match info.color_type {
|
||||
png::ColorType::Rgba => src.to_vec(),
|
||||
png::ColorType::GrayscaleAlpha => {
|
||||
let mut out = vec![0u8; n * 4];
|
||||
for i in 0..n {
|
||||
let (v, a) = (src[2 * i], src[2 * i + 1]);
|
||||
let o = i * 4;
|
||||
out[o] = v; out[o + 1] = v; out[o + 2] = v; out[o + 3] = a;
|
||||
}
|
||||
out
|
||||
}
|
||||
other => return Err(format!("PNG: unerwarteter Ausgabetyp {other:?}")),
|
||||
};
|
||||
Ok(Image { width, height, rgba })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Ein `w`×`h`-PNG mit gegebenem Farbtyp im Speicher erzeugen.
|
||||
fn png(w: u32, h: u32, color: png::ColorType, data: &[u8]) -> Vec<u8> {
|
||||
let mut out = Vec::new();
|
||||
let mut enc = png::Encoder::new(&mut out, w, h);
|
||||
enc.set_color(color);
|
||||
enc.set_depth(png::BitDepth::Eight);
|
||||
enc.write_header().unwrap().write_image_data(data).unwrap();
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rgb_png_gets_opaque_alpha() {
|
||||
// 2×1, zwei RGB-Pixel.
|
||||
let bytes = png(2, 1, png::ColorType::Rgb, &[10, 20, 30, 40, 50, 60]);
|
||||
let img = decode(&bytes, "image/png").unwrap();
|
||||
assert_eq!((img.width, img.height), (2, 1));
|
||||
assert_eq!(img.rgba, vec![10, 20, 30, 255, 40, 50, 60, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn grayscale_png_expands_to_rgba() {
|
||||
let bytes = png(2, 1, png::ColorType::Grayscale, &[128, 255]);
|
||||
let img = decode(&bytes, "").unwrap(); // mime leer → Signatur greift
|
||||
assert_eq!(img.rgba, vec![128, 128, 128, 255, 255, 255, 255, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn non_png_is_reported_not_decoded() {
|
||||
assert!(decode(b"\xff\xd8\xff\xe0junk", "image/jpeg").is_err());
|
||||
assert!(decode(b"whatever", "").is_err());
|
||||
}
|
||||
}
|
||||
+6
-3
@@ -14,9 +14,11 @@
|
||||
//! so wie story_ctrl Tags zurückgibt, statt selbst `signals::dispatch` zu
|
||||
//! rufen.
|
||||
//!
|
||||
//! `gltf`, `tga` und `wav` sind reine Decoder (Bytes → owned Daten); `gltf`
|
||||
//! ist DER 3D-Pfad und produziert das `model::Model`, den Vertrag zwischen
|
||||
//! Loader und seinen Konsumenten (collision, trigger, audio, render::props).
|
||||
//! `gltf`, `tga`, `image` und `wav` sind reine Decoder (Bytes → owned Daten);
|
||||
//! `gltf` ist DER 3D-Pfad und produziert das `model::Model`, den Vertrag
|
||||
//! zwischen Loader und seinen Konsumenten (collision, trigger, audio,
|
||||
//! render::props) — samt der Welt-Texturen, die als PNG in der `.glb` liegen
|
||||
//! (dekodiert über `image`, das den RGBA8-`Image`-Typ auch für `tga` stellt).
|
||||
//! `audio` ist die Emitter-Logik zum Frontend-Treiber render::audio, `player`
|
||||
//! die First-Person-Physik auf der Welt aus `collision`. Post-Effekte kennt
|
||||
//! der Kern nur als `game::Action::SetPost` — die Kette lebt in render::post.
|
||||
@@ -26,6 +28,7 @@ pub mod audio;
|
||||
pub mod collision;
|
||||
pub mod game;
|
||||
pub mod gltf;
|
||||
pub mod image;
|
||||
pub mod ink;
|
||||
pub mod kv;
|
||||
pub mod model;
|
||||
|
||||
+23
-5
@@ -6,6 +6,10 @@
|
||||
//! glTF ist der einzige 3D-Pfad (die OBJ- und Map-Loader-Pfade sind
|
||||
//! Geschichte), `gltf` der einzige Produzent.
|
||||
//!
|
||||
//! Texturen kommen als Pixel mit — der Loader zieht sie aus der `.glb`
|
||||
//! (baseColorTexture, PNG-Chunk im BIN), siehe [`Texture`]. Keine externe
|
||||
//! Namenskonvention mehr.
|
||||
//!
|
||||
//! Was ein Objekt *ist*, steuern seine Blender-Custom-Properties (keine
|
||||
//! Namens-Präfixe — Namen bleiben frei für die Autorin), siehe
|
||||
//! [`apply_props`]:
|
||||
@@ -22,6 +26,8 @@
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::engine::image::Image;
|
||||
|
||||
/// Blender-Custom-Properties eines Objekts/Empties (glTF-`extras`),
|
||||
/// Werte zu Strings vereinheitlicht.
|
||||
pub type Props = HashMap<String, String>;
|
||||
@@ -31,10 +37,22 @@ pub struct Model {
|
||||
/// Nodes ohne Mesh (Blender-Empties) — der Entity-Kanal: Marker für
|
||||
/// Spawn-Punkte, Trigger o.Ä., Bedeutung geben künftige Konsumenten.
|
||||
pub empties: Vec<Empty>,
|
||||
/// Distinkte Materialnamen in Auftrittsreihenfolge; `Object::tri_mats`
|
||||
/// indiziert hierhin. `""` steht für „Faces ohne Material" — der
|
||||
/// Konsument wählt dafür seinen Fallback (z.B. Platzhalter-Textur).
|
||||
pub materials: Vec<String>,
|
||||
/// Distinkte Texturen in Auftrittsreihenfolge; `Object::tri_mats`
|
||||
/// indiziert hierhin.
|
||||
pub textures: Vec<Texture>,
|
||||
}
|
||||
|
||||
/// Eine baseColorTexture aus der `.glb` (bzw. ein Material ohne Bild).
|
||||
pub struct Texture {
|
||||
/// Dedup-/Log-Schlüssel: der glTF-Bildname (Blender: Name des
|
||||
/// Bild-Datablocks), sonst der Materialname, sonst `""`. Texturen mit
|
||||
/// gleichem Schlüssel — auch über mehrere `.glb` — teilen sich auf der
|
||||
/// GPU eine Textur.
|
||||
pub key: String,
|
||||
/// Dekodierte Pixel (RGBA8, Ursprung oben links). `None`: Material ohne
|
||||
/// baseColorTexture oder unlesbares Bild → der Konsument nimmt seine
|
||||
/// Platzhalter-Textur.
|
||||
pub image: Option<Image>,
|
||||
}
|
||||
|
||||
pub struct Object {
|
||||
@@ -49,7 +67,7 @@ pub struct Object {
|
||||
/// Modell, rechnet der Loader sie aus den Flächen.
|
||||
pub normals: Vec<[f32; 3]>,
|
||||
pub tris: Vec<[usize; 3]>,
|
||||
/// Material-Index je Dreieck, parallel zu `tris` (→ `Model::materials`).
|
||||
/// Textur-Index je Dreieck, parallel zu `tris` (→ `Model::textures`).
|
||||
pub tri_mats: Vec<usize>,
|
||||
pub visible: bool,
|
||||
pub collider: bool,
|
||||
|
||||
+5
-7
@@ -1,19 +1,17 @@
|
||||
//! TGA-Decoder → fertig dekodiertes RGBA8-`Image`.
|
||||
//! TGA-Decoder → fertig dekodiertes RGBA8-[`Image`] (der Typ lebt in
|
||||
//! [`super::image`], geteilt mit dem PNG-Pfad).
|
||||
//!
|
||||
//! Neutral: kennt weder GPU noch UI noch Fonts. Liefert *immer* RGBA8,
|
||||
//! Ursprung oben-links, vollständig konvertiert — der Aufrufer macht keine
|
||||
//! Nachbearbeitung, nur das Sampling (und damit die UV-Konvention) gehört ihm.
|
||||
//! Zuständig für UI- und Font-Assets; Welt-Texturen kommen als PNG aus der
|
||||
//! `.glb` (siehe [`super::gltf`]).
|
||||
//!
|
||||
//! Unterstützt True-Color unkomprimiert (Typ 2) und RLE (Typ 10) mit 24
|
||||
//! oder 32 bpp, sowie Graustufen (Typ 3/11, 8 bpp → zu RGBA expandiert) für
|
||||
//! Font-Maps. Paletten-TGAs gibt es nicht mehr (wds ist 15-bit True-Color).
|
||||
|
||||
pub struct Image {
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
/// `width * height * 4`, Ursprung oben-links.
|
||||
pub rgba: Vec<u8>,
|
||||
}
|
||||
use crate::engine::image::Image;
|
||||
|
||||
pub fn load(path: &str) -> Result<Image, String> {
|
||||
let bytes = std::fs::read(path).map_err(|e| format!("tga load {path}: {e}"))?;
|
||||
|
||||
@@ -100,7 +100,7 @@ mod tests {
|
||||
use crate::engine::model::{test_cube as cube, Object};
|
||||
|
||||
fn model(objects: Vec<Object>) -> Model {
|
||||
Model { objects, empties: Vec::new(), materials: vec![String::new()] }
|
||||
Model { objects, empties: Vec::new(), textures: Vec::new() }
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
+1
-1
@@ -17,7 +17,7 @@
|
||||
//! seinen GPU-Textur-Index, damit `ui::Ui::text` ohne Zusatzargumente damit
|
||||
//! zeichnen kann.
|
||||
|
||||
use crate::engine::tga::Image;
|
||||
use crate::engine::image::Image;
|
||||
|
||||
const COLS: u32 = 32;
|
||||
|
||||
|
||||
+1
-1
@@ -16,7 +16,7 @@ use std::sync::Arc;
|
||||
|
||||
use winit::window::Window;
|
||||
|
||||
use crate::engine::tga::Image;
|
||||
use crate::engine::image::Image;
|
||||
use crate::render::math::Mat4;
|
||||
use crate::render::post::{Post, PostChain};
|
||||
use crate::render::scene::{Mesh, ScenePass};
|
||||
|
||||
+24
-17
@@ -29,8 +29,8 @@ use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
|
||||
use winit::keyboard::{KeyCode, PhysicalKey};
|
||||
use winit::window::{CursorGrabMode, Window, WindowId};
|
||||
|
||||
use crate::engine::image::Image;
|
||||
use crate::engine::player;
|
||||
use crate::engine::tga::Image;
|
||||
use crate::engine::{assets, gltf, model, tga, wav};
|
||||
use crate::session::{FrameInput, Mode, Session};
|
||||
use gpu::Gpu;
|
||||
@@ -58,13 +58,26 @@ pub fn run(mut session: Session, maps_dir: &str) {
|
||||
// `Gpu` — die beiden bleiben getrennt.
|
||||
let models = load_models(maps_dir);
|
||||
|
||||
// Eine geteilte Texturliste über alle Modelle, damit ihre Meshes
|
||||
// denselben Index-Raum benutzen und zu einem Buffer verschmelzen können.
|
||||
// Eine geteilte Textur-Schlüsselliste über alle Modelle, damit ihre
|
||||
// Meshes denselben Index-Raum benutzen und zu einem Buffer verschmelzen.
|
||||
let mut tex_names: Vec<String> = Vec::new();
|
||||
for (_, m) in &models { tex_names.extend(props::texture_names(m)); }
|
||||
for (_, m) in &models { tex_names.extend(props::texture_keys(m)); }
|
||||
tex_names.sort_unstable();
|
||||
tex_names.dedup();
|
||||
let images: Vec<Image> = tex_names.iter().map(|n| load_texture(n)).collect();
|
||||
|
||||
// Die Pixel liegen in den `.glb` selbst; gleicher Schlüssel = eine Textur
|
||||
// (erstes Vorkommen gewinnt). Schlüssel ohne Bild treffen den Platzhalter
|
||||
// (Projekt-Asset, darf hart scheitern).
|
||||
let mut by_key: HashMap<&str, &Image> = HashMap::new();
|
||||
for (_, m) in &models {
|
||||
for t in &m.textures {
|
||||
if let Some(img) = &t.image { by_key.entry(props::texture_key(t)).or_insert(img); }
|
||||
}
|
||||
}
|
||||
let placeholder = placeholder();
|
||||
let images: Vec<Image> = tex_names.iter()
|
||||
.map(|k| by_key.get(k.as_str()).map_or_else(|| placeholder.clone(), |i| (*i).clone()))
|
||||
.collect();
|
||||
|
||||
let mut mesh = Mesh::default();
|
||||
for (_, m) in &models { mesh.append(props::build(m, &tex_names)); }
|
||||
@@ -186,18 +199,12 @@ fn load_sound(name: &str) -> Option<audio::Sound> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Welt-Textur laden. Autorinnen-Content: fehlt oder klemmt die Datei, wird
|
||||
/// gemeldet und der Platzhalter genommen — der selbst ist Projekt-Asset und
|
||||
/// darf hart scheitern.
|
||||
fn load_texture(name: &str) -> Image {
|
||||
match tga::load(&assets::path(&format!("assets/textures/{name}.tga"))) {
|
||||
Ok(img) => img,
|
||||
Err(e) => {
|
||||
eprintln!("[tex] {e} — Platzhalter");
|
||||
tga::load(&assets::path(&format!("assets/textures/{}.tga", props::FALLBACK_TEXTURE)))
|
||||
.expect("Platzhalter-Textur (Projekt-Asset)")
|
||||
}
|
||||
}
|
||||
/// Die Platzhalter-Textur für Schlüssel ohne eigenes Bild in der `.glb`.
|
||||
/// Projekt-Asset: fehlt sie, ist die Installation kaputt und es darf scheitern.
|
||||
fn placeholder() -> Image {
|
||||
let name = props::FALLBACK_TEXTURE;
|
||||
tga::load(&assets::path(&format!("assets/textures/{name}.tga")))
|
||||
.expect("Platzhalter-Textur (Projekt-Asset)")
|
||||
}
|
||||
|
||||
/// Aktueller Eingabezustand. Tasten als gehaltene Flags (nicht Events),
|
||||
|
||||
+45
-25
@@ -4,34 +4,42 @@
|
||||
//! [`Mesh`] (Vertices + nach Textur gruppierte Index-Batches); mehrere
|
||||
//! Modelle verschmelzen über `Mesh::append` zu einem Buffer.
|
||||
//!
|
||||
//! Texturen: der Blender-Materialname *ist* der Texturname — aufgelöst zu
|
||||
//! `assets/textures/{name}.tga` (macht der Aufrufer). Faces ohne Material
|
||||
//! (`""`) laufen unter [`FALLBACK_TEXTURE`].
|
||||
//! Texturen liegen als Pixel im Modell (`model::Texture`, aus der `.glb`).
|
||||
//! Hier wird nur nach ihrem Schlüssel gruppiert; Texturen ohne Bild —
|
||||
//! Material ohne baseColorTexture oder unlesbar — landen unter
|
||||
//! [`FALLBACK_TEXTURE`], dessen Pixel der Aufrufer stellt.
|
||||
//!
|
||||
//! UVs kommen unverändert durch (Modell und `tga::Image` teilen den
|
||||
//! Oben-links-Ursprung). Nur `visible`-Objekte werden ausgegeben;
|
||||
//! UVs kommen unverändert durch (Modell und `Image` teilen den
|
||||
//! Oben-links-Ursprung; `KHR_texture_transform` hat der Loader schon
|
||||
//! eingebacken). Nur `visible`-Objekte werden ausgegeben;
|
||||
//! Collider-/Zonen-Volumen sind Sache von engine::collision und
|
||||
//! engine::trigger.
|
||||
|
||||
use crate::engine::model::Model;
|
||||
use crate::engine::model::{Model, Texture};
|
||||
use crate::render::scene::{Batch, Mesh, Vertex};
|
||||
|
||||
/// Texturname für Faces ohne Material (`""`).
|
||||
/// Schlüssel für Texturen ohne eigenes Bild; der Aufrufer lädt die Pixel
|
||||
/// dazu (`assets/textures/placeholder.tga`).
|
||||
pub const FALLBACK_TEXTURE: &str = "placeholder";
|
||||
|
||||
/// Distinkte Texturnamen des Modells (sortiert), `""` bereits auf den
|
||||
/// Fallback gemappt.
|
||||
pub fn texture_names(model: &Model) -> Vec<String> {
|
||||
let mut names: Vec<String> = model.materials.iter()
|
||||
.map(|m| resolve(m).to_string())
|
||||
/// Distinkte Textur-Schlüssel des Modells (sortiert), bildlose bereits auf
|
||||
/// den Fallback gemappt.
|
||||
pub fn texture_keys(model: &Model) -> Vec<String> {
|
||||
let mut keys: Vec<String> = model.textures.iter()
|
||||
.map(|t| texture_key(t).to_string())
|
||||
.collect();
|
||||
names.sort_unstable();
|
||||
names.dedup();
|
||||
names
|
||||
keys.sort_unstable();
|
||||
keys.dedup();
|
||||
keys
|
||||
}
|
||||
|
||||
fn resolve(material: &str) -> &str {
|
||||
if material.is_empty() { FALLBACK_TEXTURE } else { material }
|
||||
/// Gruppierungs-Schlüssel einer Textur: ihr eigener, sofern sie Pixel hat —
|
||||
/// sonst der Fallback. Der Renderer sammelt darüber die Pixel je Schlüssel.
|
||||
pub fn texture_key(t: &Texture) -> &str {
|
||||
match &t.image {
|
||||
Some(_) if !t.key.is_empty() => &t.key,
|
||||
_ => FALLBACK_TEXTURE,
|
||||
}
|
||||
}
|
||||
|
||||
/// Alle sichtbaren Objekte zu einem Mesh. `tex_names` gibt die Textur-
|
||||
@@ -53,7 +61,7 @@ pub fn build(model: &Model, tex_names: &[String]) -> Mesh {
|
||||
}
|
||||
id += 1;
|
||||
for (t, &m) in o.tris.iter().zip(&o.tri_mats) {
|
||||
let name = resolve(&model.materials[m]);
|
||||
let name = texture_key(&model.textures[m]);
|
||||
let Some(ti) = tex_names.iter().position(|n| n == name) else { continue; };
|
||||
per_tex[ti].extend(t.map(|i| base + i as u32));
|
||||
}
|
||||
@@ -73,8 +81,19 @@ pub fn build(model: &Model, tex_names: &[String]) -> Mesh {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::engine::image::Image;
|
||||
use crate::engine::model::{Model, Object, Props};
|
||||
|
||||
/// 1×1-Platzhalterbild, damit eine Textur „Pixel hat".
|
||||
fn pixel() -> Image {
|
||||
Image { width: 1, height: 1, rgba: vec![255, 255, 255, 255] }
|
||||
}
|
||||
|
||||
/// Textur mit Bild und Schlüssel `key`.
|
||||
fn tex(key: &str) -> Texture {
|
||||
Texture { key: key.into(), image: Some(pixel()) }
|
||||
}
|
||||
|
||||
/// Ein Dreieck mit UVs; `visible` steuert, ob es gerendert werden darf.
|
||||
fn tri(name: &str, visible: bool) -> Object {
|
||||
Object {
|
||||
@@ -93,14 +112,14 @@ mod tests {
|
||||
Model {
|
||||
objects: vec![tri("Ding", true), tri("Proxy", false)],
|
||||
empties: Vec::new(),
|
||||
materials: vec!["carpet".to_string()],
|
||||
textures: vec![tex("carpet")],
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_only_visible_objects() {
|
||||
let m = sample();
|
||||
let names = texture_names(&m);
|
||||
let names = texture_keys(&m);
|
||||
assert_eq!(names, vec!["carpet".to_string()]);
|
||||
let mesh = build(&m, &names);
|
||||
|
||||
@@ -114,7 +133,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn visible_objects_get_distinct_ids_across_models() {
|
||||
let names = texture_names(&sample());
|
||||
let names = texture_keys(&sample());
|
||||
// Zwei sichtbare Objekte + ein unsichtbarer Proxy je Modell.
|
||||
let mut m = sample();
|
||||
m.objects.insert(1, tri("Zweites", true));
|
||||
@@ -133,11 +152,12 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_material_maps_to_fallback() {
|
||||
fn imageless_texture_maps_to_fallback() {
|
||||
let mut m = sample();
|
||||
m.materials = vec![String::new()]; // Faces ohne Material
|
||||
assert_eq!(texture_names(&m), vec![FALLBACK_TEXTURE.to_string()]);
|
||||
let mesh = build(&m, &texture_names(&m));
|
||||
// Material ohne baseColorTexture: Schlüssel gesetzt, aber kein Bild.
|
||||
m.textures = vec![Texture { key: "nackt".into(), image: None }];
|
||||
assert_eq!(texture_keys(&m), vec![FALLBACK_TEXTURE.to_string()]);
|
||||
let mesh = build(&m, &texture_keys(&m));
|
||||
assert_eq!(mesh.batches.len(), 1);
|
||||
}
|
||||
|
||||
|
||||
+3
-3
@@ -1,13 +1,13 @@
|
||||
//! Szenen-Pass: zeichnet die 3D-Welt ins interne Target.
|
||||
//!
|
||||
//! Geometrie + Texturen kommen vom Aufrufer (Blender-Modelle via
|
||||
//! render::props; Bilder aus engine::tga). Pro Textur eine Bind-Group +
|
||||
//! ein Draw-Batch (Material-Batching „pro Textur ein Draw" wie im Plan).
|
||||
//! render::props; Bilder als RGBA8-`Image`, aus der `.glb` dekodiert). Pro
|
||||
//! Textur eine Bind-Group + ein Draw-Batch („pro Textur ein Draw" wie im Plan).
|
||||
//! Die Shader (scene.wgsl) sind die echten PS1-Shader.
|
||||
|
||||
use wgpu::util::DeviceExt;
|
||||
|
||||
use crate::engine::tga::Image;
|
||||
use crate::engine::image::Image;
|
||||
use crate::render::math::Mat4;
|
||||
|
||||
#[repr(C)]
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
//! hochgeladen — wie beim Szenen-Pass: Decode (CPU) ≠ Upload (GPU), und über
|
||||
//! dieselbe `scene::upload_texture`, nur ohne Mipchain.
|
||||
|
||||
use crate::engine::tga::Image;
|
||||
use crate::engine::image::Image;
|
||||
use crate::render::scene::upload_texture;
|
||||
|
||||
#[repr(C)]
|
||||
|
||||
+1
-1
@@ -10,7 +10,7 @@
|
||||
//! Koordinaten sind interne Pixel (das Overlay wird vor dem Blit gezeichnet,
|
||||
//! teilt also den Lo-Fi-Look). Gezeichnet wird über [`crate::render::sprite`].
|
||||
|
||||
use crate::engine::tga::Image;
|
||||
use crate::engine::image::Image;
|
||||
use crate::render::font::{self, Font, Fonts};
|
||||
use crate::render::sprite::{SpriteBatch, SpriteVertex};
|
||||
use crate::session::{Dialog, Mode, Session};
|
||||
|
||||
+2
-2
@@ -558,7 +558,7 @@ mod tests {
|
||||
"Kiste", [5.0, 0.0, 5.0], Some("1"), Some("set kiste_geklickt true")),
|
||||
],
|
||||
empties: Vec::new(),
|
||||
materials: vec![String::new()],
|
||||
textures: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -628,7 +628,7 @@ mod tests {
|
||||
props: crate::engine::model::Props::new(),
|
||||
},
|
||||
],
|
||||
materials: Vec::new(),
|
||||
textures: Vec::new(),
|
||||
});
|
||||
assert_eq!(s.player.pos, [3.0, 0.5, -2.0], "role=spawn setzt den Fußpunkt");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user