Fabian Hamm
ed54f95d54
`cargo fmt --all -- --check` has failed on every run in this repository's history, identically on `main` and on every branch. This is #12. Mechanical: `cargo fmt --all`, nothing else. 154 files, all `.rs`, no other extension touched. `cargo check --workspace` exits 0 afterwards, so nothing changed semantically. ON THE ORDERING, WHICH WAS THE REAL QUESTION. HANDOFF-2026-09-06 section 7 warns this is the expensive fix: a whole-tree reformat before #7 and #8 return "would put a conflict in every file of 861 commits and make the reviews those items exist to enable unreadable". That is measurably too pessimistic, and it had been reasoned rather than tested. Measured here by three-way merging a rustfmt'd `main` against both unmerged branches, file by file: file/branch pairs tested 32 merges CLEAN 28 merges CONFLICTING 4 (8 conflict hunks total) sylpheed-cli/src/main.rs 1 hunk sylpheed-export/src/check.rs 1 sylpheed-export/src/screen.rs 4 sylpheed-export/src/video.rs 2 All four are against `auto/frame-blend-draw-path` only; `auto/port-p6-audio` does not conflict anywhere. The earlier framing -- 154 dirty files, 133 that cannot collide, 21 that can, the collision set carrying 147 of 774 hunks (19%) -- reproduces exactly. What it did not say is that most of the 21 still merge cleanly, because rustfmt's edits and the branches' edits rarely land on the same lines. So the cost of sweeping now is 4 files and 8 hunks for one branch, against a check that is otherwise red forever. Deliberately NOT folded into the WASM PR: 154 reformatted files would make that one unreviewable. Closes #12
252 lines
10 KiB
Rust
252 lines
10 KiB
Rust
//! Where does a drawn block's INDEX buffer really live?
|
||
//!
|
||
//! Our XBG7 anchor scan only ever *assumes* the layout `[index buffer][vertex
|
||
//! buffer]` with a pad of at most 3 bytes between them (`anchor_pool_mesh`:
|
||
//! `ib = vb - idx_count*2 - pad`). Nothing on disc states it, and it is the gate
|
||
//! that rejected the capture-proven `e106_eng_02_l` block
|
||
//! (docs/re/captures/…): the block's index data was not where the decoder
|
||
//! looked. The F10 ship capture was extended on 2026-08-13 to log each draw's
|
||
//! index-buffer base, count and min/max index value, so the assumption is now
|
||
//! directly checkable:
|
||
//!
|
||
//! * `vbase - ibase` is the real gap in guest memory, and a stage container is
|
||
//! uploaded contiguously (see `shared_vbase_check`), so the same difference
|
||
//! holds in the file;
|
||
//! * `max index vs vcount` says whether a draw covers its whole vertex pool —
|
||
//! the "buffer not covered" miss class is a *sub-range draw* if it does not.
|
||
//!
|
||
//! Usage:
|
||
//! cargo run --release --example capture_ib_truth -- <Stage_SNN.xpr> <capture.log>...
|
||
use std::collections::HashMap;
|
||
use sylpheed_formats::mesh::{debug_resource_params, xbg7_resource_names, Xbg7Model};
|
||
use sylpheed_formats::ship_capture::{parse_capture, CapturedDraw};
|
||
|
||
fn q(v: f32) -> i64 {
|
||
(v as f64 * 1e4).round() as i64
|
||
}
|
||
|
||
fn main() {
|
||
let a: Vec<String> = std::env::args().collect();
|
||
if a.len() < 3 {
|
||
eprintln!("usage: capture_ib_truth <container.xpr> <capture.log>...");
|
||
std::process::exit(2);
|
||
}
|
||
let bytes = std::fs::read(&a[1]).expect("container");
|
||
|
||
// One entry per (log, vbase): the capture already de-dups per placement, and
|
||
// a buffer drawn at several transforms has the same index buffer each time.
|
||
let mut draws: Vec<CapturedDraw> = Vec::new();
|
||
let mut seen = std::collections::HashSet::new();
|
||
for log in &a[2..] {
|
||
let text = std::fs::read_to_string(log).expect("log");
|
||
for d in parse_capture(&text) {
|
||
// One entry per (log, vbase, index range): the engine issues SEVERAL
|
||
// draws over one vertex buffer, each with its own index sub-range, and
|
||
// it is their UNION that describes the block. (Captures taken before
|
||
// 2026-08-13 de-dup by (vbase, transform) and so hold only the first
|
||
// batch — such a log reads as a mysteriously short draw.)
|
||
let k = d.ib.map(|i| (i.ibase, i.icount)).unwrap_or((0, 0));
|
||
if d.ib.is_some() && d.pos.len() >= 4 && seen.insert((log.clone(), d.vbase, k)) {
|
||
draws.push(d);
|
||
}
|
||
}
|
||
}
|
||
eprintln!("{} drawn buffers with an index buffer", draws.len());
|
||
|
||
// ── Place the drawn buffers in the file: POSITION is f32×3 big-endian at
|
||
// vertex offset 0, so the dumped positions are a literal byte pattern.
|
||
let be = |at: usize| f32::from_be_bytes(bytes[at..at + 4].try_into().unwrap());
|
||
let mut index: HashMap<(i64, i64, i64), Vec<u32>> = HashMap::new();
|
||
let mut o = 0usize;
|
||
while o + 12 <= bytes.len() {
|
||
let (x, y, z) = (be(o), be(o + 4), be(o + 8));
|
||
if x.is_finite()
|
||
&& y.is_finite()
|
||
&& z.is_finite()
|
||
&& x.abs() < 1e6
|
||
&& y.abs() < 1e6
|
||
&& z.abs() < 1e6
|
||
{
|
||
index.entry((q(x), q(y), q(z))).or_default().push(o as u32);
|
||
}
|
||
o += 4;
|
||
}
|
||
let mut deltas: HashMap<i64, usize> = HashMap::new();
|
||
let mut hits: Vec<(i64, usize, &CapturedDraw)> = Vec::new(); // (delta, file offset, draw)
|
||
for d in &draws {
|
||
let k = (q(d.pos[0][0]), q(d.pos[0][1]), q(d.pos[0][2]));
|
||
for dx in -1..=1i64 {
|
||
for dy in -1..=1i64 {
|
||
for dz in -1..=1i64 {
|
||
let Some(cands) = index.get(&(k.0 + dx, k.1 + dy, k.2 + dz)) else {
|
||
continue;
|
||
};
|
||
for &off in cands {
|
||
for stride in (12..=64).step_by(4) {
|
||
let ok = (1..4).all(|j| {
|
||
let at = off as usize + j * stride;
|
||
at + 12 <= bytes.len()
|
||
&& (0..3).all(|c| (be(at + c * 4) - d.pos[j][c]).abs() <= 1e-4)
|
||
});
|
||
if ok {
|
||
let delta = d.vbase as i64 - off as i64;
|
||
*deltas.entry(delta).or_default() += 1;
|
||
hits.push((delta, off as usize, d));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let Some((&base_delta, &n)) = deltas.iter().max_by_key(|(_, n)| **n) else {
|
||
eprintln!("no draw could be placed in this container");
|
||
std::process::exit(1);
|
||
};
|
||
println!(
|
||
"container load constant: vbase - file_offset = 0x{base_delta:X} ({n} buffers agree)"
|
||
);
|
||
|
||
// ── Our decoder's view of the same container.
|
||
let models = Xbg7Model::stage_models(&bytes);
|
||
let mut by_off: HashMap<usize, Vec<(String, usize, usize)>> = HashMap::new();
|
||
for m in &models {
|
||
for sm in &m.meshes {
|
||
if let Some(off) = sm.vbuf_offset {
|
||
by_off.entry(off).or_default().push((
|
||
m.name.clone(),
|
||
sm.positions.len(),
|
||
sm.indices.len(),
|
||
));
|
||
}
|
||
}
|
||
}
|
||
println!(
|
||
"decoded {} resources, {} distinct vertex offsets\n",
|
||
models.len(),
|
||
by_off.len()
|
||
);
|
||
|
||
// Declared-but-not-decoded resources, indexed by their first marker's
|
||
// (vertex, index) counts. A drawn buffer our decoder cannot name is the one
|
||
// thing a capture can give the residual misses: ground truth for where the
|
||
// block actually is. Matching on counts is enough to propose an identity —
|
||
// then `debug_try_anchor` at that offset says which gate rejects it.
|
||
let decoded_names: std::collections::HashSet<String> =
|
||
models.iter().map(|m| m.name.clone()).collect();
|
||
let mut undecoded_by_counts: HashMap<(usize, usize), Vec<String>> = HashMap::new();
|
||
for n in xbg7_resource_names(&bytes) {
|
||
if decoded_names.contains(&n) {
|
||
continue;
|
||
}
|
||
if let Some((markers, _)) = debug_resource_params(&bytes, &n) {
|
||
if let Some(&(v, i)) = markers.first() {
|
||
undecoded_by_counts.entry((v, i)).or_default().push(n);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ── The report: one row per drawn BUFFER, aggregating its index batches.
|
||
let mut per_buf: HashMap<
|
||
u32,
|
||
(
|
||
usize,
|
||
Vec<sylpheed_formats::ship_capture::CapturedIndexBuffer>,
|
||
u32,
|
||
),
|
||
> = HashMap::new();
|
||
for (delta, voff, d) in &hits {
|
||
if *delta != base_delta {
|
||
continue;
|
||
}
|
||
let e = per_buf
|
||
.entry(d.vbase)
|
||
.or_insert((*voff, Vec::new(), d.vcount));
|
||
let ib = d.ib.unwrap();
|
||
if !e.1.contains(&ib) {
|
||
e.1.push(ib);
|
||
}
|
||
}
|
||
|
||
let (mut pad0, mut pad_small, mut pad_off, mut unnamed) = (0usize, 0usize, 0usize, 0usize);
|
||
let (mut cover_exact, mut cover_short, mut idx_equal, mut idx_partial) =
|
||
(0usize, 0usize, 0usize, 0usize);
|
||
let mut rows: Vec<(usize, String)> = Vec::new();
|
||
for (_, (voff, ibs, vcount)) in per_buf.iter() {
|
||
let batches = ibs.len();
|
||
let total: u32 = ibs.iter().map(|i| i.icount).sum();
|
||
let lo = ibs.iter().map(|i| i.ibase).min().unwrap() as i64 - base_delta;
|
||
let hi = ibs.iter().map(|i| i.ibase + i.icount * 2).max().unwrap() as i64 - base_delta;
|
||
let umax = ibs.iter().map(|i| i.imax).max().unwrap();
|
||
let gap = *voff as i64 - hi; // bytes from the end of the index data to the vertex buffer
|
||
let names = by_off.get(voff);
|
||
let dec_idx = names.and_then(|v| {
|
||
v.iter()
|
||
.find(|(_, p, _)| *p as u32 == *vcount)
|
||
.map(|(_, _, i)| *i as u32)
|
||
});
|
||
// The decoder's assumption, scored: it expects the whole index buffer at
|
||
// `vb - 2*idx_count - pad`, pad ≤ 3.
|
||
let dec_pad = dec_idx.map(|i| *voff as i64 - (i as i64) * 2 - lo);
|
||
match dec_pad {
|
||
Some(0) => pad0 += 1,
|
||
Some(p) if (1..=3).contains(&p) => pad_small += 1,
|
||
Some(_) => pad_off += 1,
|
||
None => unnamed += 1,
|
||
}
|
||
if umax + 1 == *vcount {
|
||
cover_exact += 1;
|
||
} else {
|
||
cover_short += 1;
|
||
}
|
||
match dec_idx {
|
||
Some(i) if i == total => idx_equal += 1,
|
||
Some(_) => idx_partial += 1,
|
||
None => {}
|
||
}
|
||
rows.push((
|
||
*voff,
|
||
format!(
|
||
"vb 0x{:07X} v={:<6} batches {:<3} idx {:<6} span {:<7} gap {:<8} decpad {:<7} cover {:<10} {}",
|
||
voff,
|
||
vcount,
|
||
batches,
|
||
total,
|
||
hi - lo,
|
||
gap,
|
||
dec_pad.map(|p| p.to_string()).unwrap_or_else(|| "?".into()),
|
||
if umax + 1 == *vcount { "exact".to_string() } else { format!("{}/{}", umax, vcount - 1) },
|
||
names
|
||
.map(|v| v
|
||
.iter()
|
||
.map(|(n, p, i)| format!("{n}(v{p},i{i})"))
|
||
.collect::<Vec<_>>()
|
||
.join(" "))
|
||
.unwrap_or_else(|| {
|
||
// Nothing of ours sits here — is it a resource that never
|
||
// decodes? Propose it by (vertex, index) counts.
|
||
undecoded_by_counts
|
||
.get(&(*vcount as usize, total as usize))
|
||
.map(|v| format!("MISSED? {}", v.join(" ")))
|
||
.unwrap_or_else(|| "-".into())
|
||
})
|
||
),
|
||
));
|
||
}
|
||
rows.sort();
|
||
for (_, r) in &rows {
|
||
println!("{r}");
|
||
}
|
||
println!("\nplaced {} drawn buffers in this container", rows.len());
|
||
println!(
|
||
"DECODER layout assumption — whole index buffer at vb - 2*idx_count - pad: pad 0 {pad0} · pad 1..3 {pad_small} · elsewhere {pad_off} · not decoded here {unnamed}"
|
||
);
|
||
println!(
|
||
"index extent: our idx_count == sum of captured batches for {idx_equal} buffers, differs for {idx_partial}"
|
||
);
|
||
println!(
|
||
"vertex-pool coverage by the union of batches: exact {cover_exact} · short {cover_short}"
|
||
);
|
||
}
|