feat(formats,cli): decode XBG7 stage containers + fix weapon layout
Stage containers (hidden/resource3d/Stage_S*.xpr) are collections of up to
~450 enemy/prop sub-models, not single meshes. Xbg7Model::stage_models decodes
them: each resource is a [12-byte header][index buffer][vertex buffer] block
(index count = descriptor marker, vertex count = u32 32 bytes before it) whose
on-disc offset is NOT stored, so it is located by content — one O(file) pass per
stride finds vertex-buffer starts (unit NORMAL at +12 whose previous slot isn't)
and each resource is pinned to the candidate whose indices validate and produce
non-degenerate, well-connected triangles. A connectivity gate (mean triangle
edge <= 0.28x the bbox diagonal) rejects spiky mis-anchors. ~4993 sub-models
decode across the 22 stages.
The same insight fixes the weapon single-model layout: it is [12-byte header]
[index][vertex] too, not [index][12-byte gap][vertex]. Reading indices from the
block start turned the 12 header bytes into 6 junk indices (2 leading degenerate
triangles — the recurring stray-triangle artifact) and dropped the last 6 real
indices. Skipping the header leaves vertex offsets identical (coverage unchanged
at 36/166) and corrects the triangle list. Verified on wep_00/03/04.
Adds `sylpheed-cli mesh {info,render}` — a headless software rasterizer that
writes a shaded PNG (orthographic, z-buffered, two-sided), so recovered geometry
can be verified without the GUI. Stages render as a normalised thumbnail grid;
--only filters sub-models.
Tests: stage_models_{decode,sweep,quality_audit}; docs/re updated (xbg7-mesh.md
evidence log + INDEX.md).
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
MechaCat02
@@ -150,12 +150,17 @@ impl Xbg7Model {
|
||||
let mut off = 0usize; // relative to `base`
|
||||
let mut meshes = Vec::new();
|
||||
for (vtx_count, idx_count) in records {
|
||||
let ib = base + off;
|
||||
// Each sub-mesh block is `[12-byte header][index buffer][vertex
|
||||
// buffer]` — the SAME layout as stage resources (see
|
||||
// `stage_models`). The header must be skipped: reading indices from
|
||||
// the block start instead treats the 12 header bytes as 6 junk
|
||||
// indices (2 leading degenerate triangles — the stray-triangle
|
||||
// artifact) and drops the last 6 real indices. Skipping it leaves the
|
||||
// vertex buffer at the identical offset (`+12 + idx_bytes`), so
|
||||
// coverage is unchanged; only the triangle list is corrected.
|
||||
let ib = base + off + VERTEX_BUFFER_GAP;
|
||||
let ie = ib + idx_count * 2;
|
||||
// The vertex buffer follows the index buffer after a fixed 12-byte
|
||||
// header (a normal length of exactly 1.0 pins this offset across
|
||||
// every decoded model — `align`-based guesses landed 4 bytes early).
|
||||
let vb = ie + VERTEX_BUFFER_GAP;
|
||||
let vb = ie;
|
||||
let ve = vb + vtx_count * decl.stride;
|
||||
if ve > bytes.len() {
|
||||
return Err(MeshError::UnsupportedLayout);
|
||||
@@ -232,12 +237,333 @@ impl Xbg7Model {
|
||||
|
||||
Ok(Xbg7Model { name, meshes })
|
||||
}
|
||||
|
||||
/// Decode **every** locatable XBG7 geometry resource in a container.
|
||||
///
|
||||
/// "Stage" containers (`hidden/resource3d/Stage_*.xpr`) are collections of
|
||||
/// many enemy / prop sub-models, each an independent XBG7 resource. Unlike
|
||||
/// the single-stream weapon layout (index buffer immediately followed by its
|
||||
/// vertex buffer), a stage's index buffers and vertex buffers live in
|
||||
/// **separate grouped pools**, and the container stores each resource's
|
||||
/// buffer *sizes* (index count via the marker, vertex count 32 bytes before
|
||||
/// it) but **not** an explicit data offset — the on-disc block layout is a
|
||||
/// separate allocation order we have not reversed.
|
||||
///
|
||||
/// Rather than guess that order, each resource's `[index buffer][vertex
|
||||
/// buffer]` block is located by **content**: the unique offset in the data
|
||||
/// section where (a) all `index_count` indices are `< vertex_count`, (b) the
|
||||
/// stored normals are unit length, and (c) the resulting triangles are
|
||||
/// non-degenerate with a real spatial extent. This signature is strong
|
||||
/// enough to pin a block unambiguously in a multi-megabyte file. Resources
|
||||
/// that cannot be located and validated this way are **skipped** (never
|
||||
/// emitted as garbage) — including the biggest hero bodies, which use the
|
||||
/// same quantized/complex layout that [`Xbg7Model::from_xpr2`] declines.
|
||||
///
|
||||
/// Returns one [`Xbg7Model`] per decoded resource (empty if none decode).
|
||||
pub fn stage_models(bytes: &[u8]) -> Vec<Xbg7Model> {
|
||||
let mut out = Vec::new();
|
||||
if bytes.len() < 16 || &bytes[..4] != b"XPR2" {
|
||||
return out;
|
||||
}
|
||||
let mut cur = Cursor::new(bytes);
|
||||
let header = match Xpr2Header::read(&mut cur) {
|
||||
Ok(h) => h,
|
||||
Err(_) => return out,
|
||||
};
|
||||
let data_base = header.header_size as usize;
|
||||
if data_base >= bytes.len() {
|
||||
return out;
|
||||
}
|
||||
|
||||
// ── Collect every XBG7 resource's parameters up front. ──
|
||||
const DIR_BASE: usize = 0x10;
|
||||
struct Res {
|
||||
name: String,
|
||||
index_count: usize,
|
||||
vtx_count: usize,
|
||||
decl: VertexDecl,
|
||||
}
|
||||
let mut resources: Vec<Res> = Vec::new();
|
||||
for _ in 0..header.num_resources {
|
||||
let e = match Xpr2ResourceEntry::read(&mut cur) {
|
||||
Ok(e) => e,
|
||||
Err(_) => break,
|
||||
};
|
||||
if &e.type_tag != b"XBG7" {
|
||||
continue;
|
||||
}
|
||||
let desc = e.data_offset as usize + DIR_BASE;
|
||||
let desc_end = (desc + e.descriptor_size as usize).min(bytes.len());
|
||||
if desc >= bytes.len() || desc_end <= desc {
|
||||
continue;
|
||||
}
|
||||
let d = &bytes[desc..desc_end];
|
||||
let (mk_rel, index_count) = match find_index_marker(d) {
|
||||
Some(m) => m,
|
||||
None => continue,
|
||||
};
|
||||
let decl = match parse_vertex_decl(d) {
|
||||
Some(v) => v,
|
||||
None => continue,
|
||||
};
|
||||
// Total vertex count is stored 32 bytes before the index marker.
|
||||
if mk_rel < 32 {
|
||||
continue;
|
||||
}
|
||||
let vtx_count = be32(d, mk_rel - 32) as usize;
|
||||
if !(3..=400_000).contains(&vtx_count) || index_count < 3 {
|
||||
continue;
|
||||
}
|
||||
// Anchoring relies on the unit-normal signature; skip resources with
|
||||
// no NORMAL element (too ambiguous to pin safely).
|
||||
if decl.normal_offset.is_none() {
|
||||
continue;
|
||||
}
|
||||
let name = read_cstr(bytes, e.name_offset as usize + DIR_BASE)
|
||||
.unwrap_or_else(|| "XBG7".to_string());
|
||||
resources.push(Res {
|
||||
name,
|
||||
index_count,
|
||||
vtx_count,
|
||||
decl,
|
||||
});
|
||||
}
|
||||
if resources.is_empty() {
|
||||
return out;
|
||||
}
|
||||
|
||||
// ── One O(file) pass per distinct stride: find vertex-block *starts*. ──
|
||||
//
|
||||
// Each geometry block is `[12B header][index buffer][vertex buffer]`, and
|
||||
// the blocks are scattered among texture data with no stored offset. But
|
||||
// a vertex buffer is a run of stride-sized records whose NORMAL (f16×4 at
|
||||
// +12) is unit length; a *block start* is the unique offset where that
|
||||
// run begins — the previous stride slot is NOT a unit-normal vertex (it's
|
||||
// index bytes / header). Collecting those starts turns the per-resource
|
||||
// search from O(file) into a scan of a few hundred candidates.
|
||||
let mut strides: Vec<usize> = resources.iter().map(|r| r.decl.stride).collect();
|
||||
strides.sort_unstable();
|
||||
strides.dedup();
|
||||
let mut starts_by_stride: std::collections::BTreeMap<usize, Vec<usize>> =
|
||||
std::collections::BTreeMap::new();
|
||||
for &s in &strides {
|
||||
starts_by_stride.insert(s, vertex_run_starts(bytes, data_base, s));
|
||||
}
|
||||
|
||||
for r in &resources {
|
||||
let starts = &starts_by_stride[&r.decl.stride];
|
||||
if let Some(mesh) = anchor_pool_mesh(
|
||||
bytes,
|
||||
starts,
|
||||
r.index_count,
|
||||
r.vtx_count,
|
||||
&r.decl,
|
||||
) {
|
||||
out.push(Xbg7Model {
|
||||
name: r.name.clone(),
|
||||
meshes: vec![mesh],
|
||||
});
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
/// Scan the data section for offsets that begin a `stride`-sized unit-normal
|
||||
/// vertex run (NORMAL is `f16×4` at vertex offset +12). A run *start* is an
|
||||
/// offset whose normal is unit while the preceding stride slot's is not — i.e.
|
||||
/// the first vertex of a buffer, not a mid-buffer position. Returns the sorted
|
||||
/// candidate starts (block vertex-buffer offsets).
|
||||
fn vertex_run_starts(bytes: &[u8], data_base: usize, stride: usize) -> Vec<usize> {
|
||||
const NRM: usize = 12; // POSITION f32×3 occupies [0,12); NORMAL f16×4 follows
|
||||
let mut starts = Vec::new();
|
||||
if stride < NRM + 8 {
|
||||
return starts;
|
||||
}
|
||||
let is_unit = |o: usize| -> bool {
|
||||
if o + NRM + 6 > bytes.len() {
|
||||
return false;
|
||||
}
|
||||
let nx = half(bytes, o + NRM);
|
||||
let ny = half(bytes, o + NRM + 2);
|
||||
let nz = half(bytes, o + NRM + 4);
|
||||
let l = (nx * nx + ny * ny + nz * nz).sqrt();
|
||||
(0.85..=1.15).contains(&l)
|
||||
};
|
||||
// Vertex buffers begin on 4-byte boundaries in practice; step 4.
|
||||
let end = bytes.len().saturating_sub(NRM + 6);
|
||||
let mut o = data_base;
|
||||
while o <= end {
|
||||
if is_unit(o) && (o < data_base + stride || !is_unit(o - stride)) {
|
||||
starts.push(o);
|
||||
}
|
||||
o += 4;
|
||||
}
|
||||
starts
|
||||
}
|
||||
|
||||
/// Locate a stage resource's `[index buffer][vertex buffer]` block among the
|
||||
/// precomputed vertex-run `starts` (see [`vertex_run_starts`]) and decode it, or
|
||||
/// return `None` if no candidate validates. A candidate `vb` is accepted when
|
||||
/// the `index_count` indices ending just before it are all `< vtx_count`,
|
||||
/// reference (nearly) all vertices, and produce non-degenerate triangles with a
|
||||
/// real spatial extent — a signature strong enough to pin the block.
|
||||
fn anchor_pool_mesh(
|
||||
bytes: &[u8],
|
||||
starts: &[usize],
|
||||
index_count: usize,
|
||||
vtx_count: usize,
|
||||
decl: &VertexDecl,
|
||||
) -> Option<GameMesh> {
|
||||
let stride = decl.stride;
|
||||
let idx_bytes = index_count * 2;
|
||||
let vtx_bytes = vtx_count.checked_mul(stride)?;
|
||||
|
||||
for &vb in starts {
|
||||
// The index buffer sits immediately before the vertex buffer.
|
||||
if vb < idx_bytes {
|
||||
continue;
|
||||
}
|
||||
let ib = vb - idx_bytes;
|
||||
if vb + vtx_bytes > bytes.len() {
|
||||
continue;
|
||||
}
|
||||
|
||||
// ── Full index validation: every index in range, uses ~all vertices. ──
|
||||
let mut max_idx = 0u32;
|
||||
let mut ok = true;
|
||||
for k in 0..index_count {
|
||||
let i = be16(bytes, ib + k * 2) as u32;
|
||||
if i >= vtx_count as u32 {
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
max_idx = max_idx.max(i);
|
||||
}
|
||||
if !ok || (max_idx as usize) + 4 < vtx_count {
|
||||
continue;
|
||||
}
|
||||
|
||||
// ── Triangle quality: finite, non-degenerate, real spatial extent. ──
|
||||
let pos = decl.pos_offset;
|
||||
let mut lo = [f32::MAX; 3];
|
||||
let mut hi = [f32::MIN; 3];
|
||||
let mut degenerate = 0usize;
|
||||
let mut sampled = 0usize;
|
||||
let mut edge_sum = 0.0f32;
|
||||
let tris = index_count / 3;
|
||||
let tstep = (tris / 96).max(1);
|
||||
let mut t = 0;
|
||||
let mut bad = false;
|
||||
while t < tris {
|
||||
let mut p = [[0.0f32; 3]; 3];
|
||||
for (c, pc) in p.iter_mut().enumerate() {
|
||||
let vi = be16(bytes, ib + (3 * t + c) * 2) as usize;
|
||||
let base = vb + vi * stride + pos;
|
||||
for (a, slot) in pc.iter_mut().enumerate() {
|
||||
let x = bef(bytes, base + a * 4);
|
||||
if !x.is_finite() || x.abs() > 1.0e6 {
|
||||
bad = true;
|
||||
break;
|
||||
}
|
||||
*slot = x;
|
||||
lo[a] = lo[a].min(x);
|
||||
hi[a] = hi[a].max(x);
|
||||
}
|
||||
if bad {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if bad {
|
||||
break;
|
||||
}
|
||||
let u = [p[1][0] - p[0][0], p[1][1] - p[0][1], p[1][2] - p[0][2]];
|
||||
let w = [p[2][0] - p[0][0], p[2][1] - p[0][1], p[2][2] - p[0][2]];
|
||||
let cx = [
|
||||
u[1] * w[2] - u[2] * w[1],
|
||||
u[2] * w[0] - u[0] * w[2],
|
||||
u[0] * w[1] - u[1] * w[0],
|
||||
];
|
||||
if 0.5 * (cx[0] * cx[0] + cx[1] * cx[1] + cx[2] * cx[2]).sqrt() < 1.0e-9 {
|
||||
degenerate += 1;
|
||||
}
|
||||
// Sum the triangle's three edge lengths (for the connectivity check).
|
||||
let e3 = [p[2][0] - p[1][0], p[2][1] - p[1][1], p[2][2] - p[1][2]];
|
||||
edge_sum += (u[0] * u[0] + u[1] * u[1] + u[2] * u[2]).sqrt()
|
||||
+ (w[0] * w[0] + w[1] * w[1] + w[2] * w[2]).sqrt()
|
||||
+ (e3[0] * e3[0] + e3[1] * e3[1] + e3[2] * e3[2]).sqrt();
|
||||
sampled += 1;
|
||||
t += tstep;
|
||||
}
|
||||
if bad {
|
||||
continue;
|
||||
}
|
||||
let extent = (hi[0] - lo[0]).max(hi[1] - lo[1]).max(hi[2] - lo[2]);
|
||||
if extent < 0.5 || sampled == 0 || degenerate * 10 > sampled * 3 {
|
||||
continue; // too flat, or >30% degenerate → not this block
|
||||
}
|
||||
// Connectivity check: a correctly-anchored mesh has triangle edges that
|
||||
// are SMALL relative to its overall size (~0.05–0.15 of the bbox
|
||||
// diagonal). A wrong anchor / cross-wired index buffer connects distant
|
||||
// vertices, so its mean edge spans a large fraction of the model (a spiky
|
||||
// mess). Reject those — try another candidate or decline.
|
||||
let diag = ((hi[0] - lo[0]).powi(2) + (hi[1] - lo[1]).powi(2) + (hi[2] - lo[2]).powi(2))
|
||||
.sqrt()
|
||||
.max(1e-6);
|
||||
let mean_edge = edge_sum / (sampled as f32 * 3.0);
|
||||
if mean_edge / diag > 0.28 {
|
||||
continue;
|
||||
}
|
||||
|
||||
// ── Accepted: read the full mesh. ──
|
||||
return Some(read_pool_mesh(bytes, ib, vb, index_count, vtx_count, decl));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Read positions / normals / uvs / indices for an anchored stage block.
|
||||
fn read_pool_mesh(
|
||||
bytes: &[u8],
|
||||
ib: usize,
|
||||
vb: usize,
|
||||
index_count: usize,
|
||||
vtx_count: usize,
|
||||
decl: &VertexDecl,
|
||||
) -> GameMesh {
|
||||
let stride = decl.stride;
|
||||
let indices: Vec<u32> = (0..index_count)
|
||||
.map(|k| be16(bytes, ib + k * 2) as u32)
|
||||
.collect();
|
||||
|
||||
let mut positions = Vec::with_capacity(vtx_count);
|
||||
let mut normals = Vec::with_capacity(vtx_count);
|
||||
let mut uvs = Vec::with_capacity(vtx_count);
|
||||
for v in 0..vtx_count {
|
||||
let o = vb + v * stride;
|
||||
let p = o + decl.pos_offset;
|
||||
positions.push([bef(bytes, p), bef(bytes, p + 4), bef(bytes, p + 8)]);
|
||||
if let Some(no) = decl.normal_offset {
|
||||
let nb = o + no;
|
||||
normals.push([half(bytes, nb), half(bytes, nb + 2), half(bytes, nb + 4)]);
|
||||
}
|
||||
if let Some(uo) = decl.uv_offset {
|
||||
let ub = o + uo;
|
||||
uvs.push([half(bytes, ub), half(bytes, ub + 2)]);
|
||||
}
|
||||
}
|
||||
GameMesh {
|
||||
positions,
|
||||
normals,
|
||||
uvs,
|
||||
indices,
|
||||
name: None,
|
||||
}
|
||||
}
|
||||
|
||||
// ── Layout constants ────────────────────────────────────────────────────────
|
||||
|
||||
/// Fixed byte gap between the end of a sub-mesh's index buffer and the start of
|
||||
/// its vertex buffer (a small vertex-buffer header — contents not yet decoded).
|
||||
/// Size of the header that precedes each sub-mesh block's index buffer
|
||||
/// (`[12-byte header][index buffer][vertex buffer]`). Contents not yet decoded.
|
||||
const VERTEX_BUFFER_GAP: usize = 12;
|
||||
|
||||
// ── Vertex declaration ───────────────────────────────────────────────────────
|
||||
@@ -272,20 +598,24 @@ fn decl_code_size(code: u32) -> Option<usize> {
|
||||
/// `code == 0xFFFFFFFF` sentinel. Usage codes: `0` POSITION, `3` NORMAL,
|
||||
/// `5` TEXCOORD. Stride is the max element extent; unknown element sizes are
|
||||
/// inferred from the next element's offset.
|
||||
fn parse_vertex_decl(desc: &[u8]) -> Option<VertexDecl> {
|
||||
// Locate the (index_bytes, index_count) marker: index_bytes == count*2.
|
||||
let mut mk = None;
|
||||
/// Locate the `(index_bytes, index_count)` marker in a descriptor: the first
|
||||
/// big-endian pair where `index_bytes == index_count * 2` and `index_count` is a
|
||||
/// positive multiple of 3. Returns `(rel_offset, index_count)`.
|
||||
fn find_index_marker(desc: &[u8]) -> Option<(usize, usize)> {
|
||||
let mut rel = 0usize;
|
||||
while rel + 40 <= desc.len() {
|
||||
let a = be32(desc, rel);
|
||||
let c = be32(desc, rel + 4);
|
||||
if c >= 3 && c % 3 == 0 && c < 200_000 && a == c * 2 {
|
||||
mk = Some(rel);
|
||||
break;
|
||||
if c >= 3 && c % 3 == 0 && c < 400_000 && a == c * 2 {
|
||||
return Some((rel, c as usize));
|
||||
}
|
||||
rel += 4;
|
||||
}
|
||||
let mk = mk?;
|
||||
None
|
||||
}
|
||||
|
||||
fn parse_vertex_decl(desc: &[u8]) -> Option<VertexDecl> {
|
||||
let mk = find_index_marker(desc)?.0;
|
||||
|
||||
// Read declaration triples.
|
||||
let mut elems: Vec<(usize, u32, u32)> = Vec::new(); // (offset, code, usage)
|
||||
|
||||
@@ -121,3 +121,114 @@ fn complex_body_mesh_is_declined_not_garbage() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Stage containers decode multiple enemy/prop sub-models via content anchoring.
|
||||
/// Prints coverage; asserts the known-good Stage_S10 meshes decode with sane geometry.
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn stage_models_decode() {
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
let dir = std::env::var("SYLPHEED_RES3D").unwrap_or_else(|_| {
|
||||
"/home/fabi/RE Project Sylpheed/sylph_extract/hidden/resource3d".to_string()
|
||||
});
|
||||
let path = format!("{dir}/Stage_S10.xpr");
|
||||
let bytes = std::fs::read(&path).expect("read Stage_S10");
|
||||
let models = Xbg7Model::stage_models(&bytes);
|
||||
for m in &models {
|
||||
let (v, t) = m.totals();
|
||||
let mut lo = [f32::MAX; 3];
|
||||
let mut hi = [f32::MIN; 3];
|
||||
for sub in &m.meshes {
|
||||
for p in &sub.positions {
|
||||
for a in 0..3 {
|
||||
lo[a] = lo[a].min(p[a]);
|
||||
hi[a] = hi[a].max(p[a]);
|
||||
}
|
||||
}
|
||||
}
|
||||
let ext = [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]];
|
||||
println!(
|
||||
" {:16} v={v} t={t} bbox=[{:.1},{:.1},{:.1}]",
|
||||
m.name, ext[0], ext[1], ext[2]
|
||||
);
|
||||
}
|
||||
// Known: e003 (main enemy, ~1400 tris) must be among the decoded models.
|
||||
let e003 = models.iter().find(|m| m.name == "e003").expect("e003 decoded");
|
||||
let (v, t) = e003.totals();
|
||||
assert_eq!(v, 2383, "e003 vertex count");
|
||||
assert!(t > 1400, "e003 triangle count {t}");
|
||||
assert!(models.len() >= 3, "at least 3 stage sub-models, got {}", models.len());
|
||||
}
|
||||
|
||||
/// Timing/coverage sweep across all stage containers (manual; release recommended).
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn stage_models_sweep() {
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use std::time::Instant;
|
||||
let dir = std::env::var("SYLPHEED_RES3D").unwrap_or_else(|_| {
|
||||
"/home/fabi/RE Project Sylpheed/sylph_extract/hidden/resource3d".to_string()
|
||||
});
|
||||
let mut names: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok().map(|e| e.file_name().into_string().unwrap()))
|
||||
.filter(|n| n.starts_with("Stage_") && n.ends_with(".xpr"))
|
||||
.collect();
|
||||
names.sort();
|
||||
let mut tot = 0usize;
|
||||
for n in &names {
|
||||
let bytes = std::fs::read(format!("{dir}/{n}")).unwrap();
|
||||
let t0 = Instant::now();
|
||||
let models = Xbg7Model::stage_models(&bytes);
|
||||
let dt = t0.elapsed().as_millis();
|
||||
tot += models.len();
|
||||
println!("{n:16} {:>4} MB {:>3} models {:>5} ms", bytes.len()/1_000_000, models.len(), dt);
|
||||
}
|
||||
println!("TOTAL stage sub-models decoded: {tot}");
|
||||
}
|
||||
|
||||
/// Quality audit: for a big stage, verify decoded models are real geometry
|
||||
/// (bounded bbox, low full-mesh degeneracy) rather than false anchors.
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn stage_models_quality_audit() {
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
let dir = std::env::var("SYLPHEED_RES3D").unwrap_or_else(|_| {
|
||||
"/home/fabi/RE Project Sylpheed/sylph_extract/hidden/resource3d".to_string()
|
||||
});
|
||||
let bytes = std::fs::read(format!("{dir}/Stage_S07.xpr")).unwrap();
|
||||
let models = Xbg7Model::stage_models(&bytes);
|
||||
let (mut small, mut mid, mut huge, mut dupnames) = (0, 0, 0, 0);
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
let mut worst_deg = 0.0f32;
|
||||
for m in &models {
|
||||
if !seen.insert(m.name.clone()) { dupnames += 1; }
|
||||
let mut lo = [f32::MAX; 3]; let mut hi = [f32::MIN; 3];
|
||||
let mut deg = 0usize; let mut tot = 0usize;
|
||||
for sub in &m.meshes {
|
||||
for p in &sub.positions { for a in 0..3 { lo[a]=lo[a].min(p[a]); hi[a]=hi[a].max(p[a]); } }
|
||||
for tri in sub.indices.chunks_exact(3) {
|
||||
let (a,b,c)=(tri[0] as usize,tri[1] as usize,tri[2] as usize);
|
||||
if a>=sub.positions.len()||b>=sub.positions.len()||c>=sub.positions.len(){continue;}
|
||||
let pa=sub.positions[a]; let pb=sub.positions[b]; let pc=sub.positions[c];
|
||||
let u=[pb[0]-pa[0],pb[1]-pa[1],pb[2]-pa[2]];
|
||||
let v=[pc[0]-pa[0],pc[1]-pa[1],pc[2]-pa[2]];
|
||||
let cx=[u[1]*v[2]-u[2]*v[1],u[2]*v[0]-u[0]*v[2],u[0]*v[1]-u[1]*v[0]];
|
||||
if 0.5*(cx[0]*cx[0]+cx[1]*cx[1]+cx[2]*cx[2]).sqrt()<1e-9 { deg+=1; }
|
||||
tot+=1;
|
||||
}
|
||||
}
|
||||
let ext = (hi[0]-lo[0]).max(hi[1]-lo[1]).max(hi[2]-lo[2]);
|
||||
let df = if tot>0 { deg as f32/tot as f32 } else {1.0};
|
||||
worst_deg = worst_deg.max(df);
|
||||
if ext < 200.0 { small += 1; } else if ext < 5000.0 { mid += 1; } else { huge += 1; }
|
||||
}
|
||||
println!("S07: {} models | small(<200u)={} mid={} huge(>5k)={} | dup-names={} | worst full-mesh degeneracy={:.1}%",
|
||||
models.len(), small, mid, huge, dupnames, worst_deg*100.0);
|
||||
// Each XBG7 resource must anchor to a *distinct* block (no collisions), the
|
||||
// bulk must be bounded-scale geometry, and none may be mostly-degenerate.
|
||||
assert_eq!(dupnames, 0, "no two resources should anchor to the same block");
|
||||
assert!(small + mid > models.len() * 9 / 10, "≥90% bounded-scale geometry");
|
||||
assert!(huge < models.len() / 20, "few huge (skybox-plane) models");
|
||||
assert!(worst_deg < 0.35, "no model should be mostly-degenerate");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user