Compare commits
2 Commits
auto/re-sa
...
feat/ui-la
| Author | SHA1 | Date | |
|---|---|---|---|
| 9bc8c2d694 | |||
| c1da907135 |
1
.gitignore
vendored
1
.gitignore
vendored
@@ -20,4 +20,3 @@ Thumbs.db
|
||||
|
||||
# Trunk build output
|
||||
dist/
|
||||
__pycache__/
|
||||
|
||||
@@ -12,12 +12,7 @@
|
||||
|
||||
ship e106 ref=e106_bdy_04
|
||||
e106_bdy_01 1 0 0 0 1 0 0 0 1 -263.9948 -150.43242 1164.8667
|
||||
# 2026-08-12: this rotation was diag(-1,1,1) - the X-flip `correlate` bakes in
|
||||
# when a draw's buffer is the mirror of the decoded one. With distinct anchor
|
||||
# assignment the twins now decode to their OWN buffers (the container carries
|
||||
# both halves), so the mirror lives in the data and the placement is plain
|
||||
# identity. Re-emitting from the capture agrees: `1 0 0 0 1 0 0 0 1 264.04343`.
|
||||
e106_bdy_02 1 0 0 0 1 0 0 0 1 264.0088 -150.41339 1164.8651
|
||||
e106_bdy_02 -1 0 0 0 1 0 0 0 1 264.0088 -150.41339 1164.8651
|
||||
e106_bdy_03 1 0 0 0 1 0 0 0 1 0.0029247368 -34.517372 1075.878
|
||||
e106_bdy_04 1 0 0 0 1 0 0 0 1 0 0 0
|
||||
e106_brg_01 1 0 0 0 1 0 0 0 1 -0.005471501 153.31795 -164.03748
|
||||
|
||||
@@ -1,177 +0,0 @@
|
||||
# Unit / vessel definition object layout — offset, field, kind.
|
||||
#
|
||||
# Read out of the title's own loader, not inferred: `sub_82341A20` builds every
|
||||
# key as `addi r4, r30, -N` with `r30 = 0x82088f94`, so the field NAME for each
|
||||
# store is a string in the executable image; pairing each key with the first
|
||||
# store after its accessor call gives the offset. The accessor for floats is
|
||||
# `sub_822FC5A8`, which returns 0.0 when the pool has no value for the key.
|
||||
#
|
||||
# Verified against live objects dumped from a running Stage 02: 406 field values
|
||||
# agree with the disc records and 0 disagree, over 11 objects spanning both the
|
||||
# UNIT and VESSEL schemas (see docs/re/live-unit-definitions.md).
|
||||
#
|
||||
# Two conventions matter for a reimplementation:
|
||||
# * angle fields are DEGREES on disc and RADIANS in this object;
|
||||
# * a field the disc record omits is left at the accessor's miss value (0.0 for
|
||||
# floats) unless something later derives it — `Size_Y` takes `Size_X`.
|
||||
#
|
||||
# offset kind field
|
||||
24 str Model
|
||||
28 str CollisionModel
|
||||
48 f32 Size_X
|
||||
52 f32 Size_Y
|
||||
56 f32 Size_Z
|
||||
64 f32 Color_R
|
||||
68 f32 Color_G
|
||||
72 f32 Color_B
|
||||
80 f32 Size_Radius
|
||||
84 f32 HP
|
||||
88 f32 HQRatio
|
||||
92 f32 ShieldRatio
|
||||
96 f32 ThrusterRatio
|
||||
100 word IsDestructible
|
||||
104 str NamePlate
|
||||
112 word MountedShieldGenerator
|
||||
116 f32 ResistanceToOptics
|
||||
120 f32 ResistanceToShell
|
||||
124 f32 ResistanceToExplosion
|
||||
128 f32 ResistanceToPlayer
|
||||
132 f32 ResistanceParalyze
|
||||
136 str HUDMarkerID
|
||||
156 f32 MinimumVelocity
|
||||
160 f32 MaximumVelocity
|
||||
164 f32 CruisingVelocity
|
||||
168 f32 Acceleration
|
||||
172 f32 Deceleration
|
||||
176 f32 AV_PitchPlus_Max
|
||||
180 f32 AV_PitchPlus_Min
|
||||
184 f32 AA_PitchPlus_Max
|
||||
188 f32 AA_PitchPlus_Min
|
||||
192 f32 AV_PitchMinus_Max
|
||||
196 f32 AV_PitchMinus_Min
|
||||
200 f32 AA_PitchMinus_Max
|
||||
204 f32 AA_PitchMinus_Min
|
||||
208 f32 AV_Yaw_Max
|
||||
212 f32 AV_Yaw_Min
|
||||
216 f32 AA_Yaw_Max
|
||||
220 f32 AA_Yaw_Min
|
||||
224 f32 AV_Roll_Max
|
||||
228 f32 AV_Roll_Min
|
||||
232 f32 AA_Roll_Max
|
||||
236 f32 AA_Roll_Min
|
||||
248 f32 SideThrustVelocity_Max
|
||||
252 f32 SideThrustAcceleration
|
||||
256 f32 MaximumBank_Normal
|
||||
260 f32 YawDragFactor
|
||||
264 f32 PitchDragFactor
|
||||
268 f32 RollDragFactor
|
||||
272 f32 DragFactorThreshold
|
||||
276 f32 ArterBurner_Vc
|
||||
280 f32 ReverseThrust_Vc
|
||||
284 f32 ArterBurner_Acc
|
||||
288 f32 ReverseThrust_Acc
|
||||
292 f32 AccPitchFactor
|
||||
296 f32 DecPitchFactor
|
||||
300 f32 AV_AxisMode_Max
|
||||
304 f32 AV_AxisMode_Min
|
||||
308 f32 AA_AxisMode_Max
|
||||
312 f32 AA_AxisMode_Min
|
||||
316 f32 PowerCutConsumeShield
|
||||
320 f32 PowerCutDeceleration
|
||||
324 f32 AB_ConsumeShield_Begin
|
||||
328 f32 AB_ConsumeShield
|
||||
332 f32 AB_AV_PitchPlus
|
||||
336 f32 AB_AA_PitchPlus
|
||||
340 f32 AB_AV_PitchMinus
|
||||
344 f32 AB_AA_PitchMinus
|
||||
348 f32 AB_AV_Yaw
|
||||
352 f32 AB_AA_Yaw
|
||||
356 f32 AB_AV_Roll
|
||||
360 f32 AB_AA_Roll
|
||||
364 word SideRoll
|
||||
368 f32 SideRoll_Time
|
||||
372 f32 SideRoll_Length
|
||||
376 word BarrelRoll
|
||||
380 f32 BarrelRoll_CountMinimum
|
||||
384 f32 BarrelRoll_CountMaximum
|
||||
388 f32 BarrelRoll_Time
|
||||
392 f32 BarrelRoll_Radius
|
||||
396 word TurnAttack
|
||||
400 f32 TurnAttack_CutoffRatio
|
||||
404 f32 TurnAttack_DoubleRatio
|
||||
408 f32 CutoffTimeMin
|
||||
412 f32 CutoffTimeMax
|
||||
416 f32 TurnAttack_DoubleTimeMin
|
||||
420 f32 TurnAttack_DoubleTimeMax
|
||||
424 word TurnAway
|
||||
428 f32 Turn_AngularVelocity
|
||||
432 f32 TurnAway_Time_Minimum
|
||||
436 f32 TurnAway_Time_Maximum
|
||||
440 word BoostAway
|
||||
444 f32 BoostAway_Time_Minimum
|
||||
448 f32 BoostAway_Time_Maximum
|
||||
452 word HoldPosition
|
||||
456 f32 HoldPosition_LengthMin
|
||||
460 f32 HoldPosition_LengthMax
|
||||
464 f32 HoldPosition_MinimumTime
|
||||
468 f32 HoldPosition_MaximumTime
|
||||
472 f32 HoldPosition_SideRatio
|
||||
476 f32 HoldPosition_BackRatio
|
||||
480 f32 HoldPosition_CutoffRatio
|
||||
484 f32 HoldPosition_CancelTime
|
||||
488 word Slalom
|
||||
492 f32 Slalom_CutoffRatio
|
||||
496 f32 Slalom_TurnCount_Min
|
||||
500 f32 Slalom_TurnCount_Max
|
||||
504 word Through
|
||||
508 f32 Through_CutoffRatio
|
||||
512 f32 Through_AngleMinimum
|
||||
516 f32 Through_AngleMaximum
|
||||
520 f32 Through_Time1Max
|
||||
524 f32 Through_Time1Min
|
||||
528 f32 Through_Time2Max
|
||||
532 f32 Through_Time2Min
|
||||
536 f32 Through_LengthMinimum
|
||||
540 f32 Through_LengthMaximum
|
||||
544 word SolidCutoff
|
||||
548 f32 SolidCutoff_Ratio
|
||||
552 f32 SolidCutoff_LengthMin
|
||||
556 f32 SolidCutoff_LengthMax
|
||||
560 f32 HomingResistAdjustment
|
||||
564 f32 UsingChaffRatio
|
||||
568 f32 MaxValue
|
||||
572 f32 ChargeDelay
|
||||
576 f32 ChargeDelay_Break
|
||||
580 f32 ChargeSpeed
|
||||
584 f32 Delay
|
||||
588 f32 DelayAdjustment
|
||||
596 str LowerHPFxModel
|
||||
604 str ExplosionFxModel
|
||||
612 str DestroyMotionName
|
||||
620 str ExplosionMotionName
|
||||
624 f32 DestroyMotionTime
|
||||
628 f32 DryMass
|
||||
632 f32 GrossMass
|
||||
636 word Thruster
|
||||
640 word SideThruster
|
||||
644 word ExplosionSE
|
||||
648 word JumpIn
|
||||
652 word JumpOut
|
||||
656 word ShipEnvironmentSE
|
||||
660 word LowerHPSE
|
||||
664 f32 LowerHPThresholdRatio
|
||||
668 f32 SELength
|
||||
672 f32 RadarRange
|
||||
676 f32 FCSRange
|
||||
680 f32 FiringRange
|
||||
684 word MountedFCS
|
||||
692 f32 AttackVesselPoint
|
||||
696 f32 AttackCraftPoint
|
||||
700 f32 DefencePoint
|
||||
736 str ShieldRecoverEffectName
|
||||
740 str ShieldHitEffectName
|
||||
744 str JumpIn
|
||||
748 str JumpOut
|
||||
752 str FadeIn
|
||||
756 str FadeOut
|
||||
760 str Effect_Paralyze
|
||||
@@ -1,22 +0,0 @@
|
||||
//! Time repeated per-ship decodes of one container, as the viewer does.
|
||||
use std::collections::HashSet;
|
||||
use std::time::Instant;
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use sylpheed_formats::ship::{is_base_part, ship_id_of};
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).unwrap();
|
||||
let names = sylpheed_formats::mesh::xbg7_resource_names(&bytes);
|
||||
let ids: Vec<String> = {
|
||||
let mut v: Vec<String> = names.iter().filter(|n| is_base_part(n))
|
||||
.filter_map(|n| ship_id_of(n).map(|s| s.to_string())).collect();
|
||||
v.sort(); v.dedup(); v.truncate(5); v
|
||||
};
|
||||
for id in &ids {
|
||||
let want: HashSet<String> = names.iter()
|
||||
.filter(|n| ship_id_of(n) == Some(id.as_str())).cloned().collect();
|
||||
let t = Instant::now();
|
||||
let got = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
println!("{id}: {} models in {:?}", got.len(), t.elapsed());
|
||||
}
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
//! Does a resource's DESCRIPTOR carry its bounding box?
|
||||
//!
|
||||
//! The last cross-container disagreements are 24-vertex bound boxes swapping
|
||||
//! identities; no anchoring rule can pin them (see docs). If the descriptor
|
||||
//! states the box, that is the missing information. This decodes the resource,
|
||||
//! takes the box its geometry actually spans, and searches the descriptor for
|
||||
//! those float values.
|
||||
//!
|
||||
//! Usage: bounds_in_descriptor <container.xpr> <resource>...
|
||||
use sylpheed_formats::mesh::{xbg7_descriptor_range, Xbg7Model};
|
||||
use std::collections::HashSet;
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).expect("container");
|
||||
let want: HashSet<String> = a[2..].iter().cloned().collect();
|
||||
for m in Xbg7Model::models_named(&bytes, &want, &|| false) {
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for s in &m.meshes {
|
||||
for q in &s.positions {
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(q[k]);
|
||||
hi[k] = hi[k].max(q[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
let Some((d0, d1)) = xbg7_descriptor_range(&bytes, &m.name) else { continue };
|
||||
println!(
|
||||
"{} descriptor 0x{d0:x}..0x{d1:x} ({} bytes), box lo{:?} hi{:?}",
|
||||
m.name,
|
||||
d1 - d0,
|
||||
lo.map(|v| v.round()),
|
||||
hi.map(|v| v.round())
|
||||
);
|
||||
// Where in the descriptor does each bound value appear (±0.01)?
|
||||
let targets: Vec<(&str, f32)> = vec![
|
||||
("lo.x", lo[0]), ("lo.y", lo[1]), ("lo.z", lo[2]),
|
||||
("hi.x", hi[0]), ("hi.y", hi[1]), ("hi.z", hi[2]),
|
||||
];
|
||||
for (label, v) in targets {
|
||||
let mut at: Vec<usize> = Vec::new();
|
||||
let mut o = d0;
|
||||
while o + 4 <= d1 {
|
||||
let f = f32::from_be_bytes(bytes[o..o + 4].try_into().unwrap());
|
||||
if (f - v).abs() <= 0.01 * (1.0 + v.abs()) {
|
||||
at.push(o - d0);
|
||||
}
|
||||
o += 4;
|
||||
}
|
||||
println!(" {label:5} {v:10.3} at descriptor offsets {:x?}", &at[..at.len().min(6)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,112 +0,0 @@
|
||||
//! Which container did each captured draw come from, and where in it?
|
||||
//!
|
||||
//! Extends the single-container `--map` check in `shared_vbase_check` to a whole
|
||||
//! `resource3d` directory. For each container it indexes every 4-byte-aligned
|
||||
//! position triple, looks up each draw's first dumped position, confirms the run
|
||||
//! at a fixed stride, and reports the modal `vbase − offset`. A container the
|
||||
//! engine loaded shows one dominant constant; an unrelated one shows noise.
|
||||
//!
|
||||
//! The output is capture-named ground truth for anchors far beyond the one ship
|
||||
//! `Stage_S01` gave us.
|
||||
//!
|
||||
//! Usage: capture_truth_scan <resource3d_dir> <capture.log>...
|
||||
use sylpheed_formats::ship_capture::{parse_capture, parse_drawlog, CapturedDraw};
|
||||
use std::collections::HashMap;
|
||||
|
||||
fn q(v: f32) -> i64 {
|
||||
(v as f64 * 1e4).round() as i64
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let dir = &a[1];
|
||||
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");
|
||||
let mut d = parse_capture(&text);
|
||||
if d.is_empty() {
|
||||
d = parse_drawlog(&text);
|
||||
}
|
||||
for x in d {
|
||||
// One entry per buffer; the logs are already deduped per transform.
|
||||
if x.pos.len() >= 8 && x.vcount >= 20 && seen.insert((log.clone(), x.vbase)) {
|
||||
draws.push(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
eprintln!("{} distinct (log, vbase) draws to place", draws.len());
|
||||
|
||||
let mut files: Vec<_> = std::fs::read_dir(dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
let mut placed = 0usize;
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
// Index quantised position triples. Junk floats (NaN/huge) are skipped,
|
||||
// which prunes most of a texture-heavy container.
|
||||
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, Vec<(u32, u32)>> = HashMap::new();
|
||||
for d in &draws {
|
||||
let k = (q(d.pos[0][0]), q(d.pos[0][1]), q(d.pos[0][2]));
|
||||
// ±1 in each axis: the log rounds, our file value may round the
|
||||
// other way at a tie.
|
||||
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 {
|
||||
deltas
|
||||
.entry(d.vbase as i64 - off as i64)
|
||||
.or_default()
|
||||
.push((d.vbase, d.vcount));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut top: Vec<_> = deltas.into_iter().collect();
|
||||
top.sort_by_key(|(_, v)| std::cmp::Reverse(v.len()));
|
||||
if let Some((delta, hits)) = top.first() {
|
||||
if hits.len() >= 3 {
|
||||
placed += hits.len();
|
||||
println!(
|
||||
"{:<22} base=0x{:<10X} buffers={}",
|
||||
f.file_name().unwrap().to_string_lossy(),
|
||||
delta,
|
||||
hits.len()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
eprintln!("{placed} draws placed in a container");
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
//! How much of the "decoded geometry" belongs to SCENE COMPOSITES rather than to
|
||||
//! real meshes? A composite (`rou_*`, `e_rou_*`) carries node transforms; the
|
||||
//! anchor scan nevertheless finds a block for it, and that pseudo-geometry lands
|
||||
//! in coverage and consistency counts.
|
||||
//! Usage: composite_geometry <resource3d_dir>
|
||||
use sylpheed_formats::mesh::{scene_world_nodes, Xbg7Model};
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
let (mut total, mut composite, mut composite_named) = (0usize, 0usize, 0usize);
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
for m in Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false) {
|
||||
total += 1;
|
||||
let has_nodes = !scene_world_nodes(&bytes, &m.name).is_empty();
|
||||
let named = m.name.starts_with("rou_") || m.name.starts_with("e_rou_");
|
||||
if has_nodes {
|
||||
composite += 1;
|
||||
}
|
||||
if named {
|
||||
composite_named += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"{total} decoded; {composite} have scene nodes (a composite), {composite_named} are named rou_/e_rou_"
|
||||
);
|
||||
}
|
||||
@@ -1,87 +0,0 @@
|
||||
//! Minority report: which container decodes a shared resource differently from
|
||||
//! all the others?
|
||||
//!
|
||||
//! Cross-container consistency has been measured as "do the spans agree", which
|
||||
//! only says a resource is inconsistent — not which copy is wrong. With three or
|
||||
//! more copies the majority is the reference, and the minority names the
|
||||
//! container AND the resource to look at. That is what caught the `n054`/`n056`
|
||||
//! shift chain after the exact-coverage fix.
|
||||
//!
|
||||
//! Usage: consensus_check <resource3d_dir> [--list]
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let list = std::env::args().any(|a| a == "--list");
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
// name -> [(container, verts, tris, span)]
|
||||
let mut seen: BTreeMap<String, Vec<(String, usize, usize, [i64; 3])>> = BTreeMap::new();
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let where_ = f.file_name().unwrap().to_string_lossy().to_string();
|
||||
for m in Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false) {
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for s in &m.meshes {
|
||||
for q in &s.positions {
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(q[k]);
|
||||
hi[k] = hi[k].max(q[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if lo[0] == f32::MAX {
|
||||
continue;
|
||||
}
|
||||
let v: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
let t: usize = m.meshes.iter().map(|s| s.indices.len() / 3).sum();
|
||||
let span = [
|
||||
(hi[0] - lo[0]).round() as i64,
|
||||
(hi[1] - lo[1]).round() as i64,
|
||||
(hi[2] - lo[2]).round() as i64,
|
||||
];
|
||||
seen.entry(m.name.clone()).or_default().push((where_.clone(), v, t, span));
|
||||
}
|
||||
}
|
||||
|
||||
let (mut resources, mut minority) = (0usize, 0usize);
|
||||
let mut rows: Vec<String> = Vec::new();
|
||||
for (name, list_) in &seen {
|
||||
// Only compare decodes that agree on how much geometry they found, and
|
||||
// only where a majority can exist.
|
||||
if list_.len() < 3 || !list_.iter().all(|e| e.1 == list_[0].1 && e.2 == list_[0].2) {
|
||||
continue;
|
||||
}
|
||||
let mut votes: HashMap<[i64; 3], usize> = HashMap::new();
|
||||
for e in list_ {
|
||||
*votes.entry(e.3).or_default() += 1;
|
||||
}
|
||||
let (best, n) = votes.iter().max_by_key(|(_, n)| **n).unwrap();
|
||||
if *n * 2 <= list_.len() {
|
||||
continue; // no majority — cannot call anyone the odd one out
|
||||
}
|
||||
resources += 1;
|
||||
for e in list_.iter().filter(|e| e.3 != *best) {
|
||||
minority += 1;
|
||||
rows.push(format!(
|
||||
"{:<22} {name:<26} v={:<6} {:?} vs the other {n} containers' {:?}",
|
||||
e.0, e.1, e.3, best
|
||||
));
|
||||
}
|
||||
}
|
||||
if list {
|
||||
for r in &rows {
|
||||
println!("{r}");
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"{minority} minority decodes across {resources} resources that have a majority"
|
||||
);
|
||||
}
|
||||
@@ -16,7 +16,7 @@
|
||||
//! Usage:
|
||||
//! SYLPHEED_ISO=... cargo run --release --example correlate_capture -- \
|
||||
//! <capture.log> <Stage_SNN> <ship_id> [ref_part_substr] [--emit]
|
||||
//! e.g. SYLPHEED_ISO="/home/fabi/RE - Project Sylpheed/Project Sylpheed - Arc of
|
||||
//! e.g. SYLPHEED_ISO="/home/fabi/RE Project Sylpheed/Project Sylpheed - Arc of
|
||||
//! Deception (USA, Europe) (En,Ja).iso" \
|
||||
//! cargo run --release --example correlate_capture -- \
|
||||
//! xenia_ship_capture.log Stage_S01 e106 bdy_04 --emit
|
||||
|
||||
@@ -1,280 +0,0 @@
|
||||
//! Correlate a capture **per frame** and cross-check the frames against each
|
||||
//! other — the placement is only believable if independent frames agree.
|
||||
//!
|
||||
//! `correlate_capture` treats one capture log as one set of draws. It is not:
|
||||
//! an F10 press dumps ~14 frames with no delimiter, and `WV_ref⁻¹ · WV_p` only
|
||||
//! cancels the camera within a single frame (see
|
||||
//! [`sylpheed_formats::ship_capture::segment_frames`]). With a moving camera the
|
||||
//! mixed-frame answer is wrong, and — worse — it is wrong *silently*.
|
||||
//!
|
||||
//! So: segment, correlate each frame independently, then report per part the
|
||||
//! median translation and the spread across frames. A part whose spread is a
|
||||
//! few units is measured; a part that swings by hundreds is not, whatever the
|
||||
//! single-shot number said.
|
||||
//!
|
||||
//! Usage:
|
||||
//! SYLPHEED_ISO=... cargo run --release --example correlate_frames -- \
|
||||
//! <capture.log> <Stage_SNN> <ship_id> [ref_part_substr] [--min-parts N]
|
||||
|
||||
use sylpheed_formats::mesh::{xbg7_resource_names, Xbg7Model};
|
||||
use sylpheed_formats::ship::{is_base_part, ship_id_of};
|
||||
use sylpheed_formats::ship_capture::{
|
||||
correlate, parse_capture, parse_drawlog, segment_frames, PartKey,
|
||||
};
|
||||
use sylpheed_formats::xiso::open_iso;
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
use std::path::Path;
|
||||
|
||||
fn median(mut v: Vec<f32>) -> f32 {
|
||||
v.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
let n = v.len();
|
||||
if n % 2 == 1 { v[n / 2] } else { 0.5 * (v[n / 2 - 1] + v[n / 2]) }
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let positional: Vec<&String> = args[1..].iter().filter(|a| !a.starts_with("--")).collect();
|
||||
if positional.len() < 3 {
|
||||
eprintln!("usage: correlate_frames <capture.log> <Stage_SNN> <ship_id> [ref_part] [--min-parts N]");
|
||||
std::process::exit(2);
|
||||
}
|
||||
let (log, stage, id) = (positional[0], positional[1], positional[2]);
|
||||
let ref_sub = positional.get(3).map(|s| s.as_str()).unwrap_or("bdy_01");
|
||||
let min_parts: usize = args
|
||||
.iter()
|
||||
.position(|a| a == "--min-parts")
|
||||
.and_then(|i| args.get(i + 1))
|
||||
.and_then(|s| s.parse().ok())
|
||||
.unwrap_or(3);
|
||||
|
||||
let iso = std::env::var("SYLPHEED_ISO").expect("SYLPHEED_ISO");
|
||||
let text = std::fs::read_to_string(log).expect("read log");
|
||||
let mut draws = parse_capture(&text);
|
||||
if draws.is_empty() {
|
||||
draws = parse_drawlog(&text);
|
||||
}
|
||||
let frames = segment_frames(&draws);
|
||||
println!("{} draws → {} camera-consistent blocks", draws.len(), frames.len());
|
||||
|
||||
let bytes = {
|
||||
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
|
||||
rt.block_on(async {
|
||||
let mut r = open_iso(Path::new(&iso)).await.unwrap();
|
||||
r.read_file(&format!("hidden/resource3d/{stage}.xpr")).await.unwrap()
|
||||
})
|
||||
};
|
||||
let names = xbg7_resource_names(&bytes);
|
||||
let base_parts: Vec<String> = names
|
||||
.iter()
|
||||
.filter(|n| is_base_part(n) && ship_id_of(n) == Some(id.as_str()))
|
||||
.cloned()
|
||||
.collect();
|
||||
let mut want: HashSet<String> = base_parts.iter().cloned().collect();
|
||||
for p in &base_parts {
|
||||
for suf in ["_m", "_l", "_d"] {
|
||||
let c = format!("{p}{suf}");
|
||||
if names.contains(&c) {
|
||||
want.insert(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
let positions_of = |name: &str| -> Option<Vec<[f32; 3]>> {
|
||||
let m = models.iter().find(|m| m.name == name)?;
|
||||
Some(m.meshes.iter().flat_map(|s| s.positions.iter().copied()).collect())
|
||||
};
|
||||
|
||||
// part -> [T per frame], and how many frames placed it at all.
|
||||
let mut samples: BTreeMap<String, Vec<[f32; 3]>> = BTreeMap::new();
|
||||
let mut rots: BTreeMap<String, Vec<[[f32; 3]; 3]>> = BTreeMap::new();
|
||||
let mut used_frames = 0usize;
|
||||
for (fi, fr) in frames.iter().enumerate() {
|
||||
let mut keys: Vec<PartKey> = Vec::new();
|
||||
for part in &base_parts {
|
||||
let variants =
|
||||
[part.clone(), format!("{part}_m"), format!("{part}_l"), format!("{part}_d")];
|
||||
let union: Vec<[f32; 3]> =
|
||||
variants.iter().filter_map(|v| positions_of(v)).flatten().collect();
|
||||
for cand in &variants {
|
||||
if let Some(pos) = positions_of(cand) {
|
||||
let vcount = pos.len() as u32;
|
||||
if fr.iter().any(|d| d.vcount == vcount) {
|
||||
keys.push(PartKey { part: part.clone(), vcount, ref_pos: union.clone() });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let Some(ship) = correlate(id, fr, &keys, ref_sub) else { continue };
|
||||
if ship.parts.len() < min_parts {
|
||||
continue;
|
||||
}
|
||||
// Placements are expressed in the REFERENCE part's frame, so blocks that
|
||||
// fell back to a different reference (because the requested one was not
|
||||
// drawn in that block) are in a different coordinate system entirely.
|
||||
// Averaging them together is what makes an otherwise clean result look
|
||||
// like it disagrees by exactly the distance between the two references.
|
||||
if !ship.reference.contains(ref_sub) {
|
||||
println!(" block {fi:2}: skipped — reference fell back to {}", ship.reference);
|
||||
continue;
|
||||
}
|
||||
used_frames += 1;
|
||||
println!(
|
||||
" block {fi:2} ({:4} draws): ref={} parts={}",
|
||||
fr.len(),
|
||||
ship.reference,
|
||||
ship.parts.len()
|
||||
);
|
||||
for p in &ship.parts {
|
||||
samples.entry(p.part.clone()).or_default().push(p.t);
|
||||
rots.entry(p.part.clone()).or_default().push(p.m);
|
||||
}
|
||||
}
|
||||
|
||||
if used_frames == 0 {
|
||||
println!("\nno block placed {min_parts}+ parts — the ship is not drawn close enough");
|
||||
return;
|
||||
}
|
||||
// Aggregate by CONSENSUS, not by average. A stage holds several ships of the
|
||||
// same class, they share vertex buffers, and a block can therefore contain
|
||||
// one instance's full-LOD part next to another instance's `_m` copy — two
|
||||
// different buffers, so nothing splits them, and the recovered translation
|
||||
// then belongs to whichever instance the correlator happened to pick. Those
|
||||
// are outliers by thousands of units, so a mean or a median over all blocks
|
||||
// is meaningless; the largest cluster of blocks that agree with each other
|
||||
// is the placement, and the rest are honestly reported as other instances.
|
||||
const TOL: f32 = 25.0; // float noise in the WV products, measured ≤0.4
|
||||
let cluster = |ts: &Vec<[f32; 3]>| -> (Vec<usize>, usize) {
|
||||
let mut best: Vec<usize> = Vec::new();
|
||||
for seed in ts {
|
||||
let near: Vec<usize> = ts
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, t)| (0..3).all(|i| (t[i] - seed[i]).abs() < TOL))
|
||||
.map(|(i, _)| i)
|
||||
.collect();
|
||||
if near.len() > best.len() {
|
||||
best = near;
|
||||
}
|
||||
}
|
||||
let out = ts.len() - best.len();
|
||||
(best, out)
|
||||
};
|
||||
println!("\nacross {used_frames} blocks — consensus T (largest agreeing cluster):");
|
||||
let mut agree = 0usize;
|
||||
let mut consensus: BTreeMap<String, ([f32; 3], [[f32; 3]; 3])> = BTreeMap::new();
|
||||
for (part, ts) in &samples {
|
||||
let (cl_idx, outliers) = cluster(ts);
|
||||
let cl: Vec<[f32; 3]> = cl_idx.iter().map(|&i| ts[i]).collect();
|
||||
let med = [
|
||||
median(cl.iter().map(|t| t[0]).collect()),
|
||||
median(cl.iter().map(|t| t[1]).collect()),
|
||||
median(cl.iter().map(|t| t[2]).collect()),
|
||||
];
|
||||
let spread: Vec<f32> = (0..3)
|
||||
.map(|a| {
|
||||
let v: Vec<f32> = cl.iter().map(|t| t[a]).collect();
|
||||
v.iter().cloned().fold(f32::MIN, f32::max) - v.iter().cloned().fold(f32::MAX, f32::min)
|
||||
})
|
||||
.collect();
|
||||
let verdict = if cl.len() < 2 {
|
||||
"single block — unverified"
|
||||
} else {
|
||||
agree += 1;
|
||||
"AGREES"
|
||||
};
|
||||
// How much the ROTATION varies between blocks that agree on position.
|
||||
// A part bolted to the hull reads 0 here; a part that is articulating
|
||||
// (turret aiming, engine gimballing) does not — which is what separates
|
||||
// "the assembler has the rotation wrong" from "the part moved".
|
||||
let all_ms = rots.get(part).cloned().unwrap_or_default();
|
||||
let ms: Vec<[[f32; 3]; 3]> =
|
||||
cl_idx.iter().filter_map(|&i| all_ms.get(i).copied()).collect();
|
||||
// Keep a rotation from INSIDE the cluster: the first sample overall can
|
||||
// belong to another instance, and diffing static against that reads as a
|
||||
// rotation error that is really an instance mix-up.
|
||||
consensus.insert(
|
||||
part.clone(),
|
||||
(med, ms.first().copied().unwrap_or([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]])),
|
||||
);
|
||||
let rot_var = ms
|
||||
.iter()
|
||||
.flat_map(|a| ms.iter().map(move |b| (a, b)))
|
||||
.map(|(a, b)| {
|
||||
(0..3)
|
||||
.flat_map(|i| (0..3).map(move |j| (i, j)))
|
||||
.map(|(i, j)| (a[i][j] - b[i][j]).abs())
|
||||
.fold(0.0f32, f32::max)
|
||||
})
|
||||
.fold(0.0f32, f32::max);
|
||||
println!(
|
||||
" {part:18} {:2}/{:2} blocks T=[{:9.1}{:9.1}{:9.1}] spread=[{:6.2}{:6.2}{:6.2}] rotVar={rot_var:5.3} {verdict}{}",
|
||||
cl.len(), ts.len(), med[0], med[1], med[2], spread[0], spread[1], spread[2],
|
||||
if outliers > 0 { format!(" (+{outliers} other-instance)") } else { String::new() }
|
||||
);
|
||||
}
|
||||
println!("\n{agree}/{} parts reproduce across blocks", samples.len());
|
||||
|
||||
// `--static <Stage_SNN.xpr>`: diff the offline assembler against this
|
||||
// ground truth. Static placements are in ship space, so both sides are
|
||||
// re-expressed in the reference part's frame before comparing — and the
|
||||
// rotation is compared too, because "wrong orientation" is half of the
|
||||
// reported viewer symptom and a translation-only check cannot see it.
|
||||
let Some(si) = args.iter().position(|a| a == "--static") else { return };
|
||||
let Some(spath) = args.get(si + 1) else { return };
|
||||
let sbytes = std::fs::read(spath).expect("read stage container");
|
||||
// `include_external = true` — the engine cluster, the bridge and cross-id
|
||||
// turrets live in SEPARATE composites (`e_rou_e106_eng`, 3 nodes) that the
|
||||
// primary-composite pass does not reach. With `false` an e106 assembles as
|
||||
// 5 parts and the runtime capture's bridge/nacelles read as "not produced by
|
||||
// assemble_ship", which is a property of the caller, not of the format.
|
||||
let scene = sylpheed_formats::ship::assemble_ship(&sbytes, id, true);
|
||||
let Some(sref) = scene.iter().find(|p| p.resource.contains(ref_sub)) else {
|
||||
println!("\nstatic: no part matching '{ref_sub}' — cannot align frames");
|
||||
return;
|
||||
};
|
||||
// The reference is placed axis-aligned in every ship seen so far; if that
|
||||
// ever stops holding, the rotation would have to be unwound here too.
|
||||
println!("\nstatic vs runtime (both relative to {}):", sref.resource);
|
||||
let mut worst_t = 0.0f32;
|
||||
let mut worst_r = 0.0f32;
|
||||
for (part, (med, rm)) in &consensus {
|
||||
let (med, rm) = (*med, *rm);
|
||||
// A part may be instanced (mirrored twins share a resource name); take
|
||||
// the static copy that lands nearest the captured one.
|
||||
let cands: Vec<&sylpheed_formats::mesh::ScenePart> =
|
||||
scene.iter().filter(|p| &p.resource == part).collect();
|
||||
if cands.is_empty() {
|
||||
println!(" {part:18} — not produced by assemble_ship");
|
||||
continue;
|
||||
}
|
||||
let rel = |p: &sylpheed_formats::mesh::ScenePart| {
|
||||
[p.t[0] - sref.t[0], p.t[1] - sref.t[1], p.t[2] - sref.t[2]]
|
||||
};
|
||||
let best = cands
|
||||
.iter()
|
||||
.min_by(|a, b| {
|
||||
let d = |p: &sylpheed_formats::mesh::ScenePart| {
|
||||
let r = rel(p);
|
||||
(0..3).map(|i| (r[i] - med[i]).powi(2)).sum::<f32>()
|
||||
};
|
||||
d(a).partial_cmp(&d(b)).unwrap()
|
||||
})
|
||||
.unwrap();
|
||||
let r = rel(best);
|
||||
let dt: Vec<f32> = (0..3).map(|i| r[i] - med[i]).collect();
|
||||
let dtm = dt.iter().map(|v| v.abs()).fold(0.0f32, f32::max);
|
||||
let drm = (0..3)
|
||||
.flat_map(|i| (0..3).map(move |j| (i, j)))
|
||||
.map(|(i, j)| (best.m[i][j] - rm[i][j]).abs())
|
||||
.fold(0.0f32, f32::max);
|
||||
worst_t = worst_t.max(dtm);
|
||||
worst_r = worst_r.max(drm);
|
||||
let mark = if dtm < 1.0 && drm < 0.02 { "MATCH" } else { "DIFFERS" };
|
||||
println!(
|
||||
" {part:18} static=[{:9.1}{:9.1}{:9.1}] dT={dtm:7.2} dR={drm:6.3} {mark}",
|
||||
r[0], r[1], r[2]
|
||||
);
|
||||
}
|
||||
println!("\nworst dT={worst_t:.2} worst dR={worst_r:.3} ({} static parts, {} captured)",
|
||||
scene.len(), samples.len());
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
//! Do real index buffers address their whole vertex pool?
|
||||
//!
|
||||
//! `validate_block` rejects a block whose indices reach fewer than `vtx_count−4`
|
||||
//! vertices ("buffer not covered"). That gate is the furthest-reached rejection
|
||||
//! for a handful of resources that never decode — so the question is whether it
|
||||
//! is well founded. This measures the slack on every block that DOES decode: if
|
||||
//! real geometry always covers its pool, under-coverage is good evidence of a
|
||||
//! wrong candidate and the gate stands.
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
let mut hist: BTreeMap<i64, usize> = BTreeMap::new();
|
||||
let mut worst: Vec<(i64, String)> = Vec::new();
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
for m in Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false) {
|
||||
for sub in &m.meshes {
|
||||
if sub.positions.is_empty() || sub.indices.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let max_idx = *sub.indices.iter().max().unwrap() as i64;
|
||||
let slack = sub.positions.len() as i64 - 1 - max_idx;
|
||||
*hist.entry(slack.min(20)).or_default() += 1;
|
||||
if slack > 4 {
|
||||
worst.push((slack, format!("{} in {}", m.name, f.file_name().unwrap().to_string_lossy())));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("unreferenced tail vertices (vtx_count − 1 − max index), over decoded sub-meshes:");
|
||||
for (slack, n) in &hist {
|
||||
println!(" {:>3}{} : {n}", slack, if *slack == 20 { "+" } else { " " });
|
||||
}
|
||||
worst.sort_by_key(|(s, _)| std::cmp::Reverse(*s));
|
||||
for (s, w) in worst.iter().take(5) {
|
||||
println!(" largest slack {s}: {w}");
|
||||
}
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
//! Scratch analysis: for one IDXD key, list every object that DECLARES it and
|
||||
//! whether it carries a value on disc or is left at the title-code default.
|
||||
//!
|
||||
//! Run: cargo run -p sylpheed-formats --example default_owners -- <KEY> [KEY...]
|
||||
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
|
||||
fn is_number(s: &str) -> bool {
|
||||
let s = s.strip_suffix(['f', 'F']).unwrap_or(s);
|
||||
let t = s.strip_prefix(['-', '+']).unwrap_or(s);
|
||||
!t.is_empty() && t.chars().all(|c| c.is_ascii_digit() || c == '.')
|
||||
}
|
||||
fn is_key(s: &str) -> bool {
|
||||
!s.is_empty()
|
||||
&& s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
|
||||
&& s.chars().next().is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
|
||||
&& !is_number(s)
|
||||
}
|
||||
fn is_value(s: &str) -> bool {
|
||||
is_number(s) || !is_key(s)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let root = std::env::var("SYLPHEED_DISC")
|
||||
.unwrap_or_else(|_| "/home/fabi/RE - Project Sylpheed/sylph_extract".into());
|
||||
let wanted: Vec<String> = std::env::args().skip(1).collect();
|
||||
let arc = PakArchive::open(std::path::Path::new(&root).join("dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
|
||||
for e in arc.entries() {
|
||||
let Ok(bytes) = arc.read(e) else { continue };
|
||||
let Ok(obj) = IdxdObject::parse(&bytes) else { continue };
|
||||
let toks = obj.tokens().to_vec();
|
||||
let mut hits: Vec<String> = vec![];
|
||||
for (i, t) in toks.iter().enumerate() {
|
||||
if !wanted.iter().any(|w| w == t) {
|
||||
continue;
|
||||
}
|
||||
let valued = i > 0 && is_value(&toks[i - 1]);
|
||||
hits.push(if valued {
|
||||
format!("{t}={}", toks[i - 1])
|
||||
} else {
|
||||
format!("{t}=<DEFAULT>")
|
||||
});
|
||||
}
|
||||
if !hits.is_empty() {
|
||||
println!("0x{:08x} {:<44} {}", obj.schema_hash, obj.identity(), hits.join(" "));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
//! Scratch analysis: which IDXD fields are DECLARED but left at their default on
|
||||
//! disc, per schema. Those defaults live in title code, so they can only be read
|
||||
//! from the running game — this prints the shopping list for that dynamic capture.
|
||||
//!
|
||||
//! Run: cargo run -p sylpheed-formats --example defaulted_fields -- <disc-root>
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
|
||||
fn is_number(s: &str) -> bool {
|
||||
let s = s.strip_suffix(['f', 'F']).unwrap_or(s);
|
||||
let t = s.strip_prefix(['-', '+']).unwrap_or(s);
|
||||
!t.is_empty() && t.chars().all(|c| c.is_ascii_digit() || c == '.')
|
||||
}
|
||||
|
||||
/// Same shape-test the parser uses: an identifier-looking token that is not a
|
||||
/// value literal is a field-name key.
|
||||
fn is_key(s: &str) -> bool {
|
||||
!s.is_empty()
|
||||
&& s.chars()
|
||||
.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
|
||||
&& s.chars().next().is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
|
||||
&& !is_number(s)
|
||||
}
|
||||
|
||||
fn is_value(s: &str) -> bool {
|
||||
is_number(s) || !is_key(s)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let root = std::env::args()
|
||||
.nth(1)
|
||||
.unwrap_or_else(|| "/home/fabi/RE - Project Sylpheed/sylph_extract".into());
|
||||
let paks: Vec<String> = std::env::args().skip(2).collect();
|
||||
let paks = if paks.is_empty() {
|
||||
vec![
|
||||
"dat/GP_MAIN_GAME_E.pak".to_string(),
|
||||
"dat/GP_HANGAR_ARSENAL.pak".to_string(),
|
||||
]
|
||||
} else {
|
||||
paks
|
||||
};
|
||||
|
||||
for pak_rel in &paks {
|
||||
let path = std::path::Path::new(&root).join(pak_rel);
|
||||
let Ok(arc) = PakArchive::open(&path) else {
|
||||
eprintln!("-- skip {pak_rel} (open failed)");
|
||||
continue;
|
||||
};
|
||||
println!("\n================ {pak_rel} ================");
|
||||
|
||||
// schema -> key -> (n_set, n_defaulted, distinct values, example owners)
|
||||
type Stat = (usize, usize, BTreeSet<String>, Vec<String>);
|
||||
let mut per_schema: BTreeMap<u32, (usize, BTreeMap<String, Stat>)> = BTreeMap::new();
|
||||
|
||||
for e in arc.entries() {
|
||||
let Ok(bytes) = arc.read(e) else { continue };
|
||||
let Ok(obj) = IdxdObject::parse(&bytes) else {
|
||||
continue;
|
||||
};
|
||||
let ident = obj.identity();
|
||||
let toks = obj.tokens().to_vec();
|
||||
let entry = per_schema.entry(obj.schema_hash).or_default();
|
||||
entry.0 += 1;
|
||||
// Track which keys this object declares, and whether each is valued.
|
||||
let mut seen_here: BTreeMap<String, Option<String>> = BTreeMap::new();
|
||||
for (i, t) in toks.iter().enumerate() {
|
||||
if !is_key(t) {
|
||||
continue;
|
||||
}
|
||||
let prev = if i == 0 { None } else { Some(&toks[i - 1]) };
|
||||
let valued = prev.map(|p| is_value(p)).unwrap_or(false);
|
||||
let v = if valued { Some(toks[i - 1].clone()) } else { None };
|
||||
seen_here.entry(t.clone()).or_insert(v);
|
||||
}
|
||||
for (k, v) in seen_here {
|
||||
let s = entry.1.entry(k).or_default();
|
||||
match v {
|
||||
Some(val) => {
|
||||
s.0 += 1;
|
||||
if s.2.len() < 12 {
|
||||
s.2.insert(val);
|
||||
}
|
||||
}
|
||||
None => {
|
||||
s.1 += 1;
|
||||
if s.3.len() < 6 {
|
||||
s.3.push(ident.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (schema, (n_obj, keys)) in per_schema {
|
||||
if n_obj < 2 {
|
||||
continue;
|
||||
}
|
||||
let name = match schema {
|
||||
0x0426_e81d => "PLAYER",
|
||||
0x6ab4_825a => "WEAPON",
|
||||
0x43fa_a517 => "UNIT",
|
||||
0x3c5b_0549 => "VESSEL",
|
||||
0xbd86_d41c => "CHARACTER",
|
||||
0x3c9a_e32e => "STAGE",
|
||||
0xb412_e6d8 => "MESSAGE",
|
||||
_ => "?",
|
||||
};
|
||||
let defaulted: Vec<_> = keys
|
||||
.iter()
|
||||
.filter(|(_, s)| s.1 > 0)
|
||||
.collect();
|
||||
if defaulted.is_empty() {
|
||||
continue;
|
||||
}
|
||||
println!("\n--- schema 0x{schema:08x} {name} ({n_obj} objects) ---");
|
||||
println!(
|
||||
"{:<30} {:>5} {:>5} {}",
|
||||
"KEY", "set", "dflt", "values seen (≤12) | owners defaulting"
|
||||
);
|
||||
for (k, (n_set, n_def, vals, owners)) in defaulted {
|
||||
let vv: Vec<&str> = vals.iter().map(|s| s.as_str()).collect();
|
||||
println!(
|
||||
"{:<30} {:>5} {:>5} {} | {}",
|
||||
k,
|
||||
n_set,
|
||||
n_def,
|
||||
vv.join(","),
|
||||
owners.join(",")
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
//! Calibrate the connectivity cap against the whole disc.
|
||||
//!
|
||||
//! `XBG7_EDGE_CAP` sets the cap; this reports, for one setting, how much
|
||||
//! geometry decodes and how self-consistent it is across containers — the two
|
||||
//! numbers any change to the cap has to trade off. Run it once per cap value.
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
// name -> (verts, tris) -> spans seen, exactly as mesh_consistency_disc.rs.
|
||||
let mut seen: BTreeMap<String, Vec<([i64; 3], usize, usize)>> = BTreeMap::new();
|
||||
let (mut models, mut verts) = (0usize, 0usize);
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
for m in Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false) {
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for s in &m.meshes {
|
||||
for q in &s.positions {
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(q[k]);
|
||||
hi[k] = hi[k].max(q[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if lo[0] == f32::MAX {
|
||||
continue;
|
||||
}
|
||||
let v: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
let t: usize = m.meshes.iter().map(|s| s.indices.len() / 3).sum();
|
||||
models += 1;
|
||||
verts += v;
|
||||
if std::env::var("DUMP").is_ok() {
|
||||
// Per-resource signature, so two cap settings can be diffed:
|
||||
// a cap change that silently MOVES an existing anchor is the
|
||||
// risk a coverage count cannot see.
|
||||
println!(
|
||||
"{}|{}|{v}|{t}|{}|{}|{}|{}",
|
||||
f.file_name().unwrap().to_string_lossy(),
|
||||
m.name,
|
||||
m.meshes[0].vbuf_offset.unwrap_or(0),
|
||||
(hi[0] - lo[0]).round() as i64,
|
||||
(hi[1] - lo[1]).round() as i64,
|
||||
(hi[2] - lo[2]).round() as i64
|
||||
);
|
||||
}
|
||||
seen.entry(m.name.clone()).or_default().push((
|
||||
[
|
||||
(hi[0] - lo[0]).round() as i64,
|
||||
(hi[1] - lo[1]).round() as i64,
|
||||
(hi[2] - lo[2]).round() as i64,
|
||||
],
|
||||
v,
|
||||
t,
|
||||
));
|
||||
}
|
||||
}
|
||||
let (mut shared, mut inconsistent) = (0usize, 0usize);
|
||||
for (_, list) in &seen {
|
||||
if list.len() < 2 || !list.iter().all(|e| e.1 == list[0].1 && e.2 == list[0].2) {
|
||||
continue;
|
||||
}
|
||||
shared += 1;
|
||||
if list.iter().any(|e| e.0 != list[0].0) {
|
||||
inconsistent += 1;
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"cap={} models={models} verts={verts} shared={shared} inconsistent={inconsistent}",
|
||||
std::env::var("XBG7_EDGE_CAP").unwrap_or_else(|_| "library default".into())
|
||||
);
|
||||
}
|
||||
@@ -1,106 +0,0 @@
|
||||
//! Does every part of a ship sit inside the envelope its siblings describe?
|
||||
//!
|
||||
//! `slab_screen` compared *scale* and could not see the `e106` slab. What the eye
|
||||
//! used when the render exposed it was **relationship**: a blocky mass sitting
|
||||
//! apart from the hull. This measures that — assemble a ship, and for each part
|
||||
//! ask how far its world box protrudes beyond the box of all the OTHER parts,
|
||||
//! relative to the ship's own size. A mis-anchored block sticks out; a real part,
|
||||
//! however big, is part of the silhouette.
|
||||
//!
|
||||
//! Usage: envelope_screen <resource3d_dir> [protrusion_fraction]
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use sylpheed_formats::ship::{assemble_ship, ship_id_of};
|
||||
use std::collections::{BTreeSet, HashSet};
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let limit: f32 = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(0.35);
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
let mut flagged = 0usize;
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let ids: BTreeSet<String> = Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false)
|
||||
.iter()
|
||||
.filter_map(|m| ship_id_of(&m.name).map(|s| s.to_string()))
|
||||
.collect();
|
||||
for id in &ids {
|
||||
let placed = assemble_ship(&bytes, id, true);
|
||||
if placed.len() < 3 {
|
||||
continue;
|
||||
}
|
||||
let want: HashSet<String> = placed.iter().map(|p| p.resource.clone()).collect();
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
// World box per placement.
|
||||
let mut boxes: Vec<(String, [f32; 3], [f32; 3])> = Vec::new();
|
||||
for p in &placed {
|
||||
let Some(m) = models.iter().find(|m| m.name == p.resource) else { continue };
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for s in &m.meshes {
|
||||
for q in &s.positions {
|
||||
let w = p.apply(*q);
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(w[k]);
|
||||
hi[k] = hi[k].max(w[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if lo[0] != f32::MAX {
|
||||
boxes.push((p.resource.clone(), lo, hi));
|
||||
}
|
||||
}
|
||||
if boxes.len() < 3 {
|
||||
continue;
|
||||
}
|
||||
for i in 0..boxes.len() {
|
||||
// Envelope of every OTHER part.
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for (j, b) in boxes.iter().enumerate() {
|
||||
if i == j {
|
||||
continue;
|
||||
}
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(b.1[k]);
|
||||
hi[k] = hi[k].max(b.2[k]);
|
||||
}
|
||||
}
|
||||
// Per-AXIS: a bow legitimately extends the ship along its long
|
||||
// axis, so protrusion only means something measured against the
|
||||
// envelope's size IN THAT AXIS. The e106 slab stuck ~1 500 out in
|
||||
// Y where its siblings spanned ~800.
|
||||
let mut worst = 0.0f32;
|
||||
let mut worst_out = 0.0f32;
|
||||
for k in 0..3 {
|
||||
let size_k = hi[k] - lo[k];
|
||||
if size_k <= 1.0 {
|
||||
continue;
|
||||
}
|
||||
let out_k = (lo[k] - boxes[i].1[k]).max(boxes[i].2[k] - hi[k]).max(0.0);
|
||||
if out_k / size_k > worst {
|
||||
worst = out_k / size_k;
|
||||
worst_out = out_k;
|
||||
}
|
||||
}
|
||||
let (out, size) = (worst_out, 1.0f32);
|
||||
let _ = size;
|
||||
if worst > limit {
|
||||
flagged += 1;
|
||||
println!(
|
||||
"{:<20} {:<22} protrudes {:>7.0} beyond its siblings ({:.0}% of the ship)",
|
||||
f.file_name().unwrap().to_string_lossy(),
|
||||
boxes[i].0,
|
||||
out,
|
||||
100.0 * worst
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("{flagged} parts protrude more than {:.0}% of their ship's size", 100.0 * limit);
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
//! Does a FILTERED decode agree with the full one?
|
||||
//!
|
||||
//! Distinct anchor assignment resolves collisions against the set of resources
|
||||
//! being decoded — so `models_named` (a filtered subset, used by the ship
|
||||
//! assembler and the viewer) can reach a different answer from a whole-container
|
||||
//! decode. This measures that directly.
|
||||
//! Usage: filter_consistency <container.xpr> [resource...]
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use std::collections::HashSet;
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).expect("container");
|
||||
let full = Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false);
|
||||
let names: Vec<String> = if a.len() > 2 {
|
||||
a[2..].to_vec()
|
||||
} else {
|
||||
full.iter().map(|m| m.name.clone()).collect()
|
||||
};
|
||||
let mut differ = 0usize;
|
||||
for n in &names {
|
||||
let want: HashSet<String> = std::iter::once(n.clone()).collect();
|
||||
let one = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
let (Some(f), Some(s)) = (full.iter().find(|m| &m.name == n), one.first()) else {
|
||||
continue;
|
||||
};
|
||||
let off = |m: &Xbg7Model| m.meshes.first().and_then(|s| s.vbuf_offset).unwrap_or(0);
|
||||
if off(f) != off(s) {
|
||||
differ += 1;
|
||||
if differ <= 10 {
|
||||
println!("{n}: full decode at 0x{:x}, filtered at 0x{:x}", off(f), off(s));
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("{differ} of {} resources decode differently when filtered", names.len());
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
//! Where could a resource's index buffer be, given the vertex buffer a runtime
|
||||
//! capture proves the engine drew from? Tests the anchor scan's adjacency
|
||||
//! assumption against ground truth.
|
||||
use sylpheed_formats::mesh::{debug_find_index_buffer, debug_resource_params};
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).unwrap();
|
||||
for pair in a[2..].iter() {
|
||||
let (name, off) = pair.split_once('@').unwrap();
|
||||
let vb = usize::from_str_radix(off.trim_start_matches("0x"), 16).unwrap();
|
||||
let params = debug_resource_params(&bytes, name);
|
||||
let markers = params.as_ref().map(|(m, _)| m.clone()).unwrap_or_default();
|
||||
println!("{name} @ 0x{vb:x} markers={markers:?}");
|
||||
let hits = debug_find_index_buffer(&bytes, name, vb);
|
||||
if hits.is_empty() {
|
||||
println!(" no index buffer anywhere in the container validates this block");
|
||||
}
|
||||
let mut hits = hits;
|
||||
hits.sort_by_key(|(_, d)| d.abs());
|
||||
for (ib, d) in hits.iter().take(8) {
|
||||
println!(" ib 0x{ib:x} vb-ib = {d} bytes");
|
||||
}
|
||||
if hits.len() > 8 {
|
||||
println!(" … {} total", hits.len());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
//! Does the container hold an X-mirrored copy of a resource's decoded buffer?
|
||||
//!
|
||||
//! The twin invariant (see `twin_mirror_audit`) flags `…_01`/`…_02` pairs that
|
||||
//! decode to unrelated geometry. If the mirror of one twin's buffer exists
|
||||
//! somewhere else in the container, that offset is where the other twin belongs
|
||||
//! and the pair is a mis-anchor; if it does not exist, the pair is simply not a
|
||||
//! mirrored pair.
|
||||
//!
|
||||
//! Usage: find_mirror <container.xpr> <resource>...
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use std::collections::HashSet;
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).expect("container");
|
||||
let want: HashSet<String> = a[2..].iter().cloned().collect();
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
let be = |at: usize| f32::from_be_bytes(bytes[at..at + 4].try_into().unwrap());
|
||||
|
||||
for m in &models {
|
||||
let pos: Vec<[f32; 3]> = m.meshes.iter().flat_map(|s| s.positions.clone()).take(8).collect();
|
||||
if pos.len() < 8 {
|
||||
continue;
|
||||
}
|
||||
let anchored = m.meshes[0].vbuf_offset.unwrap_or(0);
|
||||
let (mut direct, mut mirror) = (Vec::new(), Vec::new());
|
||||
for o in (0..bytes.len().saturating_sub(12 + 8 * 24)).step_by(4) {
|
||||
for (flip, out) in [(1.0f32, &mut direct), (-1.0f32, &mut mirror)] {
|
||||
if (0..8).all(|k| {
|
||||
let at = o + k * 24;
|
||||
(be(at) - flip * pos[k][0]).abs() <= 1e-4
|
||||
&& (be(at + 4) - pos[k][1]).abs() <= 1e-4
|
||||
&& (be(at + 8) - pos[k][2]).abs() <= 1e-4
|
||||
}) {
|
||||
out.push(o);
|
||||
}
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"{:<20} anchored 0x{anchored:x} direct copies {:x?} mirrored copies {:x?}",
|
||||
m.name, direct, mirror
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
//! Which gate stops the resources that never decode?
|
||||
//! Usage: gate_histogram <resource3d_dir> [max_resources]
|
||||
use sylpheed_formats::mesh::{debug_best_rejection, xbg7_resource_names, Xbg7Model};
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let cap: usize = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(usize::MAX);
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
let mut hist: BTreeMap<usize, (usize, String)> = BTreeMap::new();
|
||||
let mut done = 0usize;
|
||||
for f in &files {
|
||||
if done >= cap {
|
||||
break;
|
||||
}
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let names = xbg7_resource_names(&bytes);
|
||||
if names.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let got: HashSet<String> = Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false)
|
||||
.into_iter()
|
||||
.map(|m| m.name)
|
||||
.collect();
|
||||
for n in names.iter().filter(|n| !got.contains(*n)) {
|
||||
if done >= cap {
|
||||
break;
|
||||
}
|
||||
done += 1;
|
||||
if let Some((rank, why)) = debug_best_rejection(&bytes, n) {
|
||||
let e = hist.entry(rank).or_insert((0, String::new()));
|
||||
e.0 += 1;
|
||||
if e.1.is_empty() {
|
||||
e.1 = format!("{n}: {why}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("furthest gate reached, over {done} resources that never decode:");
|
||||
let label = |r: usize| match r {
|
||||
0 => "no gate reached",
|
||||
1 => "index out of range",
|
||||
2 => "buffer not covered by indices",
|
||||
3 => "degenerate / implausible positions",
|
||||
4 => "connectivity (mean edge / diagonal)",
|
||||
5 => "winding consistency",
|
||||
9 => "grouped pool (different path)",
|
||||
_ => "?",
|
||||
};
|
||||
for (r, (n, ex)) in &hist {
|
||||
println!(" {:<38} {n:>5} e.g. {ex}", label(*r));
|
||||
}
|
||||
}
|
||||
@@ -1,108 +0,0 @@
|
||||
//! RE diagnostic: emit every `weapon\Weapon_*.tbl` in a pak as machine-readable
|
||||
//! records, split at the sub-object boundaries the schema declares.
|
||||
//!
|
||||
//! An IDXD `.tbl` for a weapon holds `count` sub-records — a `Weapon` and its
|
||||
//! `Shell` — flattened into one string pool. `sylpheed-cli pak dump` shows them
|
||||
//! merged, which is ambiguous (both declare `ID`/`Name`). The title's schema
|
||||
//! name pool gives the split point: the pool contains the literal type names
|
||||
//! (`Weapon`, `Shell`), and each sub-record's fields follow its type name.
|
||||
//!
|
||||
//! Here we split on a type-name token appearing as a *key* position, so each
|
||||
//! record is emitted with its own ID and field set:
|
||||
//!
|
||||
//! ```text
|
||||
//! REC <tbl-hash> <index> <TypeName> <ID>
|
||||
//! F <key> <value>
|
||||
//! ```
|
||||
//!
|
||||
//! Run: cargo run --release -p sylpheed-formats --example idxd_tokens -- <pak> [types...]
|
||||
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
|
||||
fn is_number(s: &str) -> bool {
|
||||
let s = s.strip_suffix(['f', 'F']).unwrap_or(s);
|
||||
let t = s.strip_prefix(['-', '+']).unwrap_or(s);
|
||||
!t.is_empty() && t.chars().all(|c| c.is_ascii_digit() || c == '.')
|
||||
}
|
||||
|
||||
/// `Yes`/`No`-style scalar literals are values, not field names, even though
|
||||
/// they are identifier-shaped.
|
||||
fn is_enum_value(s: &str) -> bool {
|
||||
matches!(s, "Yes" | "No" | "YES" | "NO" | "On" | "Off" | "ON" | "OFF")
|
||||
}
|
||||
|
||||
fn is_key_like(s: &str) -> bool {
|
||||
!s.is_empty()
|
||||
&& s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
|
||||
&& s.chars().next().is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
|
||||
&& !is_number(s)
|
||||
&& !is_enum_value(s)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let pak_path = args.next().expect("usage: idxd_tokens <pak> [TypeName...]");
|
||||
let types: Vec<String> = {
|
||||
let v: Vec<String> = args.collect();
|
||||
if v.is_empty() {
|
||||
vec!["Weapon".into(), "Shell".into()]
|
||||
} else {
|
||||
v
|
||||
}
|
||||
};
|
||||
|
||||
let pak = PakArchive::open(&pak_path).expect("open pak");
|
||||
for entry in pak.entries() {
|
||||
let Ok(bytes) = pak.read(entry) else { continue };
|
||||
let Ok(obj) = IdxdObject::parse(&bytes) else { continue };
|
||||
let toks = obj.tokens();
|
||||
// Only entries that actually declare one of the requested sub-record
|
||||
// types (the pool-start heuristic can prefix one stray byte, so match a
|
||||
// short suffix rather than equality -- same rule as the splitter below).
|
||||
if !toks
|
||||
.iter()
|
||||
.any(|t| types.iter().any(|ty| t == ty || (t.ends_with(ty.as_str()) && t.len() <= ty.len() + 2)))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if std::env::var("SYLPH_RAW").is_ok() {
|
||||
println!("RAW {:08x}", entry.name_hash);
|
||||
for t in toks {
|
||||
println!("T {t}");
|
||||
}
|
||||
}
|
||||
|
||||
// Sub-record boundaries: a bare type-name token. The first one is the
|
||||
// schema's own declaration (`EnumWeapon`-style header lives in title
|
||||
// code, not here), so we take every occurrence in order.
|
||||
let mut bounds: Vec<(usize, &str)> = Vec::new();
|
||||
for (i, t) in toks.iter().enumerate() {
|
||||
// The pool-start heuristic can glue one stray binary byte onto the
|
||||
// first token ("YWeapon"), so match a short suffix, not equality.
|
||||
if let Some(ty) = types
|
||||
.iter()
|
||||
.find(|ty| t == *ty || (t.ends_with(ty.as_str()) && t.len() <= ty.len() + 2))
|
||||
{
|
||||
bounds.push((i, ty.as_str()));
|
||||
}
|
||||
}
|
||||
for (n, &(start, ty)) in bounds.iter().enumerate() {
|
||||
let end = bounds.get(n + 1).map(|b| b.0).unwrap_or(toks.len());
|
||||
let slice = &toks[start..end];
|
||||
// The record's own ID value is the token straight after its type
|
||||
// name (`Shell` -> `Shell_DSaber_P_wep_01_Beam`). The `ID`/`Name`
|
||||
// *keys* are interned once in the pool, so only the first record
|
||||
// shows them -- position-of-key lookup would miss the rest.
|
||||
let id = slice.get(1).map(|s| s.as_str()).unwrap_or("?");
|
||||
println!("REC {:08x} {n} {ty} {id}", entry.name_hash);
|
||||
for i in 1..slice.len() {
|
||||
let (k, v) = (slice[i].as_str(), slice[i - 1].as_str());
|
||||
if is_key_like(k) && (!is_key_like(v) || is_number(v)) {
|
||||
println!("F {k} {v}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,156 +0,0 @@
|
||||
//! Invert the capture↔part match: instead of asking, per ship part, "is there a
|
||||
//! draw with this vertex count?", ask of the **capture's** biggest draws "which
|
||||
//! decoded resource in this stage container has that vertex count?".
|
||||
//!
|
||||
//! This is the diagnostic for the 2026-07-31 negative result (Stage_S02 capture,
|
||||
//! zero parts correlated). It separates three hypotheses:
|
||||
//! 1. LOD/variant vcount not covered by the correlator's variant list
|
||||
//! → the big draws DO map to named resources, just not to the `_m`/`_l`/`_d`
|
||||
//! set the correlator tries;
|
||||
//! 2. position validation over-rejects
|
||||
//! → the vcounts match the very parts we asked for (so the vcount key was
|
||||
//! fine and the rejection happened later);
|
||||
//! 3. a different draw path (instanced/batched/merged buffers)
|
||||
//! → the big draws match NO resource in the container at all.
|
||||
//!
|
||||
//! Usage:
|
||||
//! SYLPHEED_ISO=... cargo run --release --example invert_capture -- \
|
||||
//! <capture.log> <Stage_SNN> [top_n] [--all]
|
||||
//! `--all` lists every capture vcount, not just the `top_n` (default 40) largest.
|
||||
|
||||
use sylpheed_formats::mesh::{xbg7_resource_names, Xbg7Model};
|
||||
use sylpheed_formats::ship_capture::{parse_capture, parse_drawlog};
|
||||
use sylpheed_formats::xiso::open_iso;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::path::Path;
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let positional: Vec<&String> = args[1..].iter().filter(|a| !a.starts_with("--")).collect();
|
||||
let all = args.iter().any(|a| a == "--all");
|
||||
if positional.len() < 2 {
|
||||
eprintln!("usage: invert_capture <capture.log> <Stage_SNN> [top_n] [--all]");
|
||||
std::process::exit(2);
|
||||
}
|
||||
let (log, stage) = (positional[0], positional[1]);
|
||||
let top_n: usize = positional.get(2).and_then(|s| s.parse().ok()).unwrap_or(40);
|
||||
let iso = std::env::var("SYLPHEED_ISO").expect("SYLPHEED_ISO");
|
||||
|
||||
let text = std::fs::read_to_string(log).expect("read log");
|
||||
let mut draws = parse_capture(&text);
|
||||
if draws.is_empty() {
|
||||
draws = parse_drawlog(&text);
|
||||
println!("parsed {} draws (draw-logger format)", draws.len());
|
||||
} else {
|
||||
println!("parsed {} draws (F10 capture format)", draws.len());
|
||||
}
|
||||
|
||||
// Decode EVERY geometry resource in the stage container, not just one ship's.
|
||||
let bytes = {
|
||||
let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
|
||||
rt.block_on(async {
|
||||
let mut r = open_iso(Path::new(&iso)).await.unwrap();
|
||||
r.read_file(&format!("hidden/resource3d/{stage}.xpr")).await.unwrap()
|
||||
})
|
||||
};
|
||||
let names = xbg7_resource_names(&bytes);
|
||||
println!("{stage}.xpr: {} XBG7 resources", names.len());
|
||||
let want: HashSet<String> = names.iter().cloned().collect();
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
println!("decoded {} models", models.len());
|
||||
|
||||
// vcount -> resource names with that many vertices.
|
||||
let mut by_vcount: HashMap<u32, Vec<String>> = HashMap::new();
|
||||
for m in &models {
|
||||
let v: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
by_vcount.entry(v as u32).or_default().push(m.name.clone());
|
||||
}
|
||||
// Per-submesh counts too: a draw may be one sub-mesh of a multi-mesh resource.
|
||||
let mut by_sub_vcount: HashMap<u32, Vec<String>> = HashMap::new();
|
||||
for m in &models {
|
||||
for (i, s) in m.meshes.iter().enumerate() {
|
||||
if m.meshes.len() > 1 {
|
||||
by_sub_vcount
|
||||
.entry(s.positions.len() as u32)
|
||||
.or_default()
|
||||
.push(format!("{}#{i}", m.name));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Capture vcounts, de-duped by (vbase, vcount) so a re-drawn part counts once
|
||||
// per distinct buffer.
|
||||
let mut draw_count: HashMap<u32, usize> = HashMap::new();
|
||||
let mut bufs: HashMap<u32, HashSet<u32>> = HashMap::new();
|
||||
for d in &draws {
|
||||
*draw_count.entry(d.vcount).or_default() += 1;
|
||||
bufs.entry(d.vcount).or_default().insert(d.vbase);
|
||||
}
|
||||
let mut vcounts: Vec<u32> = draw_count.keys().copied().collect();
|
||||
vcounts.sort_unstable_by(|a, b| b.cmp(a));
|
||||
|
||||
let matched_draws: usize = draws
|
||||
.iter()
|
||||
.filter(|d| by_vcount.contains_key(&d.vcount) || by_sub_vcount.contains_key(&d.vcount))
|
||||
.count();
|
||||
println!(
|
||||
"\n{} distinct vcounts; {}/{} draws have a vcount present in {stage}.xpr ({:.1}%)",
|
||||
vcounts.len(),
|
||||
matched_draws,
|
||||
draws.len(),
|
||||
100.0 * matched_draws as f64 / draws.len().max(1) as f64
|
||||
);
|
||||
|
||||
let shown = if all { vcounts.len() } else { top_n.min(vcounts.len()) };
|
||||
println!("\nlargest capture vcounts (draws / distinct vbufs) → matching resources:");
|
||||
for &v in vcounts.iter().take(shown) {
|
||||
let n = draw_count[&v];
|
||||
let b = bufs[&v].len();
|
||||
let mut hit: Vec<String> = by_vcount.get(&v).cloned().unwrap_or_default();
|
||||
let sub: Vec<String> = by_sub_vcount.get(&v).cloned().unwrap_or_default();
|
||||
hit.extend(sub.into_iter().map(|s| format!("{s} (sub)")));
|
||||
let label = if hit.is_empty() {
|
||||
"— no resource".to_string()
|
||||
} else {
|
||||
let mut h = hit.clone();
|
||||
h.sort();
|
||||
h.truncate(6);
|
||||
format!("{}{}", h.join(", "), if hit.len() > 6 { ", …" } else { "" })
|
||||
};
|
||||
println!(" vcount {v:6} draws {n:4} bufs {b:3} {label}");
|
||||
}
|
||||
|
||||
// `--ship <id>`: every resource of one ship family, with its vertex count and
|
||||
// whether the capture drew it — this is what shows an all-`_l` (far-LOD) frame.
|
||||
if let Some(i) = args.iter().position(|a| a == "--ship") {
|
||||
if let Some(id) = args.get(i + 1) {
|
||||
let mut rows: Vec<(String, u32, usize)> = models
|
||||
.iter()
|
||||
.filter(|m| m.name.contains(id.as_str()))
|
||||
.map(|m| {
|
||||
let v = m.meshes.iter().map(|s| s.positions.len()).sum::<usize>() as u32;
|
||||
(m.name.clone(), v, draw_count.get(&v).copied().unwrap_or(0))
|
||||
})
|
||||
.collect();
|
||||
rows.sort_by(|a, b| a.0.cmp(&b.0));
|
||||
let drawn = rows.iter().filter(|r| r.2 > 0).count();
|
||||
println!("\n{id} resources in {stage}.xpr ({drawn}/{} with a drawn vcount):", rows.len());
|
||||
for (name, v, n) in rows {
|
||||
println!(" {name:28} vcount {v:6} {}", if n > 0 { format!("DRAWN ×{n}") } else { "—".into() });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The other direction, for orientation: the container's biggest resources and
|
||||
// whether the capture ever drew that many vertices.
|
||||
let mut sizes: Vec<(u32, String)> = models
|
||||
.iter()
|
||||
.map(|m| (m.meshes.iter().map(|s| s.positions.len()).sum::<usize>() as u32, m.name.clone()))
|
||||
.collect();
|
||||
sizes.sort_unstable_by(|a, b| b.0.cmp(&a.0));
|
||||
println!("\nlargest resources in {stage}.xpr → drawn in the capture?");
|
||||
for (v, name) in sizes.iter().take(top_n.min(sizes.len())) {
|
||||
let n = draw_count.get(v).copied().unwrap_or(0);
|
||||
println!(" {name:28} vcount {v:6} {}", if n > 0 { format!("DRAWN ×{n}") } else { "not drawn".into() });
|
||||
}
|
||||
}
|
||||
@@ -1,90 +0,0 @@
|
||||
//! Where does each declared field sit inside the engine's live definition object?
|
||||
//!
|
||||
//! A live object carries no names, so the mapping has to be inferred: take a unit
|
||||
//! whose disc record SETS a field, look for that value in the dumped words of the
|
||||
//! matching live object, and keep the offsets that agree across several units.
|
||||
//!
|
||||
//! Run: live_offsets <disc-root> <live-dump.txt> <ID=0xVA> ...
|
||||
//! e.g. … UN_f106_TCAF_Destroyer=0xbd3ee300 UN_f105_TCAF_Cruiser=0xbd40e200
|
||||
use std::collections::BTreeMap;
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
|
||||
fn main() {
|
||||
let mut a = std::env::args().skip(1);
|
||||
let disc = a.next().expect("disc root");
|
||||
let dump = a.next().expect("live dump");
|
||||
let pairs: Vec<(String, String)> = a
|
||||
.filter_map(|s| s.split_once('=').map(|(i, v)| (i.to_string(), v.to_string())))
|
||||
.collect();
|
||||
|
||||
// live: va -> offset -> f32
|
||||
let mut live: BTreeMap<String, BTreeMap<usize, f32>> = BTreeMap::new();
|
||||
let mut cur = String::new();
|
||||
for line in std::fs::read_to_string(&dump).expect("dump").lines() {
|
||||
if let Some(rest) = line.strip_prefix("=== ") {
|
||||
cur = rest.trim().to_string();
|
||||
continue;
|
||||
}
|
||||
let f: Vec<&str> = line.split_whitespace().collect();
|
||||
if f.len() >= 4 && f[1].starts_with('+') {
|
||||
if let (Ok(off), Ok(val)) =
|
||||
(usize::from_str_radix(&f[1][1..], 16), f[3].parse::<f32>())
|
||||
{
|
||||
live.entry(cur.clone()).or_default().insert(off, val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let pak = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).expect("pak");
|
||||
// key -> offset -> how many units agree
|
||||
let mut votes: BTreeMap<String, BTreeMap<usize, usize>> = BTreeMap::new();
|
||||
let mut units = 0usize;
|
||||
for entry in pak.entries() {
|
||||
let Ok(bytes) = pak.read(entry) else { continue };
|
||||
let Ok(obj) = IdxdObject::parse(&bytes) else { continue };
|
||||
let Some(id) = obj.get_raw("ID") else { continue };
|
||||
let Some((_, va)) = pairs.iter().find(|(i, _)| i == id) else { continue };
|
||||
let Some(words) = live.get(va) else { continue };
|
||||
units += 1;
|
||||
let mut numeric = 0usize;
|
||||
let mut hit = 0usize;
|
||||
for key in obj.tokens() {
|
||||
let Some(v) = obj.get_f32(key) else { continue };
|
||||
if !v.is_finite() || v == 0.0 {
|
||||
continue; // zero matches everywhere and says nothing
|
||||
}
|
||||
numeric += 1;
|
||||
let mut found = false;
|
||||
for (off, w) in words {
|
||||
if (*w - v).abs() <= v.abs() * 1e-6 {
|
||||
*votes.entry(key.clone()).or_default().entry(*off).or_default() += 1;
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
if found {
|
||||
hit += 1;
|
||||
}
|
||||
}
|
||||
eprintln!(" {id}: {numeric} numeric fields set on disc, {hit} found in the dumped window");
|
||||
}
|
||||
println!("{units} units correlated against their live objects\n");
|
||||
println!("{:<28} {:>8} offsets agreeing (votes)", "field", "unique?");
|
||||
for (key, offs) in &votes {
|
||||
let best = offs.iter().max_by_key(|(_, n)| **n).unwrap();
|
||||
if *best.1 < units.max(2) {
|
||||
continue; // needs every correlated unit to agree
|
||||
}
|
||||
let list: Vec<String> = offs
|
||||
.iter()
|
||||
.filter(|(_, n)| **n == *best.1)
|
||||
.map(|(o, n)| format!("+{o:03x}×{n}"))
|
||||
.collect();
|
||||
println!(
|
||||
"{:<28} {:>8} {}",
|
||||
key,
|
||||
if list.len() == 1 { "unique" } else { "ambig" },
|
||||
list.join(" ")
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
//! How many copies of a captured buffer does a container hold?
|
||||
//!
|
||||
//! The twins showed that two resources decoding to one buffer can mean the
|
||||
//! container really holds two (mirrored) copies and our scan found only one.
|
||||
//! This asks that question for any draw: give it a `vbase`, and it reports every
|
||||
//! offset whose leading vertices match the draw's dumped positions — directly, and
|
||||
//! X-mirrored.
|
||||
//!
|
||||
//! Usage: locate_draw <container.xpr> <capture.log> <vbase-hex>...
|
||||
use sylpheed_formats::ship_capture::{parse_capture, parse_drawlog};
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).expect("container");
|
||||
let text = std::fs::read_to_string(&a[2]).expect("log");
|
||||
let mut draws = parse_capture(&text);
|
||||
if draws.is_empty() {
|
||||
draws = parse_drawlog(&text);
|
||||
}
|
||||
let be = |at: usize| f32::from_be_bytes(bytes[at..at + 4].try_into().unwrap());
|
||||
|
||||
for want in &a[3..] {
|
||||
let vb = u32::from_str_radix(want.trim_start_matches("0x"), 16).expect("hex vbase");
|
||||
let Some(d) = draws.iter().find(|d| d.vbase == vb) else {
|
||||
println!("vbase 0x{vb:08X}: not in this log");
|
||||
continue;
|
||||
};
|
||||
let n = d.pos.len().min(8);
|
||||
let mut direct = Vec::new();
|
||||
let mut mirror = Vec::new();
|
||||
for o in (0..bytes.len().saturating_sub(12 + 64 * 24)).step_by(4) {
|
||||
for (flip, out) in [(1.0f32, &mut direct), (-1.0f32, &mut mirror)] {
|
||||
let hit = (0..n).all(|k| {
|
||||
let at = o + k * 24;
|
||||
(be(at) - flip * d.pos[k][0]).abs() <= 1e-4
|
||||
&& (be(at + 4) - d.pos[k][1]).abs() <= 1e-4
|
||||
&& (be(at + 8) - d.pos[k][2]).abs() <= 1e-4
|
||||
});
|
||||
if hit {
|
||||
out.push(o);
|
||||
}
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"vbase 0x{vb:08X} vcount={}: {} direct copy/copies {:x?}, {} mirrored {:x?}",
|
||||
d.vcount,
|
||||
direct.len(),
|
||||
&direct[..],
|
||||
mirror.len(),
|
||||
&mirror[..]
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
//! Dump a composite's scene nodes with their scale — the transform the static
|
||||
//! assembler copies verbatim into a placement.
|
||||
//! Usage: node_scale <container.xpr> <composite name>
|
||||
use sylpheed_formats::mesh::scene_world_nodes;
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).expect("container");
|
||||
for n in scene_world_nodes(&bytes, &a[2]) {
|
||||
// Row norms of `m`: a rotation has all three at 1.0; anything else is a
|
||||
// scale baked into the matrix, which `s` does not show.
|
||||
let norm = |r: [f32; 3]| (r[0] * r[0] + r[1] * r[1] + r[2] * r[2]).sqrt();
|
||||
println!(
|
||||
"{:<26} s[{:7.3}{:7.3}{:7.3}] |m rows|[{:7.3}{:7.3}{:7.3}] t[{:9.1}{:9.1}{:9.1}]",
|
||||
n.resource,
|
||||
n.s[0], n.s[1], n.s[2],
|
||||
norm(n.m[0]), norm(n.m[1]), norm(n.m[2]),
|
||||
n.t[0], n.t[1], n.t[2]
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
//! Raw token sequence around a key, for one record — the ground truth for
|
||||
//! "is this field actually defaulted, or is our reader missing it?"
|
||||
//! Run: pool_window <disc-root> <ID substring> <key>
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
fn main() {
|
||||
let disc = std::env::args().nth(1).unwrap();
|
||||
let want = std::env::args().nth(2).unwrap();
|
||||
let key = std::env::args().nth(3).unwrap();
|
||||
let pak = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
let Some(id) = o.get_raw("ID") else { continue };
|
||||
if !id.contains(&want) { continue; }
|
||||
let t = o.tokens();
|
||||
println!("=== {id} get_f32({key}) = {:?}", o.get_f32(&key));
|
||||
for (i, tok) in t.iter().enumerate() {
|
||||
if tok == &key {
|
||||
let lo = i.saturating_sub(6);
|
||||
let hi = (i + 7).min(t.len());
|
||||
for j in lo..hi {
|
||||
println!(" [{j}]{} {:?}", if j == i { " <-- key" } else { " " }, t[j]);
|
||||
}
|
||||
println!();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
118
crates/sylpheed-formats/examples/rat_inspect.rs
Normal file
118
crates/sylpheed-formats/examples/rat_inspect.rs
Normal file
@@ -0,0 +1,118 @@
|
||||
//! Scratch: confirm the `.rat` layout record offsets against a real screen pak.
|
||||
//! Run: cargo run -p sylpheed-formats --example rat_inspect -- <GP_SCREEN.pak>
|
||||
use sylpheed_formats::{pak::PakArchive, ratc, t8ad};
|
||||
|
||||
fn be32(b: &[u8], o: usize) -> u32 {
|
||||
u32::from_be_bytes([b[o], b[o + 1], b[o + 2], b[o + 3]])
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let path = std::env::args().nth(1).expect("pak path");
|
||||
let ar = PakArchive::open(&path).expect("open pak");
|
||||
println!("entries: {}", ar.len());
|
||||
|
||||
let mut decoded: Vec<Vec<u8>> = Vec::new();
|
||||
for (i, e) in ar.entries().iter().enumerate() {
|
||||
let d = ar.read(e).unwrap_or_default();
|
||||
let magic = String::from_utf8_lossy(&d[..4.min(d.len())]).to_string();
|
||||
let (nt, nr) = if ratc::is_ratc(&d) {
|
||||
let k = ratc::parse(&d).unwrap_or_default();
|
||||
(
|
||||
k.iter().filter(|c| c.kind == "T8aD").count(),
|
||||
k.iter()
|
||||
.filter(|c| c.name.to_lowercase().ends_with(".rat"))
|
||||
.count(),
|
||||
)
|
||||
} else {
|
||||
(0, 0)
|
||||
};
|
||||
println!(
|
||||
" entry[{:2}] {:>8} B magic={:4} t32={:2} rat={:2}",
|
||||
i,
|
||||
d.len(),
|
||||
magic,
|
||||
nt,
|
||||
nr
|
||||
);
|
||||
decoded.push(d);
|
||||
}
|
||||
// Pick the entry with the most children as "build0".
|
||||
let bi = (0..decoded.len())
|
||||
.filter(|&i| ratc::is_ratc(&decoded[i]))
|
||||
.max_by_key(|&i| ratc::parse(&decoded[i]).map(|k| k.len()).unwrap_or(0))
|
||||
.unwrap();
|
||||
println!("=> inspecting richest build: entry[{}]", bi);
|
||||
let bundle = &decoded[bi];
|
||||
let kids = ratc::parse(bundle).unwrap_or_default();
|
||||
let t32: Vec<_> = kids.iter().filter(|c| c.kind == "T8aD").collect();
|
||||
let rat: Vec<_> = kids
|
||||
.iter()
|
||||
.filter(|c| c.name.to_lowercase().ends_with(".rat"))
|
||||
.collect();
|
||||
println!(
|
||||
"build0: {} children, {} t32 sprites, {} rat records",
|
||||
kids.len(),
|
||||
t32.len(),
|
||||
rat.len()
|
||||
);
|
||||
for c in t32.iter().take(5) {
|
||||
let b = &bundle[c.offset..(c.offset + c.size).min(bundle.len())];
|
||||
if let Some(img) = t8ad::parse(b) {
|
||||
println!(" T8aD {:28} {}x{}", c.name, img.width, img.height);
|
||||
}
|
||||
}
|
||||
println!(" -- .rat records --");
|
||||
for c in rat.iter().take(10) {
|
||||
let r = &bundle[c.offset..(c.offset + c.size).min(bundle.len())];
|
||||
if r.len() < 0x60 {
|
||||
println!(" .rat {:20} (len {}, too short)", c.name, r.len());
|
||||
continue;
|
||||
}
|
||||
let (dw, dh) = (be32(r, 0x18), be32(r, 0x1c));
|
||||
let sprite = {
|
||||
let s = &r[0x20..0x30.min(r.len())];
|
||||
let end = s.iter().position(|&b| b == 0).unwrap_or(s.len());
|
||||
String::from_utf8_lossy(&s[..end]).to_string()
|
||||
};
|
||||
let (pvx, pvy) = (be32(r, 0x50), be32(r, 0x54));
|
||||
// scan for placement block [scaleX=100, scaleY=100, tint, X<dw, Y<dh]
|
||||
let mut placement = None;
|
||||
let mut o = 0x58;
|
||||
while o + 20 <= r.len() {
|
||||
if be32(r, o) == 100 && be32(r, o + 4) == 100 {
|
||||
let (tint, x, y) = (be32(r, o + 8), be32(r, o + 12), be32(r, o + 16));
|
||||
if x < dw && y < dh {
|
||||
placement = Some((o, tint, x, y));
|
||||
break;
|
||||
}
|
||||
}
|
||||
o += 4;
|
||||
}
|
||||
println!(
|
||||
" .rat {:22} {}x{} sprite={:16} pivot=({},{}) place={:x?}",
|
||||
c.name, dw, dh, sprite, pvx, pvy, placement
|
||||
);
|
||||
}
|
||||
|
||||
// End-to-end: composite the build and write it out as a PNG.
|
||||
if let Some(screen) = sylpheed_formats::ui_layout::compose_build(bundle, false) {
|
||||
println!(
|
||||
"compose: {}x{}, drew {} records: {:?}",
|
||||
screen.width,
|
||||
screen.height,
|
||||
screen.drawn.len(),
|
||||
screen.drawn
|
||||
);
|
||||
if let Some(out) = std::env::args().nth(2) {
|
||||
// Dependency-free PPM (P6, RGB — alpha already composited over the backdrop).
|
||||
let mut buf = format!("P6\n{} {}\n255\n", screen.width, screen.height).into_bytes();
|
||||
for px in screen.rgba.chunks_exact(4) {
|
||||
buf.extend_from_slice(&px[..3]);
|
||||
}
|
||||
std::fs::write(&out, buf).unwrap();
|
||||
println!("wrote {out}");
|
||||
}
|
||||
} else {
|
||||
println!("compose: build produced no image");
|
||||
}
|
||||
}
|
||||
@@ -1,111 +0,0 @@
|
||||
//! Dump a UI screen's full layout from one RATC bundle: the element declaration
|
||||
//! table (what is drawn, in back-to-front order, with pivots and parent links)
|
||||
//! plus the placement region that follows it (per element: a keyframe group of
|
||||
//! scale / tint / X / Y).
|
||||
//!
|
||||
//! See docs/re/structures/ui-rat-layout.md. Run:
|
||||
//! cargo run -p sylpheed-formats --example screen_layout -- <PAK> [0xHASH]
|
||||
//! With no hash, the largest RATC entry in the pak is used.
|
||||
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
|
||||
fn be32(b: &[u8], o: usize) -> u32 {
|
||||
u32::from_be_bytes([b[o], b[o + 1], b[o + 2], b[o + 3]])
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let pak = args.next().expect("usage: screen_layout <pak> [0xHASH]");
|
||||
let want = args.next();
|
||||
let arc = PakArchive::open(&pak).expect("open pak");
|
||||
|
||||
let bytes = match want {
|
||||
Some(h) if h.starts_with("0x") => {
|
||||
let h = u32::from_str_radix(h.trim_start_matches("0x"), 16).expect("hash");
|
||||
arc.read_by_hash(h).expect("entry").expect("decompress")
|
||||
}
|
||||
Some(name) => arc.read_by_name(&name).expect("entry present").expect("decompress"),
|
||||
None => arc
|
||||
.entries()
|
||||
.iter()
|
||||
.filter_map(|e| arc.read(e).ok())
|
||||
.filter(|b| b.len() > 16 && &b[..4] == b"RATC")
|
||||
.max_by_key(|b| b.len())
|
||||
.expect("no RATC entry"),
|
||||
};
|
||||
assert_eq!(&bytes[..4], b"RATC", "not a RATC bundle");
|
||||
|
||||
let count = be32(&bytes, 0x14) as usize;
|
||||
let mut names = Vec::with_capacity(count);
|
||||
let mut meta = Vec::with_capacity(count);
|
||||
for i in 0..count {
|
||||
let e = &bytes[0x20 + i * 60..0x20 + (i + 1) * 60];
|
||||
let name = String::from_utf8_lossy(&e[..28])
|
||||
.trim_end_matches('\0')
|
||||
.trim_end_matches(char::from(0))
|
||||
.to_string();
|
||||
let parent = be32(e, 32);
|
||||
let kind = be32(e, 40);
|
||||
let (px, py) = (be32(e, 48), be32(e, 52));
|
||||
names.push(name);
|
||||
meta.push((parent, kind, px, py));
|
||||
}
|
||||
|
||||
// Placement region: groups of (u32 element index, u32 keyframe count) then
|
||||
// `count` 40-byte keyframes; the X/Y sit 12 bytes into the scale/tint block.
|
||||
let mut pos = 0x20 + count * 60;
|
||||
// X/Y are SIGNED: off-screen animation starts are negative (e.g. -516).
|
||||
let mut placements: Vec<Vec<(i32, i32, u32)>> = vec![Vec::new(); count];
|
||||
for _ in 0..count {
|
||||
if pos + 8 > bytes.len() { break }
|
||||
let idx = be32(&bytes, pos) as usize;
|
||||
let frames = be32(&bytes, pos + 4) as usize;
|
||||
if idx >= count || frames == 0 || frames > 4096 { break }
|
||||
let first = pos + 28; // header + lead-in, verified on the pause bundles
|
||||
let mut group = Vec::with_capacity(frames);
|
||||
for k in 0..frames {
|
||||
let blk = first + k * 40;
|
||||
if blk + 20 > bytes.len() { break }
|
||||
group.push((be32(&bytes, blk + 12) as i32, be32(&bytes, blk + 16) as i32, be32(&bytes, blk + 20)));
|
||||
}
|
||||
placements[idx] = group;
|
||||
pos = first + frames * 40 - 20;
|
||||
}
|
||||
|
||||
println!("{} elements", count);
|
||||
println!("{:<3} {:<30} {:>7} {:>8} {:>12} {:>4} placement", "#", "element", "parent", "kind", "pivot", "kf");
|
||||
for i in 0..count {
|
||||
let (parent, kind, px, py) = meta[i];
|
||||
let p = &placements[i];
|
||||
// A group is an in → hold → out animation, so neither the first nor the
|
||||
// last keyframe is where the element sits: report the MAX-DWELL one
|
||||
// (longest gap to the next keyframe's time).
|
||||
let shown = if p.is_empty() {
|
||||
"—".into()
|
||||
} else if p.len() == 1 {
|
||||
format!("({},{})", p[0].0, p[0].1)
|
||||
} else {
|
||||
let mut best = (0usize, 0u32);
|
||||
for k in 0..p.len() - 1 {
|
||||
let d = p[k + 1].2.saturating_sub(p[k].2);
|
||||
if d > best.1 { best = (k, d) }
|
||||
}
|
||||
let r = p[best.0];
|
||||
format!(
|
||||
"rest ({},{}) t={}..{} [{}]",
|
||||
r.0, r.1, r.2, p[best.0 + 1].2,
|
||||
p.iter().map(|(x, y, t)| format!("{t}:{x},{y}")).collect::<Vec<_>>().join(" ")
|
||||
)
|
||||
};
|
||||
println!(
|
||||
"{:<3} {:<30} {:>7} {:>8} {:>12} {:>4} {}",
|
||||
i,
|
||||
names[i],
|
||||
if parent == u32::MAX { "-".into() } else { parent.to_string() },
|
||||
format!("{kind:#x}"),
|
||||
format!("({px},{py})"),
|
||||
p.len(),
|
||||
shown
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,262 +0,0 @@
|
||||
//! Ask the runtime capture whether two resources that our decoder gives the
|
||||
//! **same geometry** really are the same geometry.
|
||||
//!
|
||||
//! Our XBG7 anchor scan sometimes lands two different resource names on one
|
||||
//! vertex buffer. Statics cannot separate "the container genuinely reuses a
|
||||
//! buffer" from "the scan picked the wrong candidate" — but a capture can: the
|
||||
//! engine uploads a buffer per resource and reuses one only 3.4 % of the time
|
||||
//! (see docs/re/structures/xbg7-mesh.md), so a group of `k` resources our
|
||||
//! decoder collapses onto one buffer should show up as `k` distinct `vbase`s
|
||||
//! carrying that same vertex count and those same positions. Fewer means at
|
||||
//! most one member of the group is really that geometry.
|
||||
//!
|
||||
//! Usage:
|
||||
//! cargo run --release --example shared_vbase_check -- \
|
||||
//! <Stage_SNN.xpr> <capture.log>...
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use sylpheed_formats::ship_capture::{parse_capture, parse_drawlog, CapturedDraw};
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
/// Quantised position key — the logs print 4 decimals, so compare at that scale.
|
||||
fn key(p: [f32; 3]) -> (i64, i64, i64) {
|
||||
(
|
||||
(p[0] as f64 * 1e4).round() as i64,
|
||||
(p[1] as f64 * 1e4).round() as i64,
|
||||
(p[2] as f64 * 1e4).round() as i64,
|
||||
)
|
||||
}
|
||||
|
||||
/// Where in the container does a captured buffer live? POSITION is `f32×3` big
|
||||
/// endian at vertex offset 0, so a draw's dumped positions are a literal byte
|
||||
/// pattern: find the first one, then confirm the next few at a fixed stride.
|
||||
/// This turns a capture into ground truth for a resource we mis-anchored.
|
||||
fn locate_run(bytes: &[u8], pos: &[[f32; 3]]) -> Vec<(usize, usize)> {
|
||||
if pos.len() < 4 {
|
||||
return Vec::new();
|
||||
}
|
||||
// The log prints 4 decimals, so match on value with the printing tolerance
|
||||
// rather than on bytes.
|
||||
let be = |b: &[u8], at: usize| f32::from_be_bytes(b[at..at + 4].try_into().unwrap());
|
||||
let same = |b: &[u8], at: usize, p: [f32; 3]| {
|
||||
at + 12 <= b.len() && (0..3).all(|c| (be(b, at + c * 4) - p[c]).abs() <= 1e-4)
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
for o in (0..bytes.len().saturating_sub(12)).step_by(4) {
|
||||
if !same(bytes, o, pos[0]) {
|
||||
continue;
|
||||
}
|
||||
for stride in (12..=64).step_by(4) {
|
||||
if (1..4).all(|k| same(bytes, o + k * stride, pos[k])) {
|
||||
out.push((o, stride));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
if args.len() < 3 {
|
||||
eprintln!("usage: shared_vbase_check <Stage_SNN.xpr> <capture.log>...");
|
||||
std::process::exit(2);
|
||||
}
|
||||
let bytes = std::fs::read(&args[1]).expect("read container");
|
||||
|
||||
// Every draw from every log, keyed by vertex count.
|
||||
// Keep the logs apart: each is its own emulator run, so a `vbase` only
|
||||
// means something within one log.
|
||||
let mut logs: Vec<(String, Vec<CapturedDraw>)> = Vec::new();
|
||||
for log in args[2..].iter().filter(|a| !a.starts_with("--")) {
|
||||
let text = std::fs::read_to_string(log).expect("read log");
|
||||
let mut d = parse_capture(&text);
|
||||
if d.is_empty() {
|
||||
d = parse_drawlog(&text);
|
||||
}
|
||||
eprintln!("{log}: {} draws", d.len());
|
||||
logs.push((log.rsplit('/').next().unwrap_or(log).to_string(), d));
|
||||
}
|
||||
|
||||
// `--map`: is a draw's guest `vbase` just the container file offset plus a
|
||||
// constant? If the container is uploaded contiguously it is — and then a
|
||||
// capture names the exact offset of every buffer the engine drew, which is
|
||||
// ground truth the anchor scan currently has to guess at.
|
||||
if args.iter().any(|a| a == "--map") {
|
||||
for (log, draws) in &logs {
|
||||
let mut seen: BTreeSet<u32> = BTreeSet::new();
|
||||
let mut delta: BTreeMap<i64, usize> = BTreeMap::new();
|
||||
let mut unfound = 0usize;
|
||||
for d in draws {
|
||||
if d.pos.len() < 8 || d.vcount < 20 || !seen.insert(d.vbase) {
|
||||
continue;
|
||||
}
|
||||
let at = locate_run(&bytes, &d.pos);
|
||||
if at.is_empty() {
|
||||
unfound += 1;
|
||||
continue;
|
||||
}
|
||||
for (o, _) in at {
|
||||
*delta.entry(d.vbase as i64 - o as i64).or_default() += 1;
|
||||
}
|
||||
}
|
||||
let mut top: Vec<_> = delta.iter().collect();
|
||||
top.sort_by_key(|(_, n)| std::cmp::Reverse(**n));
|
||||
println!("{log}: {} distinct vbases located, {unfound} not in this container", seen.len() - unfound);
|
||||
for (d, n) in top.iter().take(5) {
|
||||
println!(" vbase - offset = 0x{:X} ×{n}", d);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Decode the container and group resources by the exact geometry they got.
|
||||
let models = Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false);
|
||||
|
||||
// `--truth <base>`: with the container's guest load address (from `--map`),
|
||||
// every draw names a file offset. Print it against the offset our anchor
|
||||
// scan chose for each resource — a direct read-out of what we got wrong.
|
||||
if let Some(a) = args.iter().find_map(|a| a.strip_prefix("--truth=")) {
|
||||
let base = u32::from_str_radix(a.trim_start_matches("0x"), 16).expect("base");
|
||||
// Where the anchor scan actually put each sub-mesh — exact, from the
|
||||
// decoder, not inferred by searching for its leading vertices (the same
|
||||
// leading run occurs at several offsets in a container, so a search
|
||||
// cannot tell where a resource was anchored).
|
||||
let mut ours: BTreeMap<usize, Vec<(String, usize)>> = BTreeMap::new();
|
||||
for m in &models {
|
||||
for sub in &m.meshes {
|
||||
if let Some(o) = sub.vbuf_offset {
|
||||
ours.entry(o).or_default().push((m.name.clone(), sub.positions.len()));
|
||||
}
|
||||
}
|
||||
}
|
||||
if args.iter().any(|a| a == "--anchors") {
|
||||
println!("{:<12} where our decode put each resource", "file offset");
|
||||
for (o, v) in &ours {
|
||||
for (n, c) in v {
|
||||
println!("0x{o:<10x} {n} ({c} verts)");
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
let mut drawn: BTreeMap<usize, u32> = BTreeMap::new();
|
||||
for (_, draws) in &logs {
|
||||
for d in draws {
|
||||
let off = d.vbase.wrapping_sub(base) as usize;
|
||||
if off < bytes.len() && d.vcount >= 20 {
|
||||
drawn.insert(off, d.vcount);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Which resources have the drawn vertex count, wherever we put them?
|
||||
// Right size + wrong place is a different bug from never finding it.
|
||||
let mut by_count: BTreeMap<usize, Vec<String>> = BTreeMap::new();
|
||||
for m in &models {
|
||||
let n: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
by_count.entry(n).or_default().push(m.name.clone());
|
||||
}
|
||||
// Is a capture-proven offset even a candidate the scan considers?
|
||||
// Absent ⇒ the run scan misses it; present ⇒ selection picked another.
|
||||
let starts: BTreeSet<usize> =
|
||||
sylpheed_formats::mesh::debug_vertex_run_starts(&bytes, 24).into_iter().collect();
|
||||
eprintln!("{} stride-24 candidate starts in this container", starts.len());
|
||||
println!("{:<12} {:>7} {:>9} {:<44} our resources with that vcount", "file offset", "vcount", "candidate", "claimed by our decode");
|
||||
for (off, vcount) in &drawn {
|
||||
let who = ours
|
||||
.get(off)
|
||||
.map(|v| {
|
||||
v.iter().map(|(n, c)| format!("{n}({c})")).collect::<Vec<_>>().join(", ")
|
||||
})
|
||||
.unwrap_or_else(|| "— NOBODY".into());
|
||||
let same = by_count
|
||||
.get(&(*vcount as usize))
|
||||
.map(|v| v.join(", "))
|
||||
.unwrap_or_else(|| "— none".into());
|
||||
// Nearest resource we anchored at or before this offset — the
|
||||
// likely owner of a buffer nobody claims.
|
||||
let near = ours
|
||||
.range(..=*off)
|
||||
.next_back()
|
||||
.map(|(o, v)| format!("{} @ -0x{:x}", v[0].0, off - o))
|
||||
.unwrap_or_default();
|
||||
let cand = if starts.contains(off) { "yes" } else { "NO" };
|
||||
println!("0x{off:<10x} {vcount:>7} {cand:>9} {who:<44} {same:<34} {near}");
|
||||
}
|
||||
return;
|
||||
}
|
||||
let mut groups: BTreeMap<Vec<(i64, i64, i64)>, Vec<String>> = BTreeMap::new();
|
||||
for m in &models {
|
||||
let pos: Vec<(i64, i64, i64)> =
|
||||
m.meshes.iter().flat_map(|s| s.positions.iter().copied()).map(key).collect();
|
||||
if pos.is_empty() {
|
||||
continue;
|
||||
}
|
||||
groups.entry(pos).or_default().push(m.name.clone());
|
||||
}
|
||||
let shared: Vec<_> = groups.iter().filter(|(_, n)| n.len() > 1).collect();
|
||||
eprintln!(
|
||||
"{} models, {} distinct geometries, {} shared by >1 resource",
|
||||
models.len(),
|
||||
groups.len(),
|
||||
shared.len()
|
||||
);
|
||||
|
||||
for (pos, names) in shared {
|
||||
let vcount = pos.len() as u32;
|
||||
// A draw belongs to this geometry if every dumped position is one of
|
||||
// the decoded ones (the log dumps at most the first 64).
|
||||
let want: BTreeSet<(i64, i64, i64)> = pos.iter().copied().collect();
|
||||
println!("\n{} ({vcount} verts, {} resources)", names.join(" ≡ "), names.len());
|
||||
for (log, draws) in &logs {
|
||||
let hits: Vec<&CapturedDraw> = draws.iter().filter(|d| d.vcount == vcount).collect();
|
||||
let all: BTreeSet<u32> = hits.iter().map(|d| d.vbase).collect();
|
||||
let matching: Vec<&&CapturedDraw> = hits
|
||||
.iter()
|
||||
.filter(|d| !d.pos.is_empty() && d.pos.iter().all(|p| want.contains(&key(*p))))
|
||||
.collect();
|
||||
let ok: BTreeSet<u32> = matching.iter().map(|d| d.vbase).collect();
|
||||
// A buffer we do NOT match may still be the mirrored twin: same
|
||||
// geometry with x negated. That is the case our assembler papers
|
||||
// over with `apply_twin_mirrors`.
|
||||
let mirrored: BTreeSet<u32> = hits
|
||||
.iter()
|
||||
.filter(|d| !ok.contains(&d.vbase))
|
||||
.filter(|d| {
|
||||
!d.pos.is_empty()
|
||||
&& d.pos.iter().all(|p| want.contains(&key([-p[0], p[1], p[2]])))
|
||||
})
|
||||
.map(|d| d.vbase)
|
||||
.collect();
|
||||
println!(
|
||||
" {log:32} draws={:<5} vbases@vcount={:<3} ours={} mirrored={} other={}",
|
||||
hits.len(),
|
||||
all.len(),
|
||||
ok.len(),
|
||||
mirrored.len(),
|
||||
all.len() - ok.len() - mirrored.len()
|
||||
);
|
||||
// Where does each captured buffer live in the container? One
|
||||
// representative draw per vbase is enough.
|
||||
let mut done: BTreeSet<u32> = BTreeSet::new();
|
||||
for d in &hits {
|
||||
if d.pos.len() < 8 || !done.insert(d.vbase) {
|
||||
continue;
|
||||
}
|
||||
let kind = if ok.contains(&d.vbase) {
|
||||
"ours"
|
||||
} else if mirrored.contains(&d.vbase) {
|
||||
"mirror"
|
||||
} else {
|
||||
"other"
|
||||
};
|
||||
let at = locate_run(&bytes, &d.pos);
|
||||
let shown: Vec<String> =
|
||||
at.iter().take(4).map(|(o, s)| format!("0x{o:x}/stride{s}")).collect();
|
||||
println!(
|
||||
" vbase=0x{:08X} [{kind:6}] in container at: {}",
|
||||
d.vbase,
|
||||
if shown.is_empty() { "NOT FOUND".into() } else { shown.join(" ") }
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
//! Screen every ship family for a part that is wildly out of scale with its
|
||||
//! siblings — the "slab" signature of a mis-anchored block.
|
||||
//!
|
||||
//! Rendering `e106` found such a part (`bdy_03`, 600×1600×998 beside parts of
|
||||
//! ~250) that coverage, cross-container consistency, the capture oracle and the
|
||||
//! twin invariant were all blind to. Eyeballing does not scale to 166 containers;
|
||||
//! this does the same comparison numerically.
|
||||
//!
|
||||
//! Usage: slab_screen <resource3d_dir> [factor]
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use sylpheed_formats::ship::{is_base_part, ship_id_of};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let factor: f32 = std::env::args().nth(2).and_then(|s| s.parse().ok()).unwrap_or(4.0);
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
let mut flagged = 0usize;
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let mut by_ship: BTreeMap<String, Vec<(String, f32)>> = BTreeMap::new();
|
||||
for m in Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false) {
|
||||
if !is_base_part(&m.name) {
|
||||
continue;
|
||||
}
|
||||
let Some(id) = ship_id_of(&m.name) else { continue };
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for s in &m.meshes {
|
||||
for q in &s.positions {
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(q[k]);
|
||||
hi[k] = hi[k].max(q[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if lo[0] == f32::MAX {
|
||||
continue;
|
||||
}
|
||||
// Compare the part's SMALLEST axis span, not its diagonal. A long
|
||||
// thin part (an antenna, a 100 000-unit tether on `f002`) is
|
||||
// legitimately huge in one axis and would swamp a diagonal test; a
|
||||
// mis-anchored block is bulky in all three, which is what the e106
|
||||
// slab looked like (600×1600×998 beside siblings of ~250).
|
||||
let thin = (hi[0] - lo[0]).min(hi[1] - lo[1]).min(hi[2] - lo[2]);
|
||||
by_ship.entry(id.to_string()).or_default().push((m.name.clone(), thin));
|
||||
}
|
||||
for (id, parts) in &by_ship {
|
||||
if parts.len() < 3 {
|
||||
continue; // no meaningful median
|
||||
}
|
||||
let mut d: Vec<f32> = parts.iter().map(|(_, x)| *x).collect();
|
||||
d.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
let median = d[d.len() / 2];
|
||||
for (name, diag) in parts {
|
||||
if *diag > median * factor {
|
||||
flagged += 1;
|
||||
println!(
|
||||
"{:<22} {name:<22} min-axis {diag:>8.0} vs ship median {median:>8.0} ({:.1}×)",
|
||||
f.file_name().unwrap().to_string_lossy(),
|
||||
diag / median
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("{flagged} parts flagged at {factor}× the ship median");
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
use sylpheed_formats::mesh::{debug_resource_params, debug_vertex_run_starts};
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).unwrap();
|
||||
let (markers, stride) = debug_resource_params(&bytes, &a[2]).expect("resource");
|
||||
println!("{}: stride={stride} markers={markers:?}", a[2]);
|
||||
let starts = debug_vertex_run_starts(&bytes, stride);
|
||||
println!("{} candidate starts at stride {stride}", starts.len());
|
||||
for off in &a[3..] {
|
||||
let o = usize::from_str_radix(off.trim_start_matches("0x"), 16).unwrap();
|
||||
println!(" 0x{o:x} in candidate list: {}", starts.binary_search(&o).is_ok());
|
||||
}
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
//! Per-sub-mesh vertex/index/coverage dump for one resource.
|
||||
//! Usage: submesh_dump <container.xpr> <resource>...
|
||||
use sylpheed_formats::mesh::{debug_resource_params, Xbg7Model};
|
||||
use std::collections::HashSet;
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).expect("container");
|
||||
let want: HashSet<String> = a[2..].iter().cloned().collect();
|
||||
for m in Xbg7Model::models_named(&bytes, &want, &|| false) {
|
||||
let markers = debug_resource_params(&bytes, &m.name).map(|(mk, _)| mk).unwrap_or_default();
|
||||
println!("{} — {} sub-meshes decoded, {} markers declared", m.name, m.meshes.len(), markers.len());
|
||||
for (i, s) in m.meshes.iter().enumerate() {
|
||||
let max_idx = s.indices.iter().max().copied().unwrap_or(0) as usize;
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for q in &s.positions {
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(q[k]);
|
||||
hi[k] = hi[k].max(q[k]);
|
||||
}
|
||||
}
|
||||
println!(
|
||||
" #{i:<2} at 0x{:<9x} verts {:<6} idx {:<6} max_idx {:<6} slack {} span [{:.0} {:.0} {:.0}]",
|
||||
s.vbuf_offset.unwrap_or(0),
|
||||
s.positions.len(),
|
||||
s.indices.len(),
|
||||
max_idx,
|
||||
s.positions.len() as i64 - 1 - max_idx as i64,
|
||||
hi[0] - lo[0],
|
||||
hi[1] - lo[1],
|
||||
hi[2] - lo[2]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
//! Does the capture-proven offset validate for the resource that should own it?
|
||||
use sylpheed_formats::mesh::debug_try_anchor;
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).unwrap();
|
||||
// The production scan tries pads 0..=3; pass a bigger one to ask whether the
|
||||
// block would validate at all with a wider index/vertex gap.
|
||||
let max_pad: usize = std::env::var("MAX_PAD").ok().and_then(|v| v.parse().ok()).unwrap_or(3);
|
||||
for pair in a[2..].iter() {
|
||||
let (name, off) = pair.split_once('@').unwrap();
|
||||
let off = usize::from_str_radix(off.trim_start_matches("0x"), 16).unwrap();
|
||||
match debug_try_anchor(&bytes, name, off, max_pad) {
|
||||
Some((v, i, pad)) => println!("{name:22} @ 0x{off:x} ACCEPTED v={v} idx={i} pad={pad}"),
|
||||
None => println!("{name:22} @ 0x{off:x} rejected"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,119 +0,0 @@
|
||||
//! Do port/starboard twins decode to mirror images of each other?
|
||||
//!
|
||||
//! A runtime capture proved the container stores both halves of the `e106` hull
|
||||
//! as separate, X-reflected buffers. That gives a **capture-free invariant**:
|
||||
//! a `…_01`/`…_02` pair of equal vertex count should decode to geometry that is
|
||||
//! an exact X-mirror — never to identical geometry (that is the collapse the
|
||||
//! distinct-assignment fix targets), and never to something unrelated (that is a
|
||||
//! mis-anchor no count-based metric can see).
|
||||
//!
|
||||
//! Usage: twin_mirror_audit <resource3d_dir>
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
fn key(p: [f32; 3]) -> (i64, i64, i64) {
|
||||
(
|
||||
(p[0] * 1e3).round() as i64,
|
||||
(p[1] * 1e3).round() as i64,
|
||||
(p[2] * 1e3).round() as i64,
|
||||
)
|
||||
}
|
||||
|
||||
/// Elementwise equality with a tolerance. Truncating keys is too strict for a
|
||||
/// mirrored pair: the halves are authored, not bit-negated, so they differ in
|
||||
/// the last digits and an exact key test reports them as unrelated.
|
||||
fn near(p: [f32; 3], q: [f32; 3]) -> bool {
|
||||
(0..3).all(|c| (p[c] - q[c]).abs() <= 1e-3 * (1.0 + q[c].abs()))
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
let (mut same, mut mirrored, mut unrelated, mut related) = (0usize, 0usize, 0usize, 0usize);
|
||||
let mut examples: Vec<String> = Vec::new();
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let models = Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false);
|
||||
let by_name: BTreeMap<&str, &Xbg7Model> =
|
||||
models.iter().map(|m| (m.name.as_str(), m)).collect();
|
||||
for m in &models {
|
||||
let Some(stem) = m.name.strip_suffix("_01") else { continue };
|
||||
let Some(t) = by_name.get(format!("{stem}_02").as_str()) else { continue };
|
||||
let a: Vec<[f32; 3]> = m.meshes.iter().flat_map(|s| s.positions.clone()).collect();
|
||||
let b: Vec<[f32; 3]> = t.meshes.iter().flat_map(|s| s.positions.clone()).collect();
|
||||
if a.len() != b.len() || a.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let ident = a.iter().zip(&b).all(|(p, q)| near(*p, *q));
|
||||
let mirr = a.iter().zip(&b).all(|(p, q)| near([-p[0], p[1], p[2]], *q));
|
||||
// A pair that is neither may still be RELATED: mirrored on another
|
||||
// axis, or the same point cloud in a different vertex order. Only a
|
||||
// pair that is none of these is evidence of a mis-anchor.
|
||||
let mirr_y = a.iter().zip(&b).all(|(p, q)| near([p[0], -p[1], p[2]], *q));
|
||||
let mirr_z = a.iter().zip(&b).all(|(p, q)| near([p[0], p[1], -p[2]], *q));
|
||||
let set = |v: &Vec<[f32; 3]>| {
|
||||
let mut s: Vec<_> = v.iter().map(|p| key(*p)).collect();
|
||||
s.sort_unstable();
|
||||
s
|
||||
};
|
||||
let same_cloud = set(&a) == set(&b);
|
||||
// …and the same point cloud after mirroring, for a pair whose
|
||||
// halves are authored in different vertex order.
|
||||
let mirrored_cloud = {
|
||||
let am: Vec<[f32; 3]> = a.iter().map(|p| [-p[0], p[1], p[2]]).collect();
|
||||
set(&am) == set(&b)
|
||||
};
|
||||
if !ident && !mirr && (mirr_y || mirr_z || same_cloud || mirrored_cloud) {
|
||||
related += 1;
|
||||
continue;
|
||||
}
|
||||
// Identical GEOMETRY is only a collapse if it also comes from the
|
||||
// same buffer: a container may store a part twice unmirrored, and
|
||||
// then two twins on two copies decode identically and correctly.
|
||||
let shared_buffer = m.meshes[0].vbuf_offset.is_some()
|
||||
&& m.meshes[0].vbuf_offset == t.meshes[0].vbuf_offset;
|
||||
if ident && !shared_buffer {
|
||||
related += 1;
|
||||
continue;
|
||||
}
|
||||
if ident {
|
||||
same += 1;
|
||||
if examples.len() < 6 {
|
||||
examples.push(format!(
|
||||
"identical: {} / {}_02 in {}",
|
||||
m.name,
|
||||
stem,
|
||||
f.file_name().unwrap().to_string_lossy()
|
||||
));
|
||||
}
|
||||
} else if mirr {
|
||||
mirrored += 1;
|
||||
} else {
|
||||
unrelated += 1;
|
||||
if examples.len() < 6 {
|
||||
examples.push(format!(
|
||||
"unrelated: {} / {}_02 in {}",
|
||||
m.name,
|
||||
stem,
|
||||
f.file_name().unwrap().to_string_lossy()
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("twin pairs of equal vertex count: {}", same + mirrored + unrelated + related);
|
||||
println!(" exact X-mirror (expected) : {mirrored}");
|
||||
println!(" IDENTICAL, one buffer (collapse) : {same}");
|
||||
println!(" related other way (Y/Z mirror, reordered): {related}");
|
||||
println!(" unrelated (mis-anchor?) : {unrelated}");
|
||||
for e in examples {
|
||||
println!(" e.g. {e}");
|
||||
}
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
//! Scratch analysis: inventory one UI screen's pak — every entry, and for RATC
|
||||
//! entries the children they bundle. Optionally write an entry's decompressed
|
||||
//! bytes out for hex inspection.
|
||||
//!
|
||||
//! Run: cargo run -p sylpheed-formats --example ui_screen -- <PAK> [--dump 0xHASH out.bin]
|
||||
|
||||
use sylpheed_formats::pak::{self, PakArchive};
|
||||
use sylpheed_formats::ratc;
|
||||
|
||||
fn main() {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let pak = args.next().expect("usage: ui_screen <pak> [--dump 0xHASH out.bin]");
|
||||
let arc = PakArchive::open(&pak).expect("open pak");
|
||||
|
||||
let rest: Vec<String> = args.collect();
|
||||
if rest.first().map(|s| s == "--dump").unwrap_or(false) {
|
||||
let h = u32::from_str_radix(rest[1].trim_start_matches("0x"), 16).unwrap();
|
||||
let bytes = arc.read_by_hash(h).expect("entry present").expect("decompress");
|
||||
std::fs::write(&rest[2], &bytes).unwrap();
|
||||
println!("wrote {} bytes to {}", bytes.len(), rest[2]);
|
||||
return;
|
||||
}
|
||||
|
||||
if rest.first().map(|s| s == "--child").unwrap_or(false) {
|
||||
// --child 0xHASH <child-name> <out>: carve one RATC child out by its
|
||||
// listed offset/size, so a 165-byte layout record can be hexdumped alone.
|
||||
let h = u32::from_str_radix(rest[1].trim_start_matches("0x"), 16).unwrap();
|
||||
let bytes = arc.read_by_hash(h).expect("entry present").expect("decompress");
|
||||
let kids = ratc::parse(&bytes).expect("ratc");
|
||||
let k = kids.iter().find(|k| k.name == rest[2]).expect("child not found");
|
||||
std::fs::write(&rest[3], &bytes[k.offset..k.offset + k.size]).unwrap();
|
||||
println!("wrote {} B ({} @ {:#x}) to {}", k.size, k.name, k.offset, rest[3]);
|
||||
return;
|
||||
}
|
||||
|
||||
println!("{pak}: {} entries", arc.len());
|
||||
for e in arc.entries() {
|
||||
let Ok(bytes) = arc.read(e) else {
|
||||
println!(" {:08x} <decompress failed>", e.name_hash);
|
||||
continue;
|
||||
};
|
||||
let label = pak::inner_format_label(&bytes);
|
||||
println!(" {:08x} {:>9} B {}", e.name_hash, bytes.len(), label);
|
||||
if ratc::is_ratc(&bytes) {
|
||||
if let Some(kids) = ratc::parse(&bytes) {
|
||||
for k in &kids {
|
||||
println!(" - {:<40} {:>9} B {}", k.name, k.size, k.kind);
|
||||
}
|
||||
if kids.is_empty() {
|
||||
println!(" (no children found)");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
//! Which XBG7 resources never decode, and how big is that population?
|
||||
//!
|
||||
//! Coverage has been reported as "resources decoded" without a denominator. This
|
||||
//! prints both, per container and in total, and names the misses so the gate
|
||||
//! attribution (`why_rejected`) has a work list.
|
||||
use sylpheed_formats::mesh::{debug_resource_params, xbg7_resource_names, Xbg7Model};
|
||||
use std::collections::HashSet;
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).expect("resource3d dir");
|
||||
let show = std::env::args().nth(2).is_some();
|
||||
let mut files: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
let (mut total, mut decoded, mut no_decl) = (0usize, 0usize, 0usize);
|
||||
let mut misses: Vec<String> = Vec::new();
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let names = xbg7_resource_names(&bytes);
|
||||
if names.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let got: HashSet<String> = Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false)
|
||||
.into_iter()
|
||||
.map(|m| m.name)
|
||||
.collect();
|
||||
for n in &names {
|
||||
total += 1;
|
||||
if got.contains(n) {
|
||||
decoded += 1;
|
||||
} else if debug_resource_params(&bytes, n).is_none() {
|
||||
// No vertex declaration / no index markers: the anchor scan
|
||||
// never even considers these, so they are a different question
|
||||
// from "searched and not found".
|
||||
no_decl += 1;
|
||||
} else {
|
||||
misses.push(format!("{}|{n}", f.file_name().unwrap().to_string_lossy()));
|
||||
}
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"XBG7 resources: {total} total, {decoded} decoded ({:.1}%), {no_decl} without a usable descriptor, {} searched-and-missed",
|
||||
100.0 * decoded as f64 / total as f64,
|
||||
misses.len()
|
||||
);
|
||||
if show {
|
||||
for m in &misses {
|
||||
println!("{m}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
//! Every key/value a named unit record actually sets on disc.
|
||||
//!
|
||||
//! The live definition object in guest RAM has no field names; to find where a
|
||||
//! field like `HQRatio` sits inside it, anchor on a unit whose disc record DOES
|
||||
//! set that field and look for the value. This prints those anchors.
|
||||
//! Run: unit_fields <disc-root> <substring of ID>...
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
|
||||
fn main() {
|
||||
let disc = std::env::args().nth(1).expect("disc root");
|
||||
let want: Vec<String> = std::env::args().skip(2).collect();
|
||||
let pak = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).expect("pak");
|
||||
for entry in pak.entries() {
|
||||
let Ok(bytes) = pak.read(entry) else { continue };
|
||||
let Ok(obj) = IdxdObject::parse(&bytes) else { continue };
|
||||
let Some(id) = obj.get_raw("ID") else { continue };
|
||||
if !want.iter().any(|w| id.contains(w.as_str())) {
|
||||
continue;
|
||||
}
|
||||
println!("=== {id} (schema {:08x})", obj.schema_hash);
|
||||
// The pool interleaves VALUE before KEY (see the module docs), so the
|
||||
// pairs read (t[i] = value, t[i+1] = key).
|
||||
let t = obj.tokens();
|
||||
let mut i = 0;
|
||||
while i + 1 < t.len() {
|
||||
println!(" {:<30} {}", t[i + 1], t[i]);
|
||||
i += 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
//! (HP, Size_X, Size_Y, Size_Z) for every craft unit and vessel on the disc.
|
||||
//!
|
||||
//! A live definition object in guest RAM carries HP at `+0x54` and the sizes at
|
||||
//! `+0x30/34/38` but no name in its first words, so identity has to come from the
|
||||
//! values themselves: this is the lookup table for that match.
|
||||
//! Run: unit_signatures <disc-root>
|
||||
use sylpheed_formats::game_data::{load_units, load_vessels};
|
||||
use sylpheed_formats::PakArchive;
|
||||
fn main() {
|
||||
let disc = std::env::args().nth(1).expect("disc root");
|
||||
let pak = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).expect("pak");
|
||||
println!("{:<34} {:>9} {:>8} {:>8} {:>8} kind", "id", "hp", "size_x", "size_y", "size_z");
|
||||
for u in load_units(&pak) {
|
||||
println!(
|
||||
"{:<34} {:>9} {:>8} {:>8} {:>8} unit",
|
||||
u.id.unwrap_or_default(),
|
||||
u.hp.map(|v| v.to_string()).unwrap_or("—".into()),
|
||||
u.size_x.map(|v| v.to_string()).unwrap_or("—".into()),
|
||||
u.size_y.map(|v| v.to_string()).unwrap_or("—".into()),
|
||||
u.size_z.map(|v| v.to_string()).unwrap_or("—".into()),
|
||||
);
|
||||
}
|
||||
for v in load_vessels(&pak) {
|
||||
println!(
|
||||
"{:<34} {:>9} {:>8} {:>8} {:>8} vessel",
|
||||
v.id.unwrap_or_default(),
|
||||
v.hp.map(|x| x.to_string()).unwrap_or("—".into()),
|
||||
v.size_x.map(|x| x.to_string()).unwrap_or("—".into()),
|
||||
v.size_y.map(|x| x.to_string()).unwrap_or("—".into()),
|
||||
v.size_z.map(|x| x.to_string()).unwrap_or("—".into()),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
fn main() {
|
||||
let disc = std::env::args().nth(1).unwrap();
|
||||
let want = std::env::args().nth(2).unwrap();
|
||||
let pak = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
let Some(id) = o.get_raw("ID") else { continue };
|
||||
if !id.contains(&want) { continue; }
|
||||
println!("=== {id}");
|
||||
let mut seen = std::collections::BTreeSet::new();
|
||||
for k in o.tokens() {
|
||||
if let Some(v) = o.get_f32(k) {
|
||||
if v != 0.0 && seen.insert(k.clone()) {
|
||||
println!(" {:<28} {:<12} 0x{:08x}", k, v, v.to_bits());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
//! Global "which resource has N vertices?" index over every `.xpr` container in
|
||||
//! an extracted `resource3d` directory, answered for the vcounts a capture log
|
||||
//! actually drew.
|
||||
//!
|
||||
//! Companion to `invert_capture`: that one asks the question inside a single
|
||||
//! stage container, this one asks it across ALL containers — so a draw whose
|
||||
//! geometry lives in `Common.xpr`, a `rou_*` weapon pack or a `BG_*` backdrop is
|
||||
//! still identified instead of coming back "no resource".
|
||||
//!
|
||||
//! Usage:
|
||||
//! cargo run --release --example vcount_index -- <resource3d_dir> <capture.log> [top_n]
|
||||
//! cargo run --release --example vcount_index -- <resource3d_dir> --vcounts 10891,6000
|
||||
|
||||
use sylpheed_formats::mesh::{xbg7_resource_names, Xbg7Model};
|
||||
use sylpheed_formats::ship_capture::{parse_capture, parse_drawlog};
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
if args.len() < 3 {
|
||||
eprintln!("usage: vcount_index <resource3d_dir> <capture.log|--vcounts a,b,c> [top_n]");
|
||||
std::process::exit(2);
|
||||
}
|
||||
let dir = &args[1];
|
||||
|
||||
// Which vertex counts are we asking about, and how often was each drawn?
|
||||
let mut draw_count: HashMap<u32, usize> = HashMap::new();
|
||||
let mut bufs: HashMap<u32, HashSet<u32>> = HashMap::new();
|
||||
if args[2] == "--vcounts" {
|
||||
for v in args[3].split(',').filter_map(|s| s.trim().parse::<u32>().ok()) {
|
||||
draw_count.insert(v, 0);
|
||||
}
|
||||
} else {
|
||||
let text = std::fs::read_to_string(&args[2]).expect("read log");
|
||||
let mut draws = parse_capture(&text);
|
||||
if draws.is_empty() {
|
||||
draws = parse_drawlog(&text);
|
||||
}
|
||||
eprintln!("parsed {} draws", draws.len());
|
||||
for d in &draws {
|
||||
*draw_count.entry(d.vcount).or_default() += 1;
|
||||
bufs.entry(d.vcount).or_default().insert(d.vbase);
|
||||
}
|
||||
}
|
||||
let top_n: usize = args.get(3).and_then(|s| s.parse().ok()).unwrap_or(usize::MAX);
|
||||
|
||||
// Decode every container once; keep only the vcount → names mapping.
|
||||
let mut by_vcount: HashMap<u32, Vec<String>> = HashMap::new();
|
||||
let mut files: Vec<std::path::PathBuf> = std::fs::read_dir(dir)
|
||||
.expect("read dir")
|
||||
.filter_map(|e| e.ok().map(|e| e.path()))
|
||||
.filter(|p| p.extension().is_some_and(|e| e == "xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
let mut total_res = 0usize;
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let names = xbg7_resource_names(&bytes);
|
||||
if names.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let want: HashSet<String> = names.iter().cloned().collect();
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
let container = f.file_stem().unwrap().to_string_lossy().to_string();
|
||||
for m in &models {
|
||||
total_res += 1;
|
||||
let whole: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
by_vcount.entry(whole as u32).or_default().push(format!("{container}:{}", m.name));
|
||||
if m.meshes.len() > 1 {
|
||||
for (i, s) in m.meshes.iter().enumerate() {
|
||||
by_vcount
|
||||
.entry(s.positions.len() as u32)
|
||||
.or_default()
|
||||
.push(format!("{container}:{}#{i}", m.name));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
eprintln!("indexed {} resources from {} containers", total_res, files.len());
|
||||
|
||||
let mut vcounts: Vec<u32> = draw_count.keys().copied().collect();
|
||||
vcounts.sort_unstable_by(|a, b| b.cmp(a));
|
||||
println!("\nvcount draws bufs resources anywhere in resource3d/");
|
||||
for v in vcounts.into_iter().take(top_n) {
|
||||
let n = draw_count[&v];
|
||||
let b = bufs.get(&v).map(|s| s.len()).unwrap_or(0);
|
||||
let hit = by_vcount.get(&v).cloned().unwrap_or_default();
|
||||
let label = if hit.is_empty() {
|
||||
"— NONE".to_string()
|
||||
} else {
|
||||
let mut h = hit.clone();
|
||||
h.sort();
|
||||
let shown = h.len().min(8);
|
||||
format!("{}{}", h[..shown].join(", "), if h.len() > shown { format!(", … ({} total)", h.len()) } else { String::new() })
|
||||
};
|
||||
println!("{v:6} {n:5} {b:4} {label}");
|
||||
}
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
//! Check the code-derived offset→field map against the live dump, then read out
|
||||
//! the runtime value of every field the disc record leaves defaulted.
|
||||
//! Run: verify_fieldmap <disc-root> <live-dump> <ID=0xVA>...
|
||||
use std::collections::BTreeMap;
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
|
||||
// Offsets read out of sub_82341A20's own key strings (stfs stores only).
|
||||
// Offsets and names recovered from `sub_82341A20` itself: each key is built as
|
||||
// `addi r4, r30, -N` (r30 = 0x82088f94, so the name is a string in the image),
|
||||
// and the value lands in the first store into the object after the accessor
|
||||
// call. 125 float-typed fields.
|
||||
const MAP: &[(usize, &str)] = &[(48, "Size_X"), (52, "Size_Y"), (56, "Size_Z"), (64, "Color_R"), (68, "Color_G"), (72, "Color_B"), (80, "Size_Radius"), (84, "HP"), (88, "HQRatio"), (92, "ShieldRatio"), (96, "ThrusterRatio"), (116, "ResistanceToOptics"), (120, "ResistanceToShell"), (124, "ResistanceToExplosion"), (128, "ResistanceToPlayer"), (132, "ResistanceParalyze"), (156, "MinimumVelocity"), (160, "MaximumVelocity"), (164, "CruisingVelocity"), (168, "Acceleration"), (172, "Deceleration"), (176, "AV_PitchPlus_Max"), (180, "AV_PitchPlus_Min"), (184, "AA_PitchPlus_Max"), (188, "AA_PitchPlus_Min"), (192, "AV_PitchMinus_Max"), (196, "AV_PitchMinus_Min"), (200, "AA_PitchMinus_Max"), (204, "AA_PitchMinus_Min"), (208, "AV_Yaw_Max"), (212, "AV_Yaw_Min"), (216, "AA_Yaw_Max"), (220, "AA_Yaw_Min"), (224, "AV_Roll_Max"), (228, "AV_Roll_Min"), (232, "AA_Roll_Max"), (236, "AA_Roll_Min"), (248, "SideThrustVelocity_Max"), (252, "SideThrustAcceleration"), (256, "MaximumBank_Normal"), (260, "YawDragFactor"), (264, "PitchDragFactor"), (268, "RollDragFactor"), (272, "DragFactorThreshold"), (276, "ArterBurner_Vc"), (280, "ReverseThrust_Vc"), (284, "ArterBurner_Acc"), (288, "ReverseThrust_Acc"), (292, "AccPitchFactor"), (296, "DecPitchFactor"), (300, "AV_AxisMode_Max"), (304, "AV_AxisMode_Min"), (308, "AA_AxisMode_Max"), (312, "AA_AxisMode_Min"), (316, "PowerCutConsumeShield"), (320, "PowerCutDeceleration"), (324, "AB_ConsumeShield_Begin"), (328, "AB_ConsumeShield"), (332, "AB_AV_PitchPlus"), (336, "AB_AA_PitchPlus"), (340, "AB_AV_PitchMinus"), (344, "AB_AA_PitchMinus"), (348, "AB_AV_Yaw"), (352, "AB_AA_Yaw"), (356, "AB_AV_Roll"), (360, "AB_AA_Roll"), (368, "SideRoll_Time"), (372, "SideRoll_Length"), (380, "BarrelRoll_CountMinimum"), (384, "BarrelRoll_CountMaximum"), (388, "BarrelRoll_Time"), (392, "BarrelRoll_Radius"), (400, "TurnAttack_CutoffRatio"), (404, "TurnAttack_DoubleRatio"), (408, "CutoffTimeMin"), (412, "CutoffTimeMax"), (416, "TurnAttack_DoubleTimeMin"), (420, "TurnAttack_DoubleTimeMax"), (428, "Turn_AngularVelocity"), (432, "TurnAway_Time_Minimum"), (436, "TurnAway_Time_Maximum"), (444, "BoostAway_Time_Minimum"), (448, "BoostAway_Time_Maximum"), (456, "HoldPosition_LengthMin"), (460, "HoldPosition_LengthMax"), (464, "HoldPosition_MinimumTime"), (468, "HoldPosition_MaximumTime"), (472, "HoldPosition_SideRatio"), (476, "HoldPosition_BackRatio"), (480, "HoldPosition_CutoffRatio"), (484, "HoldPosition_CancelTime"), (492, "Slalom_CutoffRatio"), (496, "Slalom_TurnCount_Min"), (500, "Slalom_TurnCount_Max"), (508, "Through_CutoffRatio"), (512, "Through_AngleMinimum"), (516, "Through_AngleMaximum"), (520, "Through_Time1Max"), (524, "Through_Time1Min"), (528, "Through_Time2Max"), (532, "Through_Time2Min"), (536, "Through_LengthMinimum"), (540, "Through_LengthMaximum"), (548, "SolidCutoff_Ratio"), (552, "SolidCutoff_LengthMin"), (556, "SolidCutoff_LengthMax"), (560, "HomingResistAdjustment"), (564, "UsingChaffRatio"), (568, "MaxValue"), (572, "ChargeDelay"), (576, "ChargeDelay_Break"), (580, "ChargeSpeed"), (584, "Delay"), (588, "DelayAdjustment"), (624, "DestroyMotionTime"), (628, "DryMass"), (632, "GrossMass"), (664, "LowerHPThresholdRatio"), (668, "SELength"), (672, "RadarRange"), (676, "FCSRange"), (680, "FiringRange"), (692, "AttackVesselPoint"), (696, "AttackCraftPoint"), (700, "DefencePoint")];
|
||||
|
||||
fn main() {
|
||||
let mut a = std::env::args().skip(1);
|
||||
let disc = a.next().unwrap();
|
||||
let dump = a.next().unwrap();
|
||||
let pairs: Vec<(String, String)> =
|
||||
a.filter_map(|s| s.split_once('=').map(|(i, v)| (i.into(), v.into()))).collect();
|
||||
|
||||
let mut live: BTreeMap<String, BTreeMap<usize, f32>> = BTreeMap::new();
|
||||
let mut cur = String::new();
|
||||
for line in std::fs::read_to_string(&dump).unwrap().lines() {
|
||||
if let Some(r) = line.strip_prefix("=== ") { cur = r.trim().into(); continue; }
|
||||
let f: Vec<&str> = line.split_whitespace().collect();
|
||||
// dump columns: addr +off hex u32 f32 -- the float is f[4], not f[3]
|
||||
if f.len() >= 5 && f[1].starts_with('+') {
|
||||
if let (Ok(o), Ok(v)) = (usize::from_str_radix(&f[1][1..], 16), f[4].parse::<f32>()) {
|
||||
live.entry(cur.clone()).or_default().insert(o, v);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let pak = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let (mut agree, mut disagree) = (0, 0);
|
||||
let mut defaults: BTreeMap<String, Vec<(String, f32)>> = BTreeMap::new();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
let Some(id) = o.get_raw("ID") else { continue };
|
||||
let Some((_, va)) = pairs.iter().find(|(i, _)| i == id) else { continue };
|
||||
let Some(w) = live.get(va) else { continue };
|
||||
for (off, key) in MAP {
|
||||
let Some(got) = w.get(off) else { continue };
|
||||
match o.get_f32(key) {
|
||||
Some(want) => {
|
||||
// Angle fields are stored in RADIANS at runtime and degrees on
|
||||
// disc, so a match is either the raw value or its conversion.
|
||||
let rad = want * std::f32::consts::PI / 180.0;
|
||||
let ok = (want - got).abs() <= want.abs() * 1e-4
|
||||
|| (rad - got).abs() <= rad.abs() * 1e-4;
|
||||
if ok { agree += 1 } else {
|
||||
disagree += 1;
|
||||
println!(" MISMATCH {id} {key}: disc {want}, live +{off} = {got}");
|
||||
}
|
||||
}
|
||||
None => defaults.entry((*key).into()).or_default().push((id.into(), *got)),
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("\nmap check: {agree} fields agree with the disc, {disagree} disagree\n");
|
||||
println!("runtime value where the disc record DEFAULTS the field:");
|
||||
for (key, hits) in &defaults {
|
||||
let vals: Vec<String> = hits.iter().map(|(_, v)| format!("{v}")).collect();
|
||||
let uniq: std::collections::BTreeSet<&String> = vals.iter().collect();
|
||||
println!(" {:<22} {:<28} ({} units)", key,
|
||||
uniq.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", "), hits.len());
|
||||
}
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
//! Why does the decoder refuse a grouped-pool resource at a given pool start?
|
||||
//! Usage: why_rejected <container.xpr> <resource>@<vb0-hex>...
|
||||
use sylpheed_formats::mesh::debug_grouped_report;
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).expect("container");
|
||||
for pair in &a[2..] {
|
||||
let (name, off) = pair.split_once('@').expect("name@hex");
|
||||
let vb0 = usize::from_str_radix(off.trim_start_matches("0x"), 16).expect("hex");
|
||||
for line in debug_grouped_report(&bytes, name, vb0) {
|
||||
println!("{line}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -37,6 +37,9 @@ pub mod t8ad;
|
||||
// RATC nested resource bundle
|
||||
pub mod ratc;
|
||||
|
||||
/// UI screen layout (`.rat`) — reassemble a screen from its pak.
|
||||
pub mod ui_layout;
|
||||
|
||||
// LSTA sprite list (inline T8aD frames)
|
||||
pub mod lsta;
|
||||
|
||||
@@ -68,10 +71,6 @@ pub mod localization;
|
||||
// Whole-ship assembly from XBG7 part families (capital ships as split parts).
|
||||
pub mod ship;
|
||||
|
||||
/// The runtime layout of a unit / vessel definition object, read out of the
|
||||
/// title's loader and verified against a live mission (see the module docs).
|
||||
pub mod unit_layout;
|
||||
|
||||
// Exact capital-ship placement from a runtime F10 ship-capture (ground truth).
|
||||
pub mod ship_capture;
|
||||
|
||||
|
||||
@@ -1,18 +1,9 @@
|
||||
//! `LSTA` — a display list: a header followed by N inline elements concatenated
|
||||
//! back-to-back, each either a [`T8aD`](crate::t8ad) sprite or a `PRMD`
|
||||
//! primitive (a flat coloured quad — the same primitive the UI bundles use to
|
||||
//! dim a scene).
|
||||
//! `LSTA` — a sprite list: a header followed by N inline [`T8aD`](crate::t8ad)
|
||||
//! frames concatenated back-to-back.
|
||||
//!
|
||||
//! The `count` at `@0x04` is **exact, and counts both kinds**: across all 64
|
||||
//! lists on the disc, `count == T8aD frames + PRMD primitives` with no
|
||||
//! exceptions (measured 2026-08-11). An earlier note here said "a few entries
|
||||
//! disagree with the actual frame count" — they do not; that comparison was
|
||||
//! counting sprites against a total that includes primitives.
|
||||
//!
|
||||
//! [`parse`] walks by magic and returns the **sprites**, deliberately skipping
|
||||
//! `PRMD` entries, so its result length is `count` only for lists that hold no
|
||||
//! primitives. Six lists do (in `GP_DEBRIEFING_PILOTLOG`, `GP_MISSION_SELECT`),
|
||||
//! each with exactly one.
|
||||
//! A `count` lives at `@0x04`, but a few entries disagree with the actual frame
|
||||
//! count, so we walk by the `T8aD` magic instead (robust) and decode each frame
|
||||
//! from its slice up to the next frame (or end).
|
||||
|
||||
use crate::t8ad::{self, T8adImage, T8AD_MAGIC};
|
||||
|
||||
@@ -24,9 +15,8 @@ pub fn is_lsta(bytes: &[u8]) -> bool {
|
||||
bytes.len() >= 4 && bytes[0..4] == LSTA_MAGIC
|
||||
}
|
||||
|
||||
/// Decode the inline T8aD sprites, skipping `PRMD` primitives. Returns `None`
|
||||
/// only for non-LSTA input. Every one of the 1 281 sprite frames on the disc
|
||||
/// decodes (measured 2026-08-11, after the T8aD rectangle-list fix).
|
||||
/// Decode all inline T8aD frames. Frames that don't decode (unsupported T8aD
|
||||
/// variant) are skipped. Returns `None` only for non-LSTA input.
|
||||
pub fn parse(bytes: &[u8]) -> Option<Vec<T8adImage>> {
|
||||
if !is_lsta(bytes) {
|
||||
return None;
|
||||
@@ -58,21 +48,12 @@ pub fn parse(bytes: &[u8]) -> Option<Vec<T8adImage>> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A faithful one-rectangle T8aD frame: base header, a 1-entry offset table,
|
||||
/// then the rectangle header (dst 0,0, size w×h) and its pixels. (Before
|
||||
/// 2026-08-11 this fixture wrote no offset-table entry at all and the decoder
|
||||
/// read "pixels" from inside the header — the test only ever checked the
|
||||
/// dimensions, so it passed anyway.)
|
||||
fn t8ad_frame(w: u32, h: u32) -> Vec<u8> {
|
||||
let mut b = vec![0u8; 0x2c];
|
||||
let mut b = vec![0u8; 64];
|
||||
b[0..4].copy_from_slice(&T8AD_MAGIC);
|
||||
b[0x14..0x18].copy_from_slice(&w.to_be_bytes());
|
||||
b[0x18..0x1c].copy_from_slice(&h.to_be_bytes());
|
||||
b[0x1c..0x20].copy_from_slice(&1u32.to_be_bytes());
|
||||
b.extend_from_slice(&0x30u32.to_be_bytes()); // offset table → rect at 0x30
|
||||
for v in [0u32, 0, w, h] {
|
||||
b.extend_from_slice(&v.to_be_bytes()); // dst X, dst Y, width, height
|
||||
}
|
||||
b.extend_from_slice(&vec![0x80u8; (w * h * 4) as usize]);
|
||||
b
|
||||
}
|
||||
|
||||
@@ -115,12 +115,6 @@ pub struct GameMesh {
|
||||
pub indices: Vec<u32>,
|
||||
/// Sub-mesh / node name from the descriptor, when available.
|
||||
pub name: Option<String>,
|
||||
/// Byte offset of this sub-mesh's vertex buffer inside the container, when
|
||||
/// the decode path knows it. The content-anchored stage path does — and a
|
||||
/// runtime capture names the same offset (a draw's `vbase` is this plus the
|
||||
/// container's load address), so this is what makes an anchor checkable
|
||||
/// against ground truth. See `examples/shared_vbase_check.rs`.
|
||||
pub vbuf_offset: Option<usize>,
|
||||
}
|
||||
|
||||
/// A model = the set of sub-meshes recovered from one XPR2 container's first
|
||||
@@ -382,7 +376,6 @@ impl Xbg7Model {
|
||||
uvs,
|
||||
indices,
|
||||
name: None,
|
||||
vbuf_offset: Some(vb),
|
||||
});
|
||||
off = align16(ve) - base;
|
||||
}
|
||||
@@ -463,32 +456,11 @@ impl Xbg7Model {
|
||||
Self::anchor_models_filtered(bytes, min_consistency, should_cancel, None)
|
||||
}
|
||||
|
||||
/// Decode the whole container (cached), then hand back the requested subset.
|
||||
///
|
||||
/// The decode itself must always see every resource — distinct assignment
|
||||
/// resolves collisions against the whole population, and pruning first made
|
||||
/// the answer depend on the request (see the module history). That makes a
|
||||
/// single-resource query as expensive as a full decode, so the full decode is
|
||||
/// memoised per container: the viewer asks for one ship's parts at a time and
|
||||
/// would otherwise re-anchor 6 000 resources per ship.
|
||||
fn anchor_models_filtered(
|
||||
bytes: &[u8],
|
||||
min_consistency: f32,
|
||||
should_cancel: &(dyn Fn() -> bool + Sync),
|
||||
wanted: Option<&std::collections::HashSet<String>>,
|
||||
) -> Vec<Xbg7Model> {
|
||||
let Some(w) = wanted else {
|
||||
return Self::anchor_models_uncached(bytes, min_consistency, should_cancel, None);
|
||||
};
|
||||
let full = full_decode_cached(bytes, min_consistency, should_cancel);
|
||||
full.iter().filter(|m| w.contains(&m.name)).cloned().collect()
|
||||
}
|
||||
|
||||
fn anchor_models_uncached(
|
||||
bytes: &[u8],
|
||||
min_consistency: f32,
|
||||
should_cancel: &(dyn Fn() -> bool + Sync),
|
||||
wanted: Option<&std::collections::HashSet<String>>,
|
||||
) -> Vec<Xbg7Model> {
|
||||
let mut out = Vec::new();
|
||||
if bytes.len() < 16 || &bytes[..4] != b"XPR2" {
|
||||
@@ -544,13 +516,11 @@ impl Xbg7Model {
|
||||
}
|
||||
let name = read_cstr(bytes, e.name_offset as usize + DIR_BASE)
|
||||
.unwrap_or_else(|| "XBG7".to_string());
|
||||
// NOTE: `wanted` is NOT applied here. Distinct assignment resolves
|
||||
// collisions against the whole set of resources, so pruning first
|
||||
// made a filtered decode depend on *which* subset was asked for —
|
||||
// measured 2026-08-12: 27 of 356 resources in `Stage_S02` came out
|
||||
// at a different offset when requested alone. The filter is applied
|
||||
// to the OUTPUT instead, so a subset is always a subset of the
|
||||
// container's own answer.
|
||||
if let Some(w) = wanted {
|
||||
if !w.contains(&name) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
resources.push(Res {
|
||||
name,
|
||||
markers,
|
||||
@@ -586,7 +556,6 @@ impl Xbg7Model {
|
||||
// preserves resource order, so the output is identical to the sequential
|
||||
// decode. `should_cancel()` is polled per resource so a superseded load
|
||||
// stops promptly.
|
||||
let empty_taken: std::collections::HashSet<usize> = std::collections::HashSet::new();
|
||||
let decode_one = |r: &Res| -> Option<Xbg7Model> {
|
||||
if should_cancel() {
|
||||
return None;
|
||||
@@ -598,23 +567,13 @@ impl Xbg7Model {
|
||||
// simple props take this path; `min_consistency` behaviour is
|
||||
// exactly as before.
|
||||
let (vtx_count, index_count) = r.markers[0];
|
||||
anchor_pool_mesh(
|
||||
bytes,
|
||||
starts,
|
||||
index_count,
|
||||
vtx_count,
|
||||
&r.decl,
|
||||
min_consistency,
|
||||
&empty_taken,
|
||||
0,
|
||||
)
|
||||
.into_iter()
|
||||
.collect()
|
||||
anchor_pool_mesh(bytes, starts, index_count, vtx_count, &r.decl, min_consistency)
|
||||
.into_iter()
|
||||
.collect()
|
||||
} else {
|
||||
// Several sub-meshes sharing grouped index/vertex pools → the
|
||||
// deterministic grouped-pool decode (hero ships et al.).
|
||||
let grouped =
|
||||
anchor_grouped_meshes(bytes, data_base, starts, &r.markers, &r.decl, &empty_taken);
|
||||
let grouped = anchor_grouped_meshes(bytes, data_base, starts, &r.markers, &r.decl);
|
||||
if !grouped.is_empty() {
|
||||
grouped
|
||||
} else {
|
||||
@@ -623,18 +582,9 @@ impl Xbg7Model {
|
||||
// to the original single-block adjacency anchor on the first
|
||||
// marker so coverage is never *below* the pre-grouped decode.
|
||||
let (vtx_count, index_count) = r.markers[0];
|
||||
anchor_pool_mesh(
|
||||
bytes,
|
||||
starts,
|
||||
index_count,
|
||||
vtx_count,
|
||||
&r.decl,
|
||||
min_consistency,
|
||||
&empty_taken,
|
||||
0,
|
||||
)
|
||||
.into_iter()
|
||||
.collect()
|
||||
anchor_pool_mesh(bytes, starts, index_count, vtx_count, &r.decl, min_consistency)
|
||||
.into_iter()
|
||||
.collect()
|
||||
}
|
||||
};
|
||||
(!meshes.is_empty()).then(|| Xbg7Model {
|
||||
@@ -644,585 +594,18 @@ impl Xbg7Model {
|
||||
};
|
||||
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
let decoded: Vec<(usize, Xbg7Model)> = {
|
||||
{
|
||||
use rayon::prelude::*;
|
||||
resources
|
||||
.par_iter()
|
||||
.enumerate()
|
||||
.filter_map(|(i, r)| decode_one(r).map(|m| (i, m)))
|
||||
.collect()
|
||||
};
|
||||
out = resources.par_iter().filter_map(decode_one).collect();
|
||||
}
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
let decoded: Vec<(usize, Xbg7Model)> = resources
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(i, r)| decode_one(r).map(|m| (i, m)))
|
||||
.collect();
|
||||
|
||||
// ── Distinct assignment ──────────────────────────────────────────
|
||||
//
|
||||
// Selection above is per-resource and greedy: each takes the first
|
||||
// candidate that validates, so two resources can claim ONE buffer while
|
||||
// a valid buffer sits unused. A runtime capture proves that is wrong for
|
||||
// the mirrored `e106_bdy_0{1,2}_l` twins — the container holds both
|
||||
// halves (`0x3b3ee8` and its X-mirror `0x3c55d8`) and the engine draws
|
||||
// each from its own — and both offsets validate for both names, so the
|
||||
// correct block merely lost the first-match race.
|
||||
//
|
||||
// So: walk the decodes in container order, let the first claimant keep a
|
||||
// buffer, and re-anchor any later resource that wanted the same one,
|
||||
// skipping everything already claimed. Only single-sub-mesh resources
|
||||
// (the adjacency-anchor path) take part; grouped-pool models are left
|
||||
// exactly as they were.
|
||||
let mut taken: std::collections::HashSet<usize> = std::collections::HashSet::new();
|
||||
// Opt-in monotone pass: the last offset handed to each (stride, vtx, idx)
|
||||
// signature. Resources that share a signature are interchangeable to the
|
||||
// validator — many containers hold dozens of identical 24-vertex bound
|
||||
// boxes — so file order is the only thing that can pin which is which.
|
||||
let monotone = std::env::var("XBG7_MONOTONE").is_ok();
|
||||
let mut last_by_sig: std::collections::HashMap<(usize, usize, usize), usize> =
|
||||
std::collections::HashMap::new();
|
||||
let mut models: Vec<Xbg7Model> = Vec::with_capacity(decoded.len());
|
||||
for (i, mut m) in decoded {
|
||||
let r = &resources[i];
|
||||
let starts = &starts_by_stride[&r.decl.stride];
|
||||
if monotone && m.meshes.len() == 1 && r.markers.len() == 1 {
|
||||
let (vc, ic) = r.markers[0];
|
||||
let sig = (r.decl.stride, vc, ic);
|
||||
let floor = last_by_sig.get(&sig).map_or(0, |o| o + 1);
|
||||
if m.meshes[0].vbuf_offset.map_or(false, |o| o < floor) {
|
||||
if let Some(alt) = anchor_pool_mesh(
|
||||
bytes,
|
||||
starts,
|
||||
ic,
|
||||
vc,
|
||||
&r.decl,
|
||||
min_consistency,
|
||||
&taken,
|
||||
floor,
|
||||
) {
|
||||
m.meshes[0] = alt;
|
||||
}
|
||||
}
|
||||
if let Some(o) = m.meshes[0].vbuf_offset {
|
||||
last_by_sig.insert(sig, o);
|
||||
}
|
||||
}
|
||||
if let Some(vb) = m.meshes[0].vbuf_offset {
|
||||
if taken.contains(&vb) {
|
||||
if m.meshes.len() == 1 && r.markers.len() == 1 {
|
||||
let (vtx_count, index_count) = r.markers[0];
|
||||
if let Some(alt) = anchor_pool_mesh(
|
||||
bytes,
|
||||
starts,
|
||||
index_count,
|
||||
vtx_count,
|
||||
&r.decl,
|
||||
min_consistency,
|
||||
&taken,
|
||||
0,
|
||||
) {
|
||||
m.meshes[0] = alt;
|
||||
}
|
||||
} else {
|
||||
// Grouped pool: re-place the WHOLE pool past everything
|
||||
// claimed, or keep what we had.
|
||||
let alt = anchor_grouped_meshes(
|
||||
bytes, data_base, starts, &r.markers, &r.decl, &taken,
|
||||
);
|
||||
if !alt.is_empty() {
|
||||
m.meshes = alt;
|
||||
}
|
||||
}
|
||||
// No free candidate → keep the collided decode rather than
|
||||
// drop the resource; coverage never regresses.
|
||||
}
|
||||
for sub in &m.meshes {
|
||||
if let Some(vb2) = sub.vbuf_offset {
|
||||
taken.insert(vb2);
|
||||
}
|
||||
}
|
||||
}
|
||||
models.push(m);
|
||||
{
|
||||
out = resources.iter().filter_map(decode_one).collect();
|
||||
}
|
||||
if let Some(w) = wanted {
|
||||
models.retain(|m| w.contains(&m.name));
|
||||
}
|
||||
out = models;
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
/// Diagnostic: would the anchor scan accept `vb` as the vertex buffer of the
|
||||
/// named resource's first sub-mesh? A runtime capture proves which offset the
|
||||
/// engine drew from, so this answers whether the correct block is *acceptable*
|
||||
/// and merely lost the first-match race, or is rejected outright by
|
||||
/// `validate_block`. Returns `(vtx_count, index_count, accepted_pad)`.
|
||||
pub fn debug_try_anchor(
|
||||
bytes: &[u8],
|
||||
name: &str,
|
||||
vb: usize,
|
||||
max_pad: usize,
|
||||
) -> Option<(usize, usize, usize)> {
|
||||
if bytes.len() < 16 || &bytes[..4] != b"XPR2" {
|
||||
return None;
|
||||
}
|
||||
let mut cur = Cursor::new(bytes);
|
||||
let header = Xpr2Header::read(&mut cur).ok()?;
|
||||
const DIR_BASE: usize = 0x10;
|
||||
for _ in 0..header.num_resources {
|
||||
let Ok(e) = Xpr2ResourceEntry::read(&mut cur) else { 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 rname = read_cstr(bytes, e.name_offset as usize + DIR_BASE)
|
||||
.unwrap_or_else(|| "XBG7".to_string());
|
||||
if rname != name {
|
||||
continue;
|
||||
}
|
||||
let d = &bytes[desc..desc_end];
|
||||
let markers = all_index_markers(d);
|
||||
let decl = parse_vertex_decl(d)?;
|
||||
let (vtx_count, index_count) = *markers.first()?;
|
||||
let idx_bytes = index_count * 2;
|
||||
for pad in 0..=max_pad {
|
||||
if vb < idx_bytes + pad {
|
||||
continue;
|
||||
}
|
||||
let mc = if pad == 0 { 0.0 } else { 0.85 };
|
||||
if validate_block(
|
||||
bytes,
|
||||
vb - idx_bytes - pad,
|
||||
vb,
|
||||
vtx_count,
|
||||
index_count,
|
||||
&decl,
|
||||
mc,
|
||||
true,
|
||||
) {
|
||||
return Some((vtx_count, index_count, pad));
|
||||
}
|
||||
}
|
||||
return None;
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// How far did the anchor scan get for a resource it failed to place?
|
||||
///
|
||||
/// Runs the same candidate loop the decoder runs and keeps the **furthest**
|
||||
/// rejection — the candidate that passed the most gates before failing. Over the
|
||||
/// resources that never decode, the distribution of these says which gate to
|
||||
/// work on, instead of tuning one threshold and re-measuring.
|
||||
pub fn debug_best_rejection(bytes: &[u8], name: &str) -> Option<(usize, String)> {
|
||||
let (decl, markers) = decl_of(bytes, name)?;
|
||||
let starts = debug_vertex_run_starts(bytes, decl.stride);
|
||||
#[allow(clippy::type_complexity)]
|
||||
let rank = |why: &str| -> usize {
|
||||
if why.contains("out of range") {
|
||||
1
|
||||
} else if why.contains("buffer not covered") {
|
||||
2
|
||||
} else if why.contains("not finite") || why.contains("degenerate") {
|
||||
3
|
||||
} else if why.contains("connectivity") {
|
||||
4
|
||||
} else if why.contains("winding") {
|
||||
5
|
||||
} else {
|
||||
0
|
||||
}
|
||||
};
|
||||
// A grouped-pool resource is placed by its PIVOT sub-mesh, so it needs the
|
||||
// grouped candidate loop; running the single-block loop on `markers[0]`
|
||||
// would report a gate the decoder never consulted for it.
|
||||
if markers.len() > 1 {
|
||||
let n = markers.len();
|
||||
let (mut rel_ib, mut acc_i) = (Vec::with_capacity(n), 0usize);
|
||||
for &(_, ic) in &markers {
|
||||
rel_ib.push(acc_i);
|
||||
acc_i = align4(acc_i + ic * 2);
|
||||
}
|
||||
let span = rel_ib[n - 1] + markers[n - 1].1 * 2;
|
||||
let kmax = (0..n).max_by_key(|&i| markers[i].1).unwrap_or(0);
|
||||
let (vck, ick) = markers[kmax];
|
||||
let off_v: usize = markers.iter().take(kmax).map(|&(vc, _)| vc * decl.stride).sum();
|
||||
let mut best = (0usize, String::from("no pool start reached any gate"));
|
||||
for &vb0 in &starts {
|
||||
for pad in 0..=3usize {
|
||||
if vb0 < span + pad {
|
||||
continue;
|
||||
}
|
||||
let ib0 = vb0 - span - pad;
|
||||
match validate_block_report(
|
||||
bytes,
|
||||
ib0 + rel_ib[kmax],
|
||||
vb0 + off_v,
|
||||
vck,
|
||||
ick,
|
||||
&decl,
|
||||
0.85,
|
||||
true,
|
||||
) {
|
||||
Ok(()) => return None, // the pivot would have anchored
|
||||
Err(why) => {
|
||||
let r = rank(&why);
|
||||
if r > best.0 {
|
||||
best = (r, why);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return Some(best);
|
||||
}
|
||||
let (vtx_count, index_count) = *markers.first()?;
|
||||
let idx_bytes = index_count * 2;
|
||||
let mut best = (0usize, String::from("no candidate reached any gate"));
|
||||
for &vb in &starts {
|
||||
for pad in 0..=3usize {
|
||||
if vb < idx_bytes + pad {
|
||||
continue;
|
||||
}
|
||||
// Mirror production exactly: the pad-0 path now carries the winding
|
||||
// floor too. Reporting at 0.0 would accept blocks the decoder
|
||||
// rejects and point at the wrong gate.
|
||||
let mc = if pad == 0 { pad0_consistency() } else { 0.85 };
|
||||
if let Err(why) = validate_block_report(
|
||||
bytes,
|
||||
vb - idx_bytes - pad,
|
||||
vb,
|
||||
vtx_count,
|
||||
index_count,
|
||||
&decl,
|
||||
mc,
|
||||
true,
|
||||
) {
|
||||
let r = rank(&why);
|
||||
if r > best.0 {
|
||||
best = (r, why);
|
||||
}
|
||||
} else {
|
||||
return None; // it would have decoded — not a miss
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(best)
|
||||
}
|
||||
|
||||
/// Diagnostic: why does the decoder refuse a grouped-pool resource at a given
|
||||
/// pool start? Recomputes the pool layout exactly as [`anchor_grouped_meshes`]
|
||||
/// does and reports the pivot sub-mesh's verdict for each index/vertex pad —
|
||||
/// so a capture-proven pool that the decoder rejects names the gate to fix.
|
||||
pub fn debug_grouped_report(bytes: &[u8], name: &str, vb0: usize) -> Vec<String> {
|
||||
let Some((decl, markers)) = decl_of(bytes, name) else {
|
||||
return vec!["no such XBG7 resource".into()];
|
||||
};
|
||||
let n = markers.len();
|
||||
if n == 0 {
|
||||
return vec!["no index markers".into()];
|
||||
}
|
||||
let (mut rel_ib, mut acc_i) = (Vec::with_capacity(n), 0usize);
|
||||
for &(_, ic) in &markers {
|
||||
rel_ib.push(acc_i);
|
||||
acc_i = align4(acc_i + ic * 2);
|
||||
}
|
||||
let span = rel_ib[n - 1] + markers[n - 1].1 * 2;
|
||||
let kmax = (0..n).max_by_key(|&i| markers[i].1).unwrap_or(0);
|
||||
let (vck, ick) = markers[kmax];
|
||||
let mut off_v = 0usize;
|
||||
for &(vc, _) in markers.iter().take(kmax) {
|
||||
off_v += vc * decl.stride;
|
||||
}
|
||||
let mut out = vec![format!(
|
||||
"{name}: {n} sub-meshes, pivot #{kmax} ({vck} verts, {ick} idx), pool span {span}"
|
||||
)];
|
||||
for pad in 0..=3usize {
|
||||
if vb0 < span + pad {
|
||||
out.push(format!(" pad {pad}: pool start is before the index pool"));
|
||||
continue;
|
||||
}
|
||||
let ib0 = vb0 - span - pad;
|
||||
// Same gates the production pivot test uses: strict winding (0.85)
|
||||
// AND connectivity. Reporting at 0.0 would accept blocks the decoder
|
||||
// rejects and send the reader chasing the wrong gate.
|
||||
let verdict = validate_block_report(
|
||||
bytes,
|
||||
ib0 + rel_ib[kmax],
|
||||
vb0 + off_v,
|
||||
vck,
|
||||
ick,
|
||||
&decl,
|
||||
0.85,
|
||||
true,
|
||||
);
|
||||
out.push(match verdict {
|
||||
Ok(()) => format!(" pad {pad}: ACCEPTED"),
|
||||
Err(why) => format!(" pad {pad}: {why}"),
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Diagnostic: for a resource whose vertex buffer is *known* (a runtime capture
|
||||
/// names it), where could its index buffer be? The anchor scan assumes the index
|
||||
/// buffer sits immediately before the vertex buffer; this scans the whole
|
||||
/// container instead and returns every offset that validates as this resource's
|
||||
/// index buffer. An empty result means the block is unreadable at that `vb` for
|
||||
/// another reason; a hit far from `vb` means the adjacency assumption is what
|
||||
/// fails. Returns `(ib_offset, signed distance vb - ib)` pairs.
|
||||
pub fn debug_find_index_buffer(bytes: &[u8], name: &str, vb: usize) -> Vec<(usize, i64)> {
|
||||
let Some(decl) = decl_of(bytes, name) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let markers = decl.1;
|
||||
let decl = decl.0;
|
||||
let Some(&(vtx_count, index_count)) = markers.first() else {
|
||||
return Vec::new();
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
let end = bytes.len().saturating_sub(index_count * 2);
|
||||
let mut ib = 0usize;
|
||||
while ib < end {
|
||||
// Cheap prefilter: the first few indices must be in range, and a real
|
||||
// index buffer is not a run of zeros.
|
||||
let ok = (0..6).all(|k| (be16(bytes, ib + k * 2) as usize) < vtx_count)
|
||||
&& (0..6).any(|k| be16(bytes, ib + k * 2) != 0);
|
||||
// `SOFT_IB=1` drops the connectivity requirement, to separate "no index
|
||||
// buffer fits" from "our connectivity test is too strict".
|
||||
let strict = std::env::var("SOFT_IB").is_err();
|
||||
if ok && validate_block(bytes, ib, vb, vtx_count, index_count, &decl, 0.0, strict) {
|
||||
out.push((ib, vb as i64 - ib as i64));
|
||||
}
|
||||
ib += 2;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The connectivity cap: a searched block whose mean triangle edge exceeds this
|
||||
/// fraction of its bounding-box diagonal is rejected.
|
||||
///
|
||||
/// **1.0 since 2026-08-12 — effectively inert.** The winding-consistency gate
|
||||
/// ([`pad0_consistency`]) replaced this as the primary structural test: it is an
|
||||
/// objective topology signal rather than a shape heuristic, and swapping them
|
||||
/// decodes **143 more** resources with **17 fewer** cross-container
|
||||
/// inconsistencies while the capture oracle stays at 46/46. The cap is kept as a
|
||||
/// knob and a backstop against absurd blocks. History below.
|
||||
///
|
||||
/// **0.42 from 2026-08-12**, raised from 0.28 on runtime evidence. A capture
|
||||
/// names the blocks the engine really draws, and the old cap rejected one of them
|
||||
/// outright — `e106_eng_02_l`, a 24-triangle LOD, measures **0.417**, because a
|
||||
/// coarse mesh's edges *are* a large fraction of its own size. Swept against the
|
||||
/// 46 capture-named `Stage_S02` buffers (with distinct anchor assignment): 0.28
|
||||
/// anchors 40 exactly and leaves 4 unclaimed, 0.42 anchors **45 and leaves none**,
|
||||
/// and nothing above 0.42 improves further — so this is the least permissive
|
||||
/// value that captures the whole measured gain. `XBG7_EDGE_CAP` overrides it (see
|
||||
/// docs/re/structures/xbg7-mesh.md).
|
||||
fn edge_cap() -> f32 {
|
||||
std::env::var("XBG7_EDGE_CAP").ok().and_then(|v| v.parse().ok()).unwrap_or(1.0)
|
||||
}
|
||||
|
||||
/// Winding floor for the grouped-pool **pivot** (default `0.85`). The single-block
|
||||
/// path settled at 0.70 on measurement; this is the same question for the pivot,
|
||||
/// and `XBG7_GROUPED_CONSISTENCY` sweeps it.
|
||||
fn grouped_consistency() -> f32 {
|
||||
std::env::var("XBG7_GROUPED_CONSISTENCY").ok().and_then(|v| v.parse().ok()).unwrap_or(0.85)
|
||||
}
|
||||
|
||||
/// Coverage requirement, as `max_index + N >= vtx_count`. **`1` since
|
||||
/// 2026-08-12** — i.e. the indices must reach the pool's last vertex exactly.
|
||||
///
|
||||
/// The old `4` tolerated three unreferenced tail vertices, and that slack was a
|
||||
/// mis-anchor tell rather than a real variation: 8 580 of 8 629 decoded
|
||||
/// sub-meshes cover their pool exactly, and `e106_bdy_03` in `Stage_S02` was one
|
||||
/// of the few that did not — slack 3, decoding to a 600×1600×998 slab visible in
|
||||
/// a render, where three other containers give 276×236×941. Requiring exact
|
||||
/// coverage moves it onto the block those containers agree on. Costs 3 resources
|
||||
/// disc-wide; capture oracle unchanged at 46/46. `XBG7_COVER_SLACK` overrides
|
||||
/// (note `0` rejects everything — the comparison is `max_idx + N >= vtx_count`).
|
||||
fn cover_slack() -> usize {
|
||||
std::env::var("XBG7_COVER_SLACK").ok().and_then(|v| v.parse().ok()).unwrap_or(1)
|
||||
}
|
||||
|
||||
/// Smallest bounding-box extent a block may have (default `0.5`). An absolute
|
||||
/// floor on a format with no unit convention is a scale assumption, so it is a
|
||||
/// knob: `XBG7_MIN_EXTENT`.
|
||||
fn min_extent() -> f32 {
|
||||
std::env::var("XBG7_MIN_EXTENT").ok().and_then(|v| v.parse().ok()).unwrap_or(0.5)
|
||||
}
|
||||
|
||||
/// Use a scale-free collinearity test for degeneracy instead of the absolute
|
||||
/// triangle-area one (`XBG7_REL_DEGEN=1`). More principled in the abstract — an
|
||||
/// absolute area threshold calls a small object's every triangle degenerate —
|
||||
/// but measured on this disc it decodes **no more** resources and raises
|
||||
/// cross-container inconsistency 39 → 44, so it is **not** the default.
|
||||
fn rel_degen() -> bool {
|
||||
std::env::var("XBG7_REL_DEGEN").is_ok()
|
||||
}
|
||||
|
||||
/// Winding-consistency floor for the pad-0 single-block anchor.
|
||||
///
|
||||
/// **0.70 since 2026-08-12.** A triangle's face normal should agree with its
|
||||
/// vertices' stored normals almost always (≈1.0) or almost never (≈0.0, inverted
|
||||
/// winding); a mis-carve wires arbitrary vertices and lands near 0.5. Gating on
|
||||
/// `max(na, 1−na)` is therefore an objective topology test, where the
|
||||
/// connectivity cap it replaces is a shape heuristic that provably rejected a
|
||||
/// capture-proven block. Measured over the disc, with connectivity inert:
|
||||
///
|
||||
/// | floor | resources decoded | shared inconsistent |
|
||||
/// |---|---|---|
|
||||
/// | 0.60 | 6 214 | 53 |
|
||||
/// | **0.70** | **6 212** | **39** |
|
||||
/// | 0.80 | 5 770 | 1 |
|
||||
/// | 0.85 | 5 770 | 0 |
|
||||
///
|
||||
/// 0.70 dominates the previous connectivity-only default (6 069 / 56) on both
|
||||
/// axes with the capture oracle unchanged, so it ships. The cliff at 0.80 buys
|
||||
/// perfect cross-container consistency for 442 resources — recorded rather than
|
||||
/// taken, since consistency is the weaker witness (see the docs).
|
||||
fn pad0_consistency() -> f32 {
|
||||
std::env::var("XBG7_PAD0_CONSISTENCY").ok().and_then(|v| v.parse().ok()).unwrap_or(0.70)
|
||||
}
|
||||
|
||||
/// Triangle count below which the looser [`small_cap`] applies. `0` (default)
|
||||
/// disables the split, so the flat [`edge_cap`] governs every block.
|
||||
fn small_tris() -> usize {
|
||||
std::env::var("XBG7_SMALL_TRIS").ok().and_then(|v| v.parse().ok()).unwrap_or(0)
|
||||
}
|
||||
|
||||
/// The connectivity cap for blocks below [`small_tris`] triangles.
|
||||
fn small_cap() -> f32 {
|
||||
std::env::var("XBG7_EDGE_CAP_SMALL").ok().and_then(|v| v.parse().ok()).unwrap_or(0.45)
|
||||
}
|
||||
|
||||
/// Internal: the descriptor parameters the diagnostics need.
|
||||
fn decl_of(bytes: &[u8], name: &str) -> Option<(VertexDecl, Vec<(usize, usize)>)> {
|
||||
if bytes.len() < 16 || &bytes[..4] != b"XPR2" {
|
||||
return None;
|
||||
}
|
||||
let mut cur = Cursor::new(bytes);
|
||||
let header = Xpr2Header::read(&mut cur).ok()?;
|
||||
const DIR_BASE: usize = 0x10;
|
||||
for _ in 0..header.num_resources {
|
||||
let Ok(e) = Xpr2ResourceEntry::read(&mut cur) else { 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 rname = read_cstr(bytes, e.name_offset as usize + DIR_BASE)
|
||||
.unwrap_or_else(|| "XBG7".to_string());
|
||||
if rname != name {
|
||||
continue;
|
||||
}
|
||||
let d = &bytes[desc..desc_end];
|
||||
return Some((parse_vertex_decl(d)?, all_index_markers(d)));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Diagnostic: a resource's `(vtx_count, idx_count)` markers and vertex stride,
|
||||
/// as the stage anchor scan reads them from the descriptor.
|
||||
pub fn debug_resource_params(bytes: &[u8], name: &str) -> Option<(Vec<(usize, usize)>, usize)> {
|
||||
if bytes.len() < 16 || &bytes[..4] != b"XPR2" {
|
||||
return None;
|
||||
}
|
||||
let mut cur = Cursor::new(bytes);
|
||||
let header = Xpr2Header::read(&mut cur).ok()?;
|
||||
const DIR_BASE: usize = 0x10;
|
||||
for _ in 0..header.num_resources {
|
||||
let Ok(e) = Xpr2ResourceEntry::read(&mut cur) else { 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 rname = read_cstr(bytes, e.name_offset as usize + DIR_BASE)
|
||||
.unwrap_or_else(|| "XBG7".to_string());
|
||||
if rname != name {
|
||||
continue;
|
||||
}
|
||||
let d = &bytes[desc..desc_end];
|
||||
return Some((all_index_markers(d), parse_vertex_decl(d)?.stride));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Memoised whole-container decode, keyed by a cheap fingerprint of the bytes
|
||||
/// plus the consistency setting. Holds the last few containers; a stage decode is
|
||||
/// a handful of MB, and the alternative is re-anchoring every resource for every
|
||||
/// ship the viewer shows.
|
||||
fn full_decode_cached(
|
||||
bytes: &[u8],
|
||||
min_consistency: f32,
|
||||
should_cancel: &(dyn Fn() -> bool + Sync),
|
||||
) -> std::sync::Arc<Vec<Xbg7Model>> {
|
||||
use std::sync::{Arc, Mutex, OnceLock};
|
||||
// Fingerprint: length plus three sampled 4 KB windows. Two different
|
||||
// containers agreeing on all of that is not a case this format produces.
|
||||
let mut fp: u64 = 0xcbf2_9ce4_8422_2325 ^ bytes.len() as u64;
|
||||
let windows = [0usize, bytes.len() / 2, bytes.len().saturating_sub(4096)];
|
||||
for w in windows {
|
||||
for b in bytes.iter().skip(w).take(4096) {
|
||||
fp = (fp ^ *b as u64).wrapping_mul(0x100_0000_01b3);
|
||||
}
|
||||
}
|
||||
let key = (fp, min_consistency.to_bits());
|
||||
#[allow(clippy::type_complexity)]
|
||||
static CACHE: OnceLock<Mutex<Vec<((u64, u32), Arc<Vec<Xbg7Model>>)>>> = OnceLock::new();
|
||||
let cache = CACHE.get_or_init(|| Mutex::new(Vec::new()));
|
||||
if let Ok(c) = cache.lock() {
|
||||
if let Some((_, v)) = c.iter().find(|(k, _)| *k == key) {
|
||||
return Arc::clone(v);
|
||||
}
|
||||
}
|
||||
let models = Arc::new(Xbg7Model::anchor_models_uncached(
|
||||
bytes,
|
||||
min_consistency,
|
||||
should_cancel,
|
||||
None,
|
||||
));
|
||||
if let Ok(mut c) = cache.lock() {
|
||||
c.push((key, Arc::clone(&models)));
|
||||
if c.len() > 4 {
|
||||
c.remove(0);
|
||||
}
|
||||
}
|
||||
models
|
||||
}
|
||||
|
||||
/// Diagnostic: the candidate vertex-buffer starts the stage anchor scan will
|
||||
/// consider for a given `stride`, for one container. A runtime capture names the
|
||||
/// offsets the engine really drew from (see `examples/shared_vbase_check.rs`), so
|
||||
/// asking whether a proven offset is in this list separates the two possible
|
||||
/// root causes of a mis-anchor: **absent** ⇒ the run scan misses it, **present**
|
||||
/// ⇒ the scan sees it and the selection picks another.
|
||||
pub fn debug_vertex_run_starts(bytes: &[u8], stride: usize) -> Vec<usize> {
|
||||
if bytes.len() < 16 || &bytes[..4] != b"XPR2" {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut cur = Cursor::new(bytes);
|
||||
let Ok(header) = Xpr2Header::read(&mut cur) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let data_base = header.header_size as usize;
|
||||
if data_base >= bytes.len() {
|
||||
return Vec::new();
|
||||
}
|
||||
vertex_run_starts(bytes, data_base, stride)
|
||||
}
|
||||
|
||||
/// 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.
|
||||
@@ -1269,23 +652,9 @@ fn anchor_pool_mesh(
|
||||
vtx_count: usize,
|
||||
decl: &VertexDecl,
|
||||
min_consistency: f32,
|
||||
taken: &std::collections::HashSet<usize>,
|
||||
min_vb: usize,
|
||||
) -> Option<GameMesh> {
|
||||
let idx_bytes = index_count * 2;
|
||||
for &vb in starts {
|
||||
// Monotone assignment (opt-in): resources of one signature are laid out
|
||||
// in descriptor order, so a later one may not take an earlier block.
|
||||
if vb < min_vb {
|
||||
continue;
|
||||
}
|
||||
// A buffer another resource already claimed is not a candidate: the
|
||||
// engine draws each part from its own buffer (proved for the mirrored
|
||||
// `e106_bdy_0{1,2}_l` twins by a runtime capture), so two resources
|
||||
// landing on one offset means at least one of them is wrong.
|
||||
if taken.contains(&vb) {
|
||||
continue;
|
||||
}
|
||||
// The index buffer sits just before the vertex buffer, which is 4-byte
|
||||
// aligned — so 0..=3 bytes of padding may separate them (`ib = vb −
|
||||
// idx_bytes − pad`). pad 0 is the immediate-adjacency case (all stages so
|
||||
@@ -1298,14 +667,8 @@ fn anchor_pool_mesh(
|
||||
continue;
|
||||
}
|
||||
let ib = vb - idx_bytes - pad;
|
||||
// `XBG7_PAD0_CONSISTENCY` adds a winding requirement to the pad-0
|
||||
// path, which has none by default. Winding agreement is an objective
|
||||
// topology signal (≈1.0 or ≈0.0 for a real mesh, ≈0.5 for a
|
||||
// mis-carve) where the connectivity cap is a shape heuristic with a
|
||||
// capture-proven false positive — so it is the candidate replacement
|
||||
// for that cap. Off by default; see docs/re/structures/xbg7-mesh.md.
|
||||
let mc = if pad == 0 {
|
||||
min_consistency.max(pad0_consistency())
|
||||
min_consistency
|
||||
} else {
|
||||
min_consistency.max(0.85)
|
||||
};
|
||||
@@ -1336,43 +699,17 @@ fn validate_block(
|
||||
min_consistency: f32,
|
||||
strict_connectivity: bool,
|
||||
) -> bool {
|
||||
validate_block_report(
|
||||
bytes,
|
||||
ib,
|
||||
vb,
|
||||
vtx_count,
|
||||
index_count,
|
||||
decl,
|
||||
min_consistency,
|
||||
strict_connectivity,
|
||||
)
|
||||
.is_ok()
|
||||
}
|
||||
|
||||
/// [`validate_block`], but naming the gate that rejected a block. A runtime
|
||||
/// capture can prove a block is real; when the decoder still refuses it, this
|
||||
/// says which test is wrong rather than leaving a threshold to be guessed at.
|
||||
fn validate_block_report(
|
||||
bytes: &[u8],
|
||||
ib: usize,
|
||||
vb: usize,
|
||||
vtx_count: usize,
|
||||
index_count: usize,
|
||||
decl: &VertexDecl,
|
||||
min_consistency: f32,
|
||||
strict_connectivity: bool,
|
||||
) -> Result<(), String> {
|
||||
let stride = decl.stride;
|
||||
let idx_bytes = index_count * 2;
|
||||
if ib + idx_bytes > bytes.len() {
|
||||
return Err("index buffer runs past the container".into());
|
||||
return false;
|
||||
}
|
||||
let vtx_bytes = match vtx_count.checked_mul(stride) {
|
||||
Some(v) => v,
|
||||
None => return Err("vertex byte count overflows".into()),
|
||||
None => return false,
|
||||
};
|
||||
if vb + vtx_bytes > bytes.len() {
|
||||
return Err("vertex buffer runs past the container".into());
|
||||
return false;
|
||||
}
|
||||
|
||||
// ── Full index validation: every index in range, uses ~all vertices. ──
|
||||
@@ -1380,14 +717,12 @@ fn validate_block_report(
|
||||
for k in 0..index_count {
|
||||
let i = be16(bytes, ib + k * 2) as u32;
|
||||
if i >= vtx_count as u32 {
|
||||
return Err(format!("index {i} out of range (vtx_count {vtx_count})"));
|
||||
return false;
|
||||
}
|
||||
max_idx = max_idx.max(i);
|
||||
}
|
||||
if (max_idx as usize) + cover_slack() < vtx_count {
|
||||
return Err(format!(
|
||||
"indices reach only {max_idx} of {vtx_count} vertices (buffer not covered)"
|
||||
));
|
||||
if (max_idx as usize) + 4 < vtx_count {
|
||||
return false;
|
||||
}
|
||||
|
||||
// ── Triangle quality: finite, non-degenerate, real spatial extent. ──
|
||||
@@ -1412,7 +747,7 @@ fn validate_block_report(
|
||||
for (a, slot) in pc.iter_mut().enumerate() {
|
||||
let x = bef(bytes, base + a * 4);
|
||||
if !x.is_finite() || x.abs() > 1.0e6 {
|
||||
return Err(format!("position component {x} is not finite/plausible"));
|
||||
return false;
|
||||
}
|
||||
*slot = x;
|
||||
lo[a] = lo[a].min(x);
|
||||
@@ -1426,21 +761,7 @@ fn validate_block_report(
|
||||
u[2] * w[0] - u[0] * w[2],
|
||||
u[0] * w[1] - u[1] * w[0],
|
||||
];
|
||||
// Degeneracy = collinear vertices, which is a SCALE-FREE property:
|
||||
// compare the cross-product magnitude to the two edge lengths that
|
||||
// produced it (i.e. sin of the angle between them). The old absolute
|
||||
// `area < 1e-9` test called a small object's every triangle degenerate —
|
||||
// `g005` spans 0.346 units and scored 7 of 8 — so it rejected tiny props
|
||||
// for being tiny. `XBG7_ABS_DEGEN=1` restores the absolute test.
|
||||
let cross = (cx[0] * cx[0] + cx[1] * cx[1] + cx[2] * cx[2]).sqrt();
|
||||
let un = (u[0] * u[0] + u[1] * u[1] + u[2] * u[2]).sqrt();
|
||||
let wn = (w[0] * w[0] + w[1] * w[1] + w[2] * w[2]).sqrt();
|
||||
let is_degenerate = if rel_degen() {
|
||||
cross < 1.0e-6 * un * wn || un == 0.0 || wn == 0.0
|
||||
} else {
|
||||
0.5 * cross < 1.0e-9
|
||||
};
|
||||
if is_degenerate {
|
||||
if 0.5 * (cx[0] * cx[0] + cx[1] * cx[1] + cx[2] * cx[2]).sqrt() < 1.0e-9 {
|
||||
degenerate += 1;
|
||||
} else if let Some(no) = decl.normal_offset {
|
||||
// Stored-normal agreement: the face normal should point the way
|
||||
@@ -1467,10 +788,8 @@ fn validate_block_report(
|
||||
t += tstep;
|
||||
}
|
||||
let extent = (hi[0] - lo[0]).max(hi[1] - lo[1]).max(hi[2] - lo[2]);
|
||||
if extent < min_extent() || sampled == 0 || degenerate * 10 > sampled * 3 {
|
||||
return Err(format!(
|
||||
"extent {extent:.3} (min 0.5), {degenerate}/{sampled} degenerate (max 30%)"
|
||||
));
|
||||
if extent < 0.5 || sampled == 0 || degenerate * 10 > sampled * 3 {
|
||||
return false; // 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
|
||||
@@ -1486,17 +805,8 @@ fn validate_block_report(
|
||||
.sqrt()
|
||||
.max(1e-6);
|
||||
let mean_edge = edge_sum / (sampled as f32 * 3.0);
|
||||
// A COARSE block is coarse by construction: a 24-triangle LOD's edges
|
||||
// are a large fraction of its own size, which is why the flat cap has a
|
||||
// capture-proven false positive (`e106_eng_02_l`, ratio 0.417). Under
|
||||
// `XBG7_SMALL_TRIS` blocks below that triangle count get the looser
|
||||
// `XBG7_EDGE_CAP_SMALL` instead — a targeted relaxation, off by default.
|
||||
let cap = if tris < small_tris() { small_cap() } else { edge_cap() };
|
||||
if mean_edge / diag > cap {
|
||||
return Err(format!(
|
||||
"connectivity: mean_edge/diag {:.3} > cap {cap:.2}",
|
||||
mean_edge / diag
|
||||
));
|
||||
if mean_edge / diag > 0.28 {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// Winding-consistency gate (same as `from_xpr2`): a correctly-anchored
|
||||
@@ -1508,13 +818,10 @@ fn validate_block_report(
|
||||
if nrm_counted > 0 && min_consistency > 0.0 {
|
||||
let na = nrm_agree as f32 / nrm_counted as f32;
|
||||
if na.max(1.0 - na) < min_consistency {
|
||||
return Err(format!(
|
||||
"winding consistency {:.3} < {min_consistency:.2}",
|
||||
na.max(1.0 - na)
|
||||
));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
true
|
||||
}
|
||||
|
||||
/// Decode a **grouped-pool** XBG7 resource: one whose descriptor holds *several*
|
||||
@@ -1547,7 +854,6 @@ fn anchor_grouped_meshes(
|
||||
starts: &[usize],
|
||||
markers: &[(usize, usize)], // (vtx_count, idx_count) in descriptor/file order
|
||||
decl: &VertexDecl,
|
||||
taken: &std::collections::HashSet<usize>,
|
||||
) -> Vec<GameMesh> {
|
||||
let n = markers.len();
|
||||
if n == 0 {
|
||||
@@ -1583,11 +889,6 @@ fn anchor_grouped_meshes(
|
||||
let (vck, ick) = markers[kmax];
|
||||
|
||||
for &vb0 in starts {
|
||||
// Distinct assignment: a pool another resource already claimed is not a
|
||||
// candidate (see the collision resolution in `anchor_models_filtered`).
|
||||
if taken.contains(&vb0) {
|
||||
continue;
|
||||
}
|
||||
for pad in 0..=3usize {
|
||||
if vb0 < span + pad {
|
||||
continue;
|
||||
@@ -1602,7 +903,7 @@ fn anchor_grouped_meshes(
|
||||
// collapses well below 0.85, so only the true pad/pivot passes.
|
||||
let ib_k = ib0 + rel_ib[kmax];
|
||||
let vb_k = vb0 + off_v[kmax];
|
||||
if !validate_block(bytes, ib_k, vb_k, vck, ick, decl, grouped_consistency(), true) {
|
||||
if !validate_block(bytes, ib_k, vb_k, vck, ick, decl, 0.85, true) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -1628,28 +929,7 @@ fn anchor_grouped_meshes(
|
||||
if !ok && i > kmax {
|
||||
break; // chain diverged — emit the validated prefix, no garbage
|
||||
}
|
||||
// Sub-meshes BEFORE the pivot are emitted even when they fail the
|
||||
// quality gates (a tiny flat lead part is legitimately poor), but
|
||||
// an index that addresses past its own vertex buffer is not a
|
||||
// quality question — it is unusable. Measured 2026-08-12: 18
|
||||
// sub-meshes disc-wide carried indices up to 364 vertices past
|
||||
// the end (`coverage_audit`), which any renderer would fault on.
|
||||
// Same two structural requirements the searched path enforces:
|
||||
// every index inside the buffer, and the indices reaching the
|
||||
// end of it. Real geometry covers its pool exactly — 8 586 of
|
||||
// 8 636 decoded sub-meshes reference their last vertex, none
|
||||
// more than 3 short (`coverage_audit`) — so a sub-mesh whose
|
||||
// indices stop well short is reading the wrong block, not a
|
||||
// sparse one.
|
||||
let mut max_idx = 0usize;
|
||||
let in_range = (0..ic).all(|k| {
|
||||
let i = be16(bytes, ib + k * 2) as usize;
|
||||
max_idx = max_idx.max(i);
|
||||
i < vc
|
||||
});
|
||||
if in_range && max_idx + cover_slack() >= vc {
|
||||
meshes.push(read_pool_mesh(bytes, ib, vb, ic, vc, decl));
|
||||
}
|
||||
meshes.push(read_pool_mesh(bytes, ib, vb, ic, vc, decl));
|
||||
vb += vc * stride;
|
||||
}
|
||||
return meshes;
|
||||
@@ -1696,7 +976,6 @@ fn read_pool_mesh(
|
||||
uvs,
|
||||
indices,
|
||||
name: None,
|
||||
vbuf_offset: Some(vb),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -349,21 +349,9 @@ pub fn assemble_ship(bytes: &[u8], id: &str, include_external: bool) -> Vec<Scen
|
||||
let Some((_, gncat)) = CATS.iter().find(|(c, _)| *c == cat) else {
|
||||
continue;
|
||||
};
|
||||
// An index-less part (`e105_brg`, against a `GN_Bridge_01` frame) used to
|
||||
// compare `"01" == ""` and fall through, so the bridge was silently
|
||||
// dropped from the assembly while the game draws it — caught by a runtime
|
||||
// capture, which places `e105_brg` at the `GN_Bridge_01` frame exactly.
|
||||
// With no index to match on, take the lowest-numbered frame of the
|
||||
// category; an indexed part still matches its own index only.
|
||||
let mut cands: Vec<&ScenePart> = frames
|
||||
.iter()
|
||||
.filter(|f| {
|
||||
f.resource.contains(gncat)
|
||||
&& (idx.is_empty() || trailing_index(&f.resource) == idx)
|
||||
})
|
||||
.collect();
|
||||
cands.sort_by_key(|f| trailing_index(&f.resource).parse::<u32>().unwrap_or(u32::MAX));
|
||||
if let Some(frame) = cands.first().copied() {
|
||||
if let Some(frame) =
|
||||
frames.iter().find(|f| f.resource.contains(gncat) && trailing_index(&f.resource) == idx)
|
||||
{
|
||||
placed.push(ScenePart { resource: part.clone(), m: frame.m, t: frame.t, s: frame.s });
|
||||
placed_res.insert(part.clone());
|
||||
}
|
||||
@@ -615,44 +603,18 @@ mod tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
// ── Extras: the direction this test could not previously fail in. ──
|
||||
// The loop above walks the CAPTURE's parts and looks each up in ours, so
|
||||
// a static placement with no counterpart was invisible to it — which is
|
||||
// how a resource decoded 100x too large (`e303_wep_01`, 2026-08-12) sat
|
||||
// here unnoticed. Pin the set instead: the capture legitimately misses
|
||||
// repeated instances of a shared resource (vbase dedup), so `e303_wep_01`
|
||||
// is expected; anything else appearing only in the static assembly is a
|
||||
// regression.
|
||||
let captured: std::collections::BTreeSet<&str> =
|
||||
cap.parts.iter().map(|p| p.part.as_str()).collect();
|
||||
let extra: std::collections::BTreeSet<&str> = placed
|
||||
.iter()
|
||||
.map(|p| p.resource.as_str())
|
||||
.filter(|r| !captured.contains(r))
|
||||
.collect();
|
||||
let allowed: std::collections::BTreeSet<&str> = ["e303_wep_01"].into_iter().collect();
|
||||
assert_eq!(
|
||||
extra, allowed,
|
||||
"static placements with no counterpart in the runtime capture"
|
||||
);
|
||||
|
||||
// Multi-instance coverage the capture couldn't see (vbase dedup).
|
||||
let count = |res: &str| placed.iter().filter(|p| p.resource == res).count();
|
||||
assert_eq!(count("e106_eng_01"), 2, "both engine nacelles placed");
|
||||
assert_eq!(count("e303_wep_01"), 2, "both shared turrets placed");
|
||||
// NEITHER hull reflects: the twins' geometry is mirrored on the disc,
|
||||
// so both placements are proper rotations. This flipped on 2026-08-12 —
|
||||
// while both twins decoded to one buffer, `apply_twin_mirrors` had to
|
||||
// synthesise the reflection here; a runtime capture showed the container
|
||||
// holds both halves, and distinct anchor assignment now hands each twin
|
||||
// its own (see docs/re/structures/xbg7-mesh.md).
|
||||
// The mirrored starboard hull reflects (det < 0), the port one doesn't.
|
||||
let det = |m: &[[f32; 3]; 3]| {
|
||||
m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
|
||||
- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
|
||||
+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0])
|
||||
};
|
||||
let one = |res: &str| placed.iter().find(|p| p.resource == res).unwrap();
|
||||
assert!(det(&one("e106_bdy_02").m) > 0.0, "starboard hull plain (mirror is in the data)");
|
||||
assert!(det(&one("e106_bdy_02").m) < 0.0, "starboard hull mirrored");
|
||||
assert!(det(&one("e106_bdy_01").m) > 0.0, "port hull plain");
|
||||
}
|
||||
|
||||
|
||||
@@ -183,41 +183,6 @@ pub const SHIP_VS_HASH: &str = "0xC7F781F4C1D58054";
|
||||
/// with `vs=`[`SHIP_VS_HASH`] are kept (the ship shader), so HUD/skybox draws are
|
||||
/// ignored. (The player fighter shares ONE buffer across its fin draws and so
|
||||
/// collapses to a single entry here — fine, capital ships are the target.)
|
||||
/// Split a capture into blocks that are guaranteed to share one camera.
|
||||
///
|
||||
/// **Why this is not optional.** One F10 press dumps a flat list of draws with
|
||||
/// no frame delimiter, and it spans ~14 frames (the same vertex buffer recurs
|
||||
/// that many times). The placement math is `WV_ref⁻¹ · WV_p`, which cancels the
|
||||
/// camera **only when both draws come from the same frame** — mix frames and
|
||||
/// the residual is the camera's motion between them. With a static ship and a
|
||||
/// static camera that error is invisible, which is how the single validated
|
||||
/// `e106` capture passed; closing on a cruiser at ~760 u/s it is hundreds of
|
||||
/// units, and two frames of the same ship then disagree about where its parts
|
||||
/// are (measured 2026-08-10: `f105_bdy_02` at `[488, 736, -620]` vs
|
||||
/// `[0, 0, -1090]`).
|
||||
///
|
||||
/// The split rule is the recurrence itself: a vertex buffer that appears again
|
||||
/// starts a new block. Splitting too eagerly is harmless (a block is still one
|
||||
/// camera, just with fewer parts in it) and it separates two instances of the
|
||||
/// same class as a bonus; failing to split is what corrupts the result.
|
||||
pub fn segment_frames(draws: &[CapturedDraw]) -> Vec<Vec<CapturedDraw>> {
|
||||
let mut out: Vec<Vec<CapturedDraw>> = Vec::new();
|
||||
let mut cur: Vec<CapturedDraw> = Vec::new();
|
||||
let mut seen: std::collections::HashSet<u32> = std::collections::HashSet::new();
|
||||
for d in draws {
|
||||
if !seen.insert(d.vbase) {
|
||||
out.push(std::mem::take(&mut cur));
|
||||
seen.clear();
|
||||
seen.insert(d.vbase);
|
||||
}
|
||||
cur.push(d.clone());
|
||||
}
|
||||
if !cur.is_empty() {
|
||||
out.push(cur);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn parse_drawlog(text: &str) -> Vec<CapturedDraw> {
|
||||
let mut out = Vec::new();
|
||||
let mut seen: std::collections::HashSet<u32> = std::collections::HashSet::new();
|
||||
@@ -717,17 +682,10 @@ mod tests {
|
||||
assert_eq!(e106.reference, "e106_bdy_04");
|
||||
assert_eq!(e106.parts.len(), 8, "all 8 e106 parts placed");
|
||||
let get = |p: &str| e106.parts.iter().find(|x| x.part == p).unwrap();
|
||||
// Port/starboard hull pair: X = ∓264, **both plain**. The mirror is
|
||||
// baked into the disc data, not into the placement: a runtime capture
|
||||
// shows the container carrying two 119-vertex buffers whose contents are
|
||||
// exact X-reflections, each drawn from its own address (see
|
||||
// docs/re/structures/xbg7-mesh.md). Until 2026-08-12 both twins decoded
|
||||
// to ONE buffer and this row carried diag(-1,1,1) to compensate; with
|
||||
// distinct anchor assignment they decode to their own, and re-emitting
|
||||
// from the capture produces identity here.
|
||||
// Port/starboard hull pair: X = ∓264, the starboard copy mirrored.
|
||||
assert!((get("e106_bdy_01").t[0] + 264.0).abs() < 0.1);
|
||||
assert!((get("e106_bdy_02").t[0] - 264.0).abs() < 0.1);
|
||||
assert_eq!(get("e106_bdy_02").m[0][0], 1.0);
|
||||
assert_eq!(get("e106_bdy_02").m[0][0], -1.0);
|
||||
assert_eq!(get("e106_bdy_01").m[0][0], 1.0);
|
||||
// Bridge: centreline, above and aft of the hull reference.
|
||||
let brg = get("e106_brg_01");
|
||||
|
||||
@@ -1,28 +1,20 @@
|
||||
//! `T8aD` — the game's 2D UI/HUD texture format.
|
||||
//!
|
||||
//! A 32bpp **A8R8G8B8** (Xbox byte order) surface stored as a list of
|
||||
//! **arbitrary sub-rectangles**, each with its own destination origin and size.
|
||||
//! Reversed 2026-07-17 (verified against the running game's title screen) and
|
||||
//! **corrected 2026-08-11**, when the per-tile header turned out to carry the
|
||||
//! rectangle's placement rather than being opaque flags.
|
||||
//! A 32bpp **A8R8G8B8** (Xbox byte order) surface stored as **256×256 raster
|
||||
//! tiles in row-major order** — each tile prefixed by a 16-byte tile header, edge
|
||||
//! tiles clipped to the image bounds. Fully reversed 2026-07-17 from the file
|
||||
//! header and verified against the running game (title screen).
|
||||
//!
|
||||
//! ```text
|
||||
//! 0x00 4 Magic "T8aD"
|
||||
//! 0x14 4 width (BE u32) the full surface
|
||||
//! 0x14 4 width (BE u32)
|
||||
//! 0x18 4 height (BE u32)
|
||||
//! 0x1c 4 rectangle count (BE u32) — NOT ceil(w/256)*ceil(h/256)
|
||||
//! 0x2c count*4 offset table: absolute byte offset of each rectangle
|
||||
//! <off> 16 rectangle header, four BE u32: dst X, dst Y, width, height
|
||||
//! <off+16> width * height * 4 bytes of A8R8G8B8 pixels, row-major
|
||||
//! 0x1c 4 tile count (BE u32) = ceil(w/256) * ceil(h/256)
|
||||
//! 0x2c tiles*4 offset table: absolute byte offset of each row-major tile
|
||||
//! <off> 16 per-tile header (flags + tile w/h), then:
|
||||
//! <off+16> tile_w * tile_h * 4 bytes of A8R8G8B8 pixels, row-major
|
||||
//! ```
|
||||
//!
|
||||
//! Most surfaces happen to be stored as full-width 256-tall bands, which is why
|
||||
//! treating the file as a 256×256 grid decoded 96 % of the disc correctly. It is
|
||||
//! not the model, though: a dialogue strip declares 524×63 and stores **one**
|
||||
//! 173×25 rectangle at (175,20), and `pdmes010` stores two — (59,6,256,54) and
|
||||
//! (315,6,149,54), the second beginning exactly `16 + 256*54*4` bytes after the
|
||||
//! first. Anything the rectangles do not cover stays transparent.
|
||||
//!
|
||||
//! Surfaces ≤256px wide are a single tile column, so the first tile's pixels sit
|
||||
//! at `44 + tiles*4 + 16 = 64` — which is why the old "type→header size 64/84/…"
|
||||
//! rule (header = 44 + tiles*20) happened to decode small textures correctly: for
|
||||
@@ -51,11 +43,18 @@ fn be32(b: &[u8], off: usize) -> u32 {
|
||||
}
|
||||
|
||||
/// Side of the square storage tile, in texels, and the per-tile header size.
|
||||
/// Bytes of per-rectangle header before its pixels: dst X, dst Y, w, h.
|
||||
const RECT_HDR: usize = 16;
|
||||
const TILE: usize = 256;
|
||||
const TILE_HDR: usize = 16;
|
||||
|
||||
/// Decode a T8aD surface from a slice whose first bytes ARE the magic. Returns
|
||||
/// `None` if any rectangle fails to fit the surface or the file — never guesses.
|
||||
/// `None` for non-T8aD input or a variant we can't decode as RGBA (never guesses).
|
||||
///
|
||||
/// Layout (reversed from the header + verified against the running game):
|
||||
/// a 44-byte base header, then a `tiles`-entry big-endian u32 **offset table** at
|
||||
/// `0x2c`, where `tiles` = the field at `0x1c` = `ceil(w/256) * ceil(h/256)`.
|
||||
/// Each entry is the absolute byte offset of a **row-major** 256×256 tile; every
|
||||
/// tile is a 16-byte tile header followed by `tile_w*tile_h*4` A8R8G8B8 pixels,
|
||||
/// edge tiles clipped to the image bounds.
|
||||
pub fn parse(bytes: &[u8]) -> Option<T8adImage> {
|
||||
if !is_t8ad(bytes) || bytes.len() < 0x40 {
|
||||
return None;
|
||||
@@ -65,45 +64,41 @@ pub fn parse(bytes: &[u8]) -> Option<T8adImage> {
|
||||
if !(1..=4096).contains(&width) || !(1..=4096).contains(&height) {
|
||||
return None;
|
||||
}
|
||||
let rects = be32(bytes, 0x1c) as usize;
|
||||
if rects == 0 || rects > 4096 {
|
||||
let tiles = be32(bytes, 0x1c) as usize;
|
||||
let cols = width.div_ceil(TILE);
|
||||
let rows = height.div_ceil(TILE);
|
||||
// The field at 0x1c must be the tile count; otherwise it's a variant we don't
|
||||
// decode (e.g. DXT / palettized) — defer rather than misdecode.
|
||||
if tiles == 0 || tiles != cols * rows {
|
||||
return None;
|
||||
}
|
||||
const TABLE: usize = 0x2c;
|
||||
if bytes.len() < TABLE + rects * 4 {
|
||||
if bytes.len() < TABLE + tiles * 4 {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Anything no rectangle covers stays transparent.
|
||||
let mut rgba = vec![0u8; width * height * 4];
|
||||
for r in 0..rects {
|
||||
let at = be32(bytes, TABLE + r * 4) as usize;
|
||||
if at + RECT_HDR > bytes.len() {
|
||||
return None;
|
||||
}
|
||||
let dx = be32(bytes, at) as usize;
|
||||
let dy = be32(bytes, at + 4) as usize;
|
||||
let rw = be32(bytes, at + 8) as usize;
|
||||
let rh = be32(bytes, at + 12) as usize;
|
||||
// Never guess: a rectangle must fit the surface and its pixels the file.
|
||||
if rw == 0 || rh == 0 || dx + rw > width || dy + rh > height {
|
||||
return None;
|
||||
}
|
||||
let pixels = at + RECT_HDR;
|
||||
if pixels + rw * rh * 4 > bytes.len() {
|
||||
return None;
|
||||
}
|
||||
for row in 0..rh {
|
||||
let mut s = pixels + row * rw * 4;
|
||||
let mut d = ((dy + row) * width + dx) * 4;
|
||||
for _ in 0..rw {
|
||||
// A8R8G8B8 → RGBA8.
|
||||
rgba[d] = bytes[s + 1];
|
||||
rgba[d + 1] = bytes[s + 2];
|
||||
rgba[d + 2] = bytes[s + 3];
|
||||
rgba[d + 3] = bytes[s];
|
||||
s += 4;
|
||||
d += 4;
|
||||
for ty in 0..rows {
|
||||
for tx in 0..cols {
|
||||
let tile = ty * cols + tx;
|
||||
let pixels = be32(bytes, TABLE + tile * 4) as usize + TILE_HDR;
|
||||
let tw = TILE.min(width - tx * TILE);
|
||||
let th = TILE.min(height - ty * TILE);
|
||||
if pixels + tw * th * 4 > bytes.len() {
|
||||
return None; // truncated / not the layout we expect
|
||||
}
|
||||
for row in 0..th {
|
||||
let mut s = pixels + row * tw * 4;
|
||||
let mut d = ((ty * TILE + row) * width + tx * TILE) * 4;
|
||||
for _ in 0..tw {
|
||||
// A8R8G8B8 → RGBA8.
|
||||
rgba[d] = bytes[s + 1];
|
||||
rgba[d + 1] = bytes[s + 2];
|
||||
rgba[d + 2] = bytes[s + 3];
|
||||
rgba[d + 3] = bytes[s];
|
||||
s += 4;
|
||||
d += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -128,11 +123,7 @@ mod tests {
|
||||
b[0x18..0x1c].copy_from_slice(&h.to_be_bytes());
|
||||
b[0x1c..0x20].copy_from_slice(&1u32.to_be_bytes()); // 1 tile
|
||||
b.extend_from_slice(&0x30u32.to_be_bytes()); // offset table: tile 0 @ 0x30
|
||||
// rectangle header: dst (0,0), size w×h
|
||||
b.extend_from_slice(&0u32.to_be_bytes());
|
||||
b.extend_from_slice(&0u32.to_be_bytes());
|
||||
b.extend_from_slice(&w.to_be_bytes());
|
||||
b.extend_from_slice(&h.to_be_bytes());
|
||||
b.extend_from_slice(&[0u8; 16]); // 16-byte tile header → pixels at 0x40
|
||||
for i in 0..(w * h) {
|
||||
b.extend_from_slice(&[(i & 0xff) as u8, 0x24, 0x63, 0xB2]); // A, R, G, B
|
||||
}
|
||||
@@ -152,8 +143,8 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn assembles_rectangles_via_offset_table() {
|
||||
// 300×1 → 2 rectangles: (0,0) 256×1 red, then (256,0) 44×1 blue.
|
||||
fn assembles_row_major_tiles_via_offset_table() {
|
||||
// 300×1 → 2 tiles: (0,0)=256×1 red, (1,0)=44×1 blue, each +16-byte header.
|
||||
let (w, h): (u32, u32) = (300, 1);
|
||||
let mut b = vec![0u8; 0x2c];
|
||||
b[0..4].copy_from_slice(&T8AD_MAGIC);
|
||||
@@ -164,9 +155,9 @@ mod tests {
|
||||
let off1 = off0 + 16 + 256 * 4; // tile-0 header + its 256 pixels
|
||||
b.extend_from_slice(&(off0 as u32).to_be_bytes());
|
||||
b.extend_from_slice(&(off1 as u32).to_be_bytes());
|
||||
for v in [0u32, 0, 256, 1] { b.extend_from_slice(&v.to_be_bytes()) } // dst(0,0) 256×1
|
||||
b.extend_from_slice(&[0u8; 16]);
|
||||
b.extend_from_slice(&[0xFF, 0xFF, 0, 0].repeat(256)); // A,R,G,B red
|
||||
for v in [256u32, 0, 44, 1] { b.extend_from_slice(&v.to_be_bytes()) } // dst(256,0) 44×1
|
||||
b.extend_from_slice(&[0u8; 16]);
|
||||
b.extend_from_slice(&[0xFF, 0, 0, 0xFF].repeat(44)); // A,R,G,B blue
|
||||
let img = parse(&b).expect("decodes");
|
||||
assert_eq!((img.width, img.height), (300, 1));
|
||||
@@ -175,11 +166,10 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_out_of_range_rect_and_short() {
|
||||
// a rectangle that does not fit the declared surface → None, never guess
|
||||
fn rejects_wrong_tilecount_and_short() {
|
||||
// tile-count field that isn't ceil(w/256)*ceil(h/256) → None
|
||||
let mut b = synth(2, 2);
|
||||
let at = 0x2c + 4;
|
||||
b[at + 8..at + 12].copy_from_slice(&99u32.to_be_bytes()); // width 99 > 2
|
||||
b[0x1c..0x20].copy_from_slice(&7u32.to_be_bytes());
|
||||
assert!(parse(&b).is_none());
|
||||
// truncated pixel data → None
|
||||
let b = synth(64, 64);
|
||||
|
||||
282
crates/sylpheed-formats/src/ui_layout.rs
Normal file
282
crates/sylpheed-formats/src/ui_layout.rs
Normal file
@@ -0,0 +1,282 @@
|
||||
//! `.rat` UI-screen layout — reassemble a UI screen from its pak.
|
||||
//!
|
||||
//! A UI screen ships as one pak (`GP_TITLE`, `GP_PAUSE_MENU`, …). Inside it,
|
||||
//! each large [RATC](crate::ratc) bundle is one *(context × language)* **build**
|
||||
//! of the screen, holding its `<name>.t32` sprites and `<name>.rat` layout
|
||||
//! records side by side. Each `.rat` record is itself a RATC-tagged blob that
|
||||
//! places one sprite; this module parses those records and composites the
|
||||
//! sprites back into the screen image.
|
||||
//!
|
||||
//! Format reverse-engineered in `docs/re/structures/ui-rat-layout.md` and
|
||||
//! validated here against `GP_PAUSE_MENU.pak` / `GP_TITLE.pak`: the pause menu's
|
||||
//! `pgpbtn00/01/04/15.rat` read X=226, Y=268/337/407/478 (the documented 70 px
|
||||
//! pitch), and focus records land 42 px left / 8 px up of their base.
|
||||
|
||||
use crate::{ratc, t8ad};
|
||||
use std::collections::HashMap;
|
||||
|
||||
fn be32(b: &[u8], o: usize) -> u32 {
|
||||
u32::from_be_bytes([b[o], b[o + 1], b[o + 2], b[o + 3]])
|
||||
}
|
||||
|
||||
/// One sprite placement parsed from a `.rat` record.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Placement {
|
||||
/// The `.rat` record's own name (e.g. `pgpbtn00.rat`).
|
||||
pub record: String,
|
||||
/// The `.t32` sprite this record places (from record offset 0x20).
|
||||
pub sprite: String,
|
||||
/// Top-left position in the design space (X/Y from the placement block).
|
||||
pub x: u32,
|
||||
pub y: u32,
|
||||
/// Scale in percent (100 = 1:1).
|
||||
pub scale_x: u32,
|
||||
pub scale_y: u32,
|
||||
/// RGBA tint (`0xffffffff` = untinted).
|
||||
pub tint: u32,
|
||||
/// A `*f.rat` focus-state record (draws the selection art).
|
||||
pub focused: bool,
|
||||
/// A `loopN.rat` / keyframed record — its first frame is taken.
|
||||
pub animated: bool,
|
||||
}
|
||||
|
||||
/// A parsed UI build: one screen layout (one context × language).
|
||||
pub struct UiBuild {
|
||||
/// Design-space dimensions, normally 1280×720.
|
||||
pub design_w: u32,
|
||||
pub design_h: u32,
|
||||
/// Every `.rat` placement in draw order.
|
||||
pub placements: Vec<Placement>,
|
||||
/// Sprite name → (offset, size) of its `T8aD` child within the bundle.
|
||||
pub sprites: HashMap<String, (usize, usize)>,
|
||||
/// A guessed context from the sprite naming (e.g. `"tutorial"`), if any.
|
||||
pub context_hint: Option<String>,
|
||||
}
|
||||
|
||||
/// Whether `bundle` is a RATC build (has at least one `.rat` layout child).
|
||||
pub fn is_build(bundle: &[u8]) -> bool {
|
||||
ratc::is_ratc(bundle)
|
||||
&& ratc::parse(bundle).is_some_and(|kids| {
|
||||
kids.iter()
|
||||
.any(|c| c.name.to_ascii_lowercase().ends_with(".rat"))
|
||||
})
|
||||
}
|
||||
|
||||
/// Parse one `.rat` record (a RATC-tagged placement blob) → a [`Placement`].
|
||||
fn parse_record(name: &str, rec: &[u8]) -> Option<Placement> {
|
||||
if rec.len() < 0x58 || rec[0..4] != *b"RATC" {
|
||||
return None;
|
||||
}
|
||||
let dw = be32(rec, 0x18);
|
||||
let dh = be32(rec, 0x1c);
|
||||
if dw == 0 || dh == 0 || dw > 8192 || dh > 8192 {
|
||||
return None;
|
||||
}
|
||||
// Sprite name: NUL-terminated ASCII at 0x20 (up to 16 bytes).
|
||||
let sname = {
|
||||
let s = &rec[0x20..0x30.min(rec.len())];
|
||||
let end = s.iter().position(|&b| b == 0).unwrap_or(s.len());
|
||||
String::from_utf8_lossy(&s[..end]).trim().to_string()
|
||||
};
|
||||
if sname.is_empty() {
|
||||
return None;
|
||||
}
|
||||
// Placement block: [scaleX=100, scaleY=100, tint, X, Y] — the first such run
|
||||
// whose X/Y fall inside the design space (records are tag-driven/variable, so
|
||||
// this anchor is more robust than a fixed offset). See the format doc.
|
||||
let mut placement = None;
|
||||
let mut o = 0x58;
|
||||
while o + 20 <= rec.len() {
|
||||
if be32(rec, o) == 100 && be32(rec, o + 4) == 100 {
|
||||
let (tint, x, y) = (be32(rec, o + 8), be32(rec, o + 12), be32(rec, o + 16));
|
||||
if x < dw && y < dh {
|
||||
placement = Some((tint, x, y));
|
||||
break;
|
||||
}
|
||||
}
|
||||
o += 4;
|
||||
}
|
||||
let (tint, x, y) = placement?;
|
||||
let lname = name.to_ascii_lowercase();
|
||||
Some(Placement {
|
||||
record: name.to_string(),
|
||||
sprite: sname,
|
||||
x,
|
||||
y,
|
||||
scale_x: 100,
|
||||
scale_y: 100,
|
||||
tint,
|
||||
focused: lname.ends_with("f.rat"),
|
||||
animated: lname.contains("loop"),
|
||||
})
|
||||
}
|
||||
|
||||
/// Parse a build bundle into its placements and sprite table.
|
||||
pub fn parse_build(bundle: &[u8]) -> Option<UiBuild> {
|
||||
let kids = ratc::parse(bundle)?;
|
||||
let mut sprites = HashMap::new();
|
||||
let mut placements = Vec::new();
|
||||
for c in &kids {
|
||||
let lname = c.name.to_ascii_lowercase();
|
||||
let end = (c.offset + c.size).min(bundle.len());
|
||||
if c.kind == "T8aD" {
|
||||
sprites.insert(c.name.clone(), (c.offset, end - c.offset));
|
||||
} else if lname.ends_with(".rat") {
|
||||
if let Some(p) = parse_record(&c.name, &bundle[c.offset..end]) {
|
||||
placements.push(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
if placements.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let (design_w, design_h) = placements
|
||||
.iter()
|
||||
.find_map(|_| {
|
||||
// design dims are constant across records; re-read the first record
|
||||
kids.iter()
|
||||
.find(|c| c.name.to_ascii_lowercase().ends_with(".rat"))
|
||||
.map(|c| {
|
||||
let r = &bundle[c.offset..(c.offset + c.size).min(bundle.len())];
|
||||
(be32(r, 0x18), be32(r, 0x1c))
|
||||
})
|
||||
})
|
||||
.unwrap_or((1280, 720));
|
||||
let context_hint = sprites
|
||||
.keys()
|
||||
.find_map(|n| n.contains("ttrl").then(|| "tutorial".to_string()));
|
||||
Some(UiBuild {
|
||||
design_w,
|
||||
design_h,
|
||||
placements,
|
||||
sprites,
|
||||
context_hint,
|
||||
})
|
||||
}
|
||||
|
||||
/// A composited screen image ready to display.
|
||||
pub struct ComposedScreen {
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
/// Row-major RGBA8.
|
||||
pub rgba: Vec<u8>,
|
||||
/// Names of the records actually drawn.
|
||||
pub drawn: Vec<String>,
|
||||
}
|
||||
|
||||
/// Composite a build into its screen image.
|
||||
///
|
||||
/// Draws every base placement (title + menu items). Animated `loop*` records are
|
||||
/// skipped (they're decorations without a static position); `*f` focus records
|
||||
/// are skipped unless `include_focus`. Sprites are alpha-blended at their
|
||||
/// top-left with their tint applied.
|
||||
pub fn compose_build(bundle: &[u8], include_focus: bool) -> Option<ComposedScreen> {
|
||||
let build = parse_build(bundle)?;
|
||||
let (w, h) = (build.design_w, build.design_h);
|
||||
// A dim backdrop stands in for the PRMD dim-quad + live 3D scene.
|
||||
let mut canvas = vec![0u8; (w * h * 4) as usize];
|
||||
for px in canvas.chunks_exact_mut(4) {
|
||||
px.copy_from_slice(&[14, 14, 20, 255]);
|
||||
}
|
||||
let mut drawn = Vec::new();
|
||||
for p in &build.placements {
|
||||
if p.animated || (p.focused && !include_focus) {
|
||||
continue;
|
||||
}
|
||||
let Some(&(off, size)) = build.sprites.get(&p.sprite) else {
|
||||
continue;
|
||||
};
|
||||
let Some(img) = t8ad::parse(&bundle[off..off + size]) else {
|
||||
continue;
|
||||
};
|
||||
blit(&mut canvas, w, h, &img, p);
|
||||
drawn.push(p.record.clone());
|
||||
}
|
||||
Some(ComposedScreen {
|
||||
width: w,
|
||||
height: h,
|
||||
rgba: canvas,
|
||||
drawn,
|
||||
})
|
||||
}
|
||||
|
||||
/// Alpha-blend one sprite onto the canvas at its placement, with tint + scale.
|
||||
fn blit(canvas: &mut [u8], cw: u32, ch: u32, img: &t8ad::T8adImage, p: &Placement) {
|
||||
let (sw, sh) = (img.width, img.height);
|
||||
if sw == 0 || sh == 0 {
|
||||
return;
|
||||
}
|
||||
let (dw, dh) = (sw * p.scale_x / 100, sh * p.scale_y / 100);
|
||||
let (tr, tg, tb, ta) = (
|
||||
(p.tint >> 24) & 0xff,
|
||||
(p.tint >> 16) & 0xff,
|
||||
(p.tint >> 8) & 0xff,
|
||||
p.tint & 0xff,
|
||||
);
|
||||
for oy in 0..dh {
|
||||
let ty = p.y + oy;
|
||||
if ty >= ch {
|
||||
break;
|
||||
}
|
||||
let syi = (oy * sh / dh).min(sh - 1);
|
||||
for ox in 0..dw {
|
||||
let tx = p.x + ox;
|
||||
if tx >= cw {
|
||||
break;
|
||||
}
|
||||
let sxi = (ox * sw / dw).min(sw - 1);
|
||||
let si = ((syi * sw + sxi) * 4) as usize;
|
||||
let sr = img.rgba[si] as u32 * tr / 255;
|
||||
let sg = img.rgba[si + 1] as u32 * tg / 255;
|
||||
let sb = img.rgba[si + 2] as u32 * tb / 255;
|
||||
let sa = img.rgba[si + 3] as u32 * ta / 255;
|
||||
if sa == 0 {
|
||||
continue;
|
||||
}
|
||||
let di = ((ty * cw + tx) * 4) as usize;
|
||||
for (k, sc) in [sr, sg, sb].into_iter().enumerate() {
|
||||
let dc = canvas[di + k] as u32;
|
||||
canvas[di + k] = ((sc * sa + dc * (255 - sa)) / 255) as u8;
|
||||
}
|
||||
canvas[di + 3] = 255;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A synthetic `.rat` record: RATC header, sprite name at 0x20, a
|
||||
/// `[100,100,tint,X,Y]` placement block.
|
||||
fn synth_record(sprite: &str, x: u32, y: u32) -> Vec<u8> {
|
||||
let mut r = vec![0u8; 0x58];
|
||||
r[0..4].copy_from_slice(b"RATC");
|
||||
r[0x18..0x1c].copy_from_slice(&1280u32.to_be_bytes());
|
||||
r[0x1c..0x20].copy_from_slice(&720u32.to_be_bytes());
|
||||
let nb = sprite.as_bytes();
|
||||
r[0x20..0x20 + nb.len()].copy_from_slice(nb);
|
||||
for v in [100u32, 100, 0xffff_ffff, x, y] {
|
||||
r.extend_from_slice(&v.to_be_bytes());
|
||||
}
|
||||
r
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_placement_block() {
|
||||
let r = synth_record("pgpbtn00.t32", 226, 268);
|
||||
let p = parse_record("pgpbtn00.rat", &r).unwrap();
|
||||
assert_eq!(p.sprite, "pgpbtn00.t32");
|
||||
assert_eq!((p.x, p.y), (226, 268));
|
||||
assert_eq!(p.tint, 0xffff_ffff);
|
||||
assert!(!p.focused);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flags_focus_and_rejects_out_of_range() {
|
||||
let f = parse_record("pgpbtn00f.rat", &synth_record("ring.t32", 184, 260)).unwrap();
|
||||
assert!(f.focused);
|
||||
// X beyond design space → no placement found.
|
||||
assert!(parse_record("bad.rat", &synth_record("x.t32", 9000, 10)).is_none());
|
||||
}
|
||||
}
|
||||
@@ -1,105 +0,0 @@
|
||||
//! The runtime layout of a unit / vessel definition object.
|
||||
//!
|
||||
//! The game parses an [`crate::idxd`] record into a fixed 880-byte object whose
|
||||
//! field offsets are **not** guessable from the disc data: the record is a
|
||||
//! reflective key/value pool, and the loader assigns each key to a member by
|
||||
//! name. This table is that assignment, read out of the loader itself
|
||||
//! (`sub_82341A20` — every key is built as `addi r4, r30, -N`, so the field name
|
||||
//! for each store is a string in the executable image), and verified against
|
||||
//! objects dumped from a running mission: **406 values agree with the disc
|
||||
//! records, 0 disagree**, over 11 objects covering both schemas.
|
||||
//!
|
||||
//! Why a reimplementation wants it:
|
||||
//!
|
||||
//! - it names the field behind every word of a live definition object, so a
|
||||
//! memory snapshot can be read directly;
|
||||
//! - it says which fields a record leaves **defaulted**, and what the loader
|
||||
//! leaves there — the float accessor returns `0.0` on a pool miss;
|
||||
//! - it carries two conventions that are invisible on disc: **angles are degrees
|
||||
//! in the data and radians in the object**, and **`Size_Y` takes `Size_X`**
|
||||
//! when omitted.
|
||||
//!
|
||||
//! See `docs/re/live-unit-definitions.md` for the derivation and the measured
|
||||
//! default values.
|
||||
|
||||
/// How a field is stored in the definition object.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Kind {
|
||||
/// IEEE-754 single, big-endian.
|
||||
F32,
|
||||
/// Pointer to a string.
|
||||
Str,
|
||||
/// 32-bit word (bool / enum / count / id).
|
||||
Word,
|
||||
}
|
||||
|
||||
/// One field of the definition object.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct Field {
|
||||
/// Byte offset from the start of the object.
|
||||
pub offset: usize,
|
||||
/// Field name, exactly as the disc record spells it.
|
||||
pub name: &'static str,
|
||||
/// Storage kind.
|
||||
pub kind: Kind,
|
||||
}
|
||||
|
||||
const TABLE: &str = include_str!("../data/unit_definition_layout.txt");
|
||||
|
||||
/// Every mapped field, in offset order.
|
||||
pub fn fields() -> Vec<Field> {
|
||||
TABLE
|
||||
.lines()
|
||||
.filter(|l| !l.trim_start().starts_with('#') && !l.trim().is_empty())
|
||||
.filter_map(|l| {
|
||||
let mut it = l.split_whitespace();
|
||||
let offset = it.next()?.parse().ok()?;
|
||||
let kind = match it.next()? {
|
||||
"f32" => Kind::F32,
|
||||
"str" => Kind::Str,
|
||||
_ => Kind::Word,
|
||||
};
|
||||
// `name` is a &'static str because TABLE is 'static.
|
||||
let name = it.next()?;
|
||||
let name: &'static str = TABLE.get(
|
||||
TABLE.find(name).map(|s| s..s + name.len())?,
|
||||
)?;
|
||||
Some(Field { offset, name, kind })
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The field at `offset`, if one is mapped there.
|
||||
pub fn field_at(offset: usize) -> Option<Field> {
|
||||
fields().into_iter().find(|f| f.offset == offset)
|
||||
}
|
||||
|
||||
/// The offset of `name`, if it is mapped.
|
||||
pub fn offset_of(name: &str) -> Option<usize> {
|
||||
fields().into_iter().find(|f| f.name == name).map(|f| f.offset)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn table_parses_and_is_ordered() {
|
||||
let f = fields();
|
||||
assert!(f.len() > 150, "expected the full map, got {}", f.len());
|
||||
assert!(f.windows(2).all(|w| w[0].offset < w[1].offset), "offsets must be strictly increasing");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn known_fields_sit_where_the_loader_puts_them() {
|
||||
// Spot-checks from the verified map; these four also anchor the
|
||||
// identification of a live object (see docs/re/live-unit-definitions.md).
|
||||
assert_eq!(offset_of("Size_X"), Some(48));
|
||||
assert_eq!(offset_of("Size_Y"), Some(52));
|
||||
assert_eq!(offset_of("Size_Z"), Some(56));
|
||||
assert_eq!(offset_of("HP"), Some(84));
|
||||
assert_eq!(offset_of("HQRatio"), Some(88));
|
||||
assert_eq!(field_at(96).map(|f| f.name), Some("ThrusterRatio"));
|
||||
assert_eq!(field_at(48).map(|f| f.kind), Some(Kind::F32));
|
||||
}
|
||||
}
|
||||
@@ -1,144 +0,0 @@
|
||||
//! Cross-container consistency for XBG7 geometry.
|
||||
//!
|
||||
//! A geometry resource shared by several stage containers must decode to the
|
||||
//! same bounds in each. This needs no ground truth, and on 2026-08-11 it found
|
||||
//! **125 of 681** shared resources decoding to different bounds while reporting
|
||||
//! identical vertex and triangle counts — the anchor scan locating a different
|
||||
//! buffer of the same size (see `docs/re/structures/xbg7-mesh.md`).
|
||||
//!
|
||||
//! The test is `#[ignore]`d because the decoder does not satisfy it yet. It is
|
||||
//! written as the *target* state so that fixing the anchor scan makes it pass,
|
||||
//! rather than as a snapshot of the bug.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
|
||||
fn disc_root() -> Option<PathBuf> {
|
||||
if let Ok(p) = std::env::var("SYLPHEED_DISC") {
|
||||
let p = PathBuf::from(p);
|
||||
if p.join("dat").is_dir() {
|
||||
return Some(p);
|
||||
}
|
||||
}
|
||||
let default = Path::new(
|
||||
"/home/fabi/RE - Project Sylpheed/Project Sylpheed - Arc of Deception (USA, Europe) (En,Ja)",
|
||||
);
|
||||
if default.join("dat").is_dir() {
|
||||
return Some(default.to_path_buf());
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Rounded (w, h, d) of a model's own geometry.
|
||||
fn span(m: &Xbg7Model) -> Option<[i64; 3]> {
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for s in &m.meshes {
|
||||
for q in &s.positions {
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(q[k]);
|
||||
hi[k] = hi[k].max(q[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if lo[0] == f32::MAX {
|
||||
return None;
|
||||
}
|
||||
Some([
|
||||
(hi[0] - lo[0]).round() as i64,
|
||||
(hi[1] - lo[1]).round() as i64,
|
||||
(hi[2] - lo[2]).round() as i64,
|
||||
])
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "known-failing: 62 of 714 shared resources decode inconsistently (was 125 of 681; distinct anchor assignment + the 0.42 connectivity cap fixed the rest). Note this metric is the WEAKER witness — a systematic mis-anchor is consistent — see docs/re/structures/xbg7-mesh.md"]
|
||||
fn shared_resources_decode_identically_in_every_container() {
|
||||
let Some(root) = disc_root() else {
|
||||
eprintln!("SKIP: extracted disc not found (set SYLPHEED_DISC to enable)");
|
||||
return;
|
||||
};
|
||||
let dir = root.join("hidden/resource3d");
|
||||
let mut files: Vec<PathBuf> = std::fs::read_dir(&dir)
|
||||
.expect("resource3d/")
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
// name -> (verts, tris) -> set of spans seen
|
||||
let mut seen: BTreeMap<String, Vec<([i64; 3], usize, usize, String)>> = BTreeMap::new();
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let where_ = f.file_name().unwrap().to_string_lossy().to_string();
|
||||
for m in Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false) {
|
||||
let Some(sp) = span(&m) else { continue };
|
||||
let v: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
let t: usize = m.meshes.iter().map(|s| s.indices.len() / 3).sum();
|
||||
seen.entry(m.name.clone()).or_default().push((sp, v, t, where_.clone()));
|
||||
}
|
||||
}
|
||||
|
||||
let mut bad: Vec<String> = Vec::new();
|
||||
for (name, list) in &seen {
|
||||
if list.len() < 2 {
|
||||
continue;
|
||||
}
|
||||
// Only compare decodes that agree on how much geometry they found;
|
||||
// a differing vertex/triangle count is a different question.
|
||||
if !list.iter().all(|e| e.1 == list[0].1 && e.2 == list[0].2) {
|
||||
continue;
|
||||
}
|
||||
let spans: std::collections::BTreeSet<[i64; 3]> = list.iter().map(|e| e.0).collect();
|
||||
if spans.len() > 1 && bad.len() < 10 {
|
||||
bad.push(format!("{name}: {spans:?}"));
|
||||
}
|
||||
}
|
||||
assert!(
|
||||
bad.is_empty(),
|
||||
"{} shared resources decode to different bounds; first: {bad:?}",
|
||||
bad.len()
|
||||
);
|
||||
}
|
||||
|
||||
/// Port/starboard twins must not decode to the *same* buffer.
|
||||
///
|
||||
/// A runtime capture showed the container stores both halves of the `e106` hull
|
||||
/// as separate X-reflected buffers, so a `…_01`/`…_02` pair of equal vertex
|
||||
/// count should come out mirrored (or related by another axis / vertex order) —
|
||||
/// never identical, which is the collapse distinct assignment fixes. Since that
|
||||
/// fix reached grouped pools too, this holds for **every** twin pair on the disc
|
||||
/// — including `n206`, which was the last exception.
|
||||
#[test]
|
||||
fn twin_pairs_do_not_share_a_buffer() {
|
||||
let Some(root) = disc_root() else {
|
||||
eprintln!("SKIP: extracted disc not found (set SYLPHEED_DISC to enable)");
|
||||
return;
|
||||
};
|
||||
let mut files: Vec<PathBuf> = std::fs::read_dir(root.join("hidden/resource3d"))
|
||||
.expect("resource3d/")
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("xpr"))
|
||||
.collect();
|
||||
files.sort();
|
||||
|
||||
let mut collapsed: Vec<String> = Vec::new();
|
||||
for f in &files {
|
||||
let Ok(bytes) = std::fs::read(f) else { continue };
|
||||
let models = Xbg7Model::anchor_models_cancellable(&bytes, 0.0, &|| false);
|
||||
let by_name: BTreeMap<&str, &Xbg7Model> =
|
||||
models.iter().map(|m| (m.name.as_str(), m)).collect();
|
||||
for m in &models {
|
||||
let Some(stem) = m.name.strip_suffix("_01") else { continue };
|
||||
let Some(t) = by_name.get(format!("{stem}_02").as_str()) else { continue };
|
||||
let (a, b) = (m.meshes[0].vbuf_offset, t.meshes[0].vbuf_offset);
|
||||
if a.is_some() && a == b {
|
||||
collapsed.push(format!("{}/{stem}_02 in {}", m.name, f.file_name().unwrap().to_string_lossy()));
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(collapsed.is_empty(), "twin pairs sharing one buffer: {collapsed:?}");
|
||||
}
|
||||
@@ -17,7 +17,7 @@ fn res3d_dir() -> Option<PathBuf> {
|
||||
}
|
||||
}
|
||||
let default =
|
||||
PathBuf::from("/home/fabi/RE - Project Sylpheed/sylph_extract/hidden/resource3d");
|
||||
PathBuf::from("/home/fabi/RE Project Sylpheed/sylph_extract/hidden/resource3d");
|
||||
default.is_dir().then_some(default)
|
||||
}
|
||||
|
||||
@@ -321,7 +321,7 @@ fn hero_ship_grouped_pool_decodes() {
|
||||
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()
|
||||
"/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");
|
||||
@@ -359,7 +359,7 @@ 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()
|
||||
"/home/fabi/RE Project Sylpheed/sylph_extract/hidden/resource3d".to_string()
|
||||
});
|
||||
let mut names: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
@@ -386,7 +386,7 @@ fn stage_models_sweep() {
|
||||
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()
|
||||
"/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);
|
||||
|
||||
@@ -19,7 +19,7 @@ fn iso_path() -> Option<PathBuf> {
|
||||
}
|
||||
}
|
||||
let default = PathBuf::from(
|
||||
"/home/fabi/RE - Project Sylpheed/Project Sylpheed - Arc of Deception (USA, Europe) (En,Ja).iso",
|
||||
"/home/fabi/RE Project Sylpheed/Project Sylpheed - Arc of Deception (USA, Europe) (En,Ja).iso",
|
||||
);
|
||||
default.is_file().then_some(default)
|
||||
}
|
||||
|
||||
@@ -1,152 +0,0 @@
|
||||
//! Disc-wide guards for the 2D surface formats, locking in what was measured on
|
||||
//! 2026-08-11. Skipped (as no-ops) when the extracted disc is absent.
|
||||
//!
|
||||
//! These assert *disc-wide invariants* rather than one hand-picked file, because
|
||||
//! each of the findings they guard was originally missed by reasoning from a
|
||||
//! sample: T8aD's "~15 % unsupported variants" were a wrong model, and LSTA's
|
||||
//! "a few entries disagree with the count" was a miscount.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use sylpheed_formats::{lsta, pak::PakArchive, ratc, t8ad};
|
||||
|
||||
fn disc_root() -> Option<PathBuf> {
|
||||
if let Ok(p) = std::env::var("SYLPHEED_DISC") {
|
||||
let p = PathBuf::from(p);
|
||||
if p.join("dat").is_dir() {
|
||||
return Some(p);
|
||||
}
|
||||
}
|
||||
let default = Path::new(
|
||||
"/home/fabi/RE - Project Sylpheed/Project Sylpheed - Arc of Deception (USA, Europe) (En,Ja)",
|
||||
);
|
||||
if default.join("dat").is_dir() {
|
||||
return Some(default.to_path_buf());
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
macro_rules! skip_without_disc {
|
||||
($root:ident) => {
|
||||
let Some($root) = disc_root() else {
|
||||
eprintln!("SKIP: extracted disc not found (set SYLPHEED_DISC to enable)");
|
||||
return;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
/// Every entry of every pak, plus every RATC child, as raw bytes.
|
||||
fn for_each_blob(root: &Path, mut f: impl FnMut(&str, &str, &[u8])) {
|
||||
let mut paks: Vec<PathBuf> = std::fs::read_dir(root.join("dat"))
|
||||
.expect("dat/")
|
||||
.flatten()
|
||||
.map(|e| e.path())
|
||||
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("pak"))
|
||||
.collect();
|
||||
paks.sort();
|
||||
for p in &paks {
|
||||
let pak_name = p.file_name().unwrap().to_string_lossy().to_string();
|
||||
let Ok(arc) = PakArchive::open(p) else { continue };
|
||||
for e in arc.entries() {
|
||||
let Ok(bytes) = arc.read(e) else { continue };
|
||||
f(&pak_name, &format!("{:08x}", e.name_hash), &bytes);
|
||||
if ratc::is_ratc(&bytes) {
|
||||
if let Some(kids) = ratc::parse(&bytes) {
|
||||
for k in &kids {
|
||||
if k.offset + k.size <= bytes.len() {
|
||||
f(&pak_name, &k.name, &bytes[k.offset..k.offset + k.size]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A T8aD surface is a list of sub-rectangles, and on this disc **every** one
|
||||
/// decodes. Regressing the rectangle model would show up here as a decode gap,
|
||||
/// which is exactly how the old 256-grid reading looked (96 %, not 100 %).
|
||||
#[test]
|
||||
fn every_t8ad_on_the_disc_decodes() {
|
||||
skip_without_disc!(root);
|
||||
let (mut total, mut ok) = (0usize, 0usize);
|
||||
let mut first_failure = None;
|
||||
for_each_blob(&root, |pak, name, b| {
|
||||
if !t8ad::is_t8ad(b) || b.len() < 0x40 {
|
||||
return;
|
||||
}
|
||||
total += 1;
|
||||
if t8ad::parse(b).is_some() {
|
||||
ok += 1;
|
||||
} else if first_failure.is_none() {
|
||||
first_failure = Some(format!("{pak}:{name}"));
|
||||
}
|
||||
});
|
||||
assert!(total > 19_000, "expected the disc's ~19 216 surfaces, saw {total}");
|
||||
assert_eq!(ok, total, "first failure: {first_failure:?}");
|
||||
}
|
||||
|
||||
/// An LSTA's header count is exact and counts **both** kinds of element: T8aD
|
||||
/// sprites and `PRMD` primitives. (It was long read as unreliable because the
|
||||
/// comparison ignored primitives.)
|
||||
#[test]
|
||||
fn lsta_count_equals_sprites_plus_primitives() {
|
||||
skip_without_disc!(root);
|
||||
let count_magic = |b: &[u8], magic: &[u8; 4]| {
|
||||
let (mut n, mut i) = (0usize, 4usize);
|
||||
while i + 4 <= b.len() {
|
||||
if &b[i..i + 4] == magic {
|
||||
n += 1;
|
||||
i += 4;
|
||||
} else {
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
n
|
||||
};
|
||||
let (mut lists, mut exact) = (0usize, 0usize);
|
||||
let mut bad = Vec::new();
|
||||
for_each_blob(&root, |pak, name, b| {
|
||||
if !lsta::is_lsta(b) || b.len() < 8 {
|
||||
return;
|
||||
}
|
||||
lists += 1;
|
||||
let declared = u32::from_be_bytes([b[4], b[5], b[6], b[7]]) as usize;
|
||||
let sprites = count_magic(b, b"T8aD");
|
||||
let prims = count_magic(b, b"PRMD");
|
||||
if declared == sprites + prims {
|
||||
exact += 1;
|
||||
} else if bad.len() < 4 {
|
||||
bad.push(format!("{pak}:{name} declared {declared} != {sprites}+{prims}"));
|
||||
}
|
||||
});
|
||||
assert!(lists >= 60, "expected the disc's 64 LSTA lists, saw {lists}");
|
||||
assert_eq!(exact, lists, "mismatches: {bad:?}");
|
||||
}
|
||||
|
||||
/// Nested RATC records are **leaves**: they carry no child list of their own.
|
||||
/// "One level deep" describes the data, not a parser limit.
|
||||
#[test]
|
||||
fn ratc_nesting_is_exactly_one_level() {
|
||||
skip_without_disc!(root);
|
||||
let mut grandchildren = 0usize;
|
||||
let mut bundles = 0usize;
|
||||
for_each_blob(&root, |_, _, b| {
|
||||
if !ratc::is_ratc(b) {
|
||||
return;
|
||||
}
|
||||
let Some(kids) = ratc::parse(b) else { return };
|
||||
bundles += 1;
|
||||
for k in &kids {
|
||||
if k.offset + k.size > b.len() {
|
||||
continue;
|
||||
}
|
||||
let sub = &b[k.offset..k.offset + k.size];
|
||||
if ratc::is_ratc(sub) {
|
||||
grandchildren += ratc::parse(sub).map(|g| g.len()).unwrap_or(0);
|
||||
}
|
||||
}
|
||||
});
|
||||
assert!(bundles > 2_000, "expected thousands of RATC bundles, saw {bundles}");
|
||||
assert_eq!(grandchildren, 0, "a nested RATC record listed children");
|
||||
}
|
||||
@@ -1,96 +0,0 @@
|
||||
//! The definition-object layout must keep agreeing with the disc records.
|
||||
//!
|
||||
//! `unit_layout` was read out of the game's loader and checked against objects
|
||||
//! dumped from a running Stage 02. This pins that check: every mapped float
|
||||
//! field of every identified object must equal the value its disc record sets.
|
||||
//! It needs no emulator — the dump is checked in under `docs/re/captures/`.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use sylpheed_formats::idxd::IdxdObject;
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
use sylpheed_formats::unit_layout::{fields, Kind};
|
||||
|
||||
/// Live objects identified in the dump, with the disc record each one is.
|
||||
/// `bf001` is here because full-record agreement is what identified it: the
|
||||
/// four-value signature also fitted `UN_be005_ADAN_SpaceFortress`, which
|
||||
/// disagrees on `Color_R`/`Color_G`.
|
||||
const IDENTIFIED: &[(&str, &str)] = &[
|
||||
("UN_f106_TCAF_Destroyer", "0xbd3ee300"),
|
||||
("UN_f105_TCAF_Cruiser", "0xbd40e200"),
|
||||
("UN_e105_ADAN_Cruiser", "0xbd3fd800"),
|
||||
("UN_e106_ADAN_Destroyer", "0xbd3e6f80"),
|
||||
("UN_f101_TCAF_Acropolis", "0xbd3e1f00"),
|
||||
("UN_bf001_TCAF_SchlosBase", "0xbd3b6a00"),
|
||||
("UN_e007_ADAN_Turret", "0xbd3dea80"),
|
||||
("UN_e010_ADAN_Attacker_S", "0xbd3faa80"),
|
||||
("UN_f003_TCAF_ArrowHead", "0xbd3dbd00"),
|
||||
("UN_f001_TCAF_DeltaSaber_T", "0xbd3dfc00"),
|
||||
("UN_f001_TCAF_DeltaSaber_T_Player", "0xbd3da100"),
|
||||
];
|
||||
|
||||
const DUMP: &str = include_str!("../../../docs/re/captures/stage02-live-unit-definitions-deep.txt");
|
||||
|
||||
fn disc_root() -> Option<String> {
|
||||
if let Ok(p) = std::env::var("SYLPHEED_DISC") {
|
||||
if std::path::Path::new(&p).join("dat").is_dir() {
|
||||
return Some(p);
|
||||
}
|
||||
}
|
||||
let d = "/home/fabi/RE - Project Sylpheed/Project Sylpheed - Arc of Deception (USA, Europe) (En,Ja)";
|
||||
std::path::Path::new(d).join("dat").is_dir().then(|| d.to_string())
|
||||
}
|
||||
|
||||
/// `va -> offset -> value`, from the dump's `addr +off hex u32 f32` columns.
|
||||
fn live() -> BTreeMap<String, BTreeMap<usize, f32>> {
|
||||
let mut out: BTreeMap<String, BTreeMap<usize, f32>> = BTreeMap::new();
|
||||
let mut cur = String::new();
|
||||
for line in DUMP.lines() {
|
||||
if let Some(rest) = line.strip_prefix("=== ") {
|
||||
cur = rest.trim().to_string();
|
||||
continue;
|
||||
}
|
||||
let f: Vec<&str> = line.split_whitespace().collect();
|
||||
if f.len() >= 5 && f[1].starts_with('+') {
|
||||
if let (Ok(off), Ok(val)) = (usize::from_str_radix(&f[1][1..], 16), f[4].parse::<f32>())
|
||||
{
|
||||
out.entry(cur.clone()).or_default().insert(off, val);
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mapped_fields_match_the_disc_records() {
|
||||
let Some(disc) = disc_root() else {
|
||||
eprintln!("SKIP: extracted disc not found (set SYLPHEED_DISC to enable)");
|
||||
return;
|
||||
};
|
||||
let pak = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).expect("main pak");
|
||||
let live = live();
|
||||
let floats: Vec<_> = fields().into_iter().filter(|f| f.kind == Kind::F32).collect();
|
||||
|
||||
let (mut agree, mut bad) = (0usize, Vec::new());
|
||||
for entry in pak.entries() {
|
||||
let Ok(bytes) = pak.read(entry) else { continue };
|
||||
let Ok(obj) = IdxdObject::parse(&bytes) else { continue };
|
||||
let Some(id) = obj.get_raw("ID") else { continue };
|
||||
let Some((_, va)) = IDENTIFIED.iter().find(|(i, _)| *i == id) else { continue };
|
||||
let Some(words) = live.get(*va) else { continue };
|
||||
for f in &floats {
|
||||
let (Some(want), Some(got)) = (obj.get_f32(f.name), words.get(&f.offset)) else {
|
||||
continue;
|
||||
};
|
||||
// Angle fields are degrees on disc and radians in the object.
|
||||
let rad = want * std::f32::consts::PI / 180.0;
|
||||
if (want - got).abs() <= want.abs() * 1e-4 || (rad - got).abs() <= rad.abs() * 1e-4 {
|
||||
agree += 1;
|
||||
} else {
|
||||
bad.push(format!("{id}.{} disc {want} vs live +{} = {got}", f.name, f.offset));
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(bad.is_empty(), "{} fields disagree: {bad:?}", bad.len());
|
||||
assert!(agree >= 400, "expected ≥400 agreeing fields, got {agree}");
|
||||
}
|
||||
@@ -160,8 +160,9 @@ pub enum PakContent {
|
||||
T8ad(ImageRgba),
|
||||
/// An LSTA sprite list — inline T8aD frames.
|
||||
Lsta(Vec<ImageRgba>),
|
||||
/// A RATC bundle — its listed children (T8aD children carry a decoded image).
|
||||
Ratc(Vec<RatcEntry>),
|
||||
/// A RATC bundle — its listed children (T8aD children carry a decoded
|
||||
/// image), plus the reassembled UI screen when the bundle is a `.rat` build.
|
||||
Ratc(Vec<RatcEntry>, Option<ImageRgba>),
|
||||
/// Plain-text / XML payload, with its encoding label.
|
||||
Text { text: String, encoding: String },
|
||||
}
|
||||
@@ -192,6 +193,13 @@ impl ImageRgba {
|
||||
rgba: img.rgba,
|
||||
}
|
||||
}
|
||||
fn from_composed(s: sylpheed_formats::ui_layout::ComposedScreen) -> Self {
|
||||
Self {
|
||||
width: s.width,
|
||||
height: s.height,
|
||||
rgba: s.rgba,
|
||||
}
|
||||
}
|
||||
fn pixels(&self) -> usize {
|
||||
(self.width as usize) * (self.height as usize)
|
||||
}
|
||||
@@ -1469,7 +1477,10 @@ fn classify_content(payload: &[u8]) -> PakContent {
|
||||
})
|
||||
.collect();
|
||||
if !entries.is_empty() {
|
||||
return PakContent::Ratc(entries);
|
||||
// If this bundle is a `.rat` UI build, reassemble the screen.
|
||||
let ui_screen = sylpheed_formats::ui_layout::compose_build(payload, false)
|
||||
.map(ImageRgba::from_composed);
|
||||
return PakContent::Ratc(entries, ui_screen);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3677,7 +3688,6 @@ fn exhaust_cone_mesh() -> sylpheed_formats::mesh::GameMesh {
|
||||
uvs: Vec::new(),
|
||||
indices,
|
||||
name: Some("exhaust".to_string()),
|
||||
vbuf_offset: None, // procedural, not read from a container
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -672,7 +672,9 @@ fn draw_pak_browser(ui: &mut egui::Ui, pak: &mut PakView) {
|
||||
PakContent::Png(img) => draw_png_detail(ui, row, img, img_tex),
|
||||
PakContent::T8ad(img) => draw_t8ad_detail(ui, row, img, img_tex),
|
||||
PakContent::Lsta(frames) => draw_lsta_detail(ui, row, frames, img_tex),
|
||||
PakContent::Ratc(children) => draw_ratc_detail(ui, row, children, img_tex),
|
||||
PakContent::Ratc(children, ui_screen) => {
|
||||
draw_ratc_detail(ui, row, children, ui_screen.as_ref(), img_tex)
|
||||
}
|
||||
PakContent::Text { text, encoding } => {
|
||||
draw_text_detail(ui, row, text, encoding)
|
||||
}
|
||||
@@ -699,7 +701,10 @@ fn row_kind(row: &crate::iso_loader::PakRow) -> String {
|
||||
PakContent::Png(img) => format!("PNG {}×{}", img.width, img.height),
|
||||
PakContent::T8ad(img) => format!("T8aD {}×{}", img.width, img.height),
|
||||
PakContent::Lsta(f) => format!("LSTA · {} sprite(s)", f.len()),
|
||||
PakContent::Ratc(c) => format!("RATC · {} item(s)", c.len()),
|
||||
PakContent::Ratc(c, screen) => {
|
||||
let s = if screen.is_some() { " · UI screen" } else { "" };
|
||||
format!("RATC · {} item(s){s}", c.len())
|
||||
}
|
||||
PakContent::Text { .. } => "text".into(),
|
||||
PakContent::None => row.identity.clone(),
|
||||
}
|
||||
@@ -939,21 +944,47 @@ fn draw_ratc_detail(
|
||||
ui: &mut egui::Ui,
|
||||
row: &crate::iso_loader::PakRow,
|
||||
children: &[crate::iso_loader::RatcEntry],
|
||||
ui_screen: Option<&ImageRgba>,
|
||||
img_tex: &mut ImgCache,
|
||||
) {
|
||||
ui.horizontal(|ui| {
|
||||
ui.heading("RATC bundle");
|
||||
ui.separator();
|
||||
ui.label(format!("{} item(s)", children.len()));
|
||||
if ui_screen.is_some() {
|
||||
ui.separator();
|
||||
ui.strong("🖼 UI screen");
|
||||
}
|
||||
ui.separator();
|
||||
ui.weak("colours unverified");
|
||||
});
|
||||
ui.separator();
|
||||
|
||||
let refs: Vec<&ImageRgba> = children.iter().filter_map(|c| c.image.as_ref()).collect();
|
||||
// Cache the reassembled screen (if any) as texture 0, then child thumbnails.
|
||||
let mut refs: Vec<&ImageRgba> = Vec::new();
|
||||
if let Some(s) = ui_screen {
|
||||
refs.push(s);
|
||||
}
|
||||
let child_base = refs.len();
|
||||
refs.extend(children.iter().filter_map(|c| c.image.as_ref()));
|
||||
ensure_textures(ui, row.hash, &refs, img_tex);
|
||||
|
||||
let mut img_i = 0;
|
||||
// The reassembled screen, scaled to fit the panel width.
|
||||
if ui_screen.is_some() {
|
||||
if let Some(tex) = img_tex.as_ref().and_then(|(_, t)| t.first()) {
|
||||
ui.label("Reassembled from this screen's .rat layout records:");
|
||||
let sz = tex.size_vec2();
|
||||
let scale = (ui.available_width() / sz.x.max(1.0)).min(1.0);
|
||||
ui.add(egui::Image::new(egui::load::SizedTexture::new(
|
||||
tex.id(),
|
||||
[sz.x * scale, sz.y * scale],
|
||||
)));
|
||||
ui.weak("Frame/glow decorations (no .rat) and the live 3D background are omitted.");
|
||||
ui.separator();
|
||||
}
|
||||
}
|
||||
|
||||
let mut img_i = child_base;
|
||||
for c in children {
|
||||
ui.horizontal(|ui| {
|
||||
if c.image.is_some() {
|
||||
|
||||
@@ -1,304 +0,0 @@
|
||||
# RE backlog
|
||||
|
||||
Open items that are *not* being worked right now. Each entry says what is wrong or
|
||||
unknown, what evidence exists, and what the first step would be. Move an item into
|
||||
`INDEX.md` (with a `structures/…md` or a parser + test) once it is actually settled.
|
||||
|
||||
---
|
||||
|
||||
## Capital ships assemble wrong in the viewer
|
||||
|
||||
**Reported:** 2026-07-30, by the user. **Status:** ✅ **format-side cause found and
|
||||
fixed 2026-08-12** — see below for the 2026-08-10 diagnosis this supersedes.
|
||||
|
||||
The remaining format-side defect this entry pointed at (a shared turret decoding
|
||||
~100× too large in some containers) was real and is gone. `e303_wep_01` decoded
|
||||
as a 1600×2100×4800 block in `Stage_S02`, swallowing the `e106` hull; requiring an
|
||||
index buffer to cover its vertex pool **exactly** moved it to the block every
|
||||
other container agrees on, and it now decodes 49×23×42 everywhere and places at
|
||||
±179 on the hull. The same fix repaired `e106_bdy_03` (a 600×1600×998 slab) and
|
||||
moved 29 anchors disc-wide, 22 of which had been carrying **another resource's
|
||||
geometry under their own name**. See
|
||||
[`structures/xbg7-mesh.md`](structures/xbg7-mesh.md).
|
||||
|
||||
Two things are worth carrying forward rather than closing:
|
||||
- the assembler was **audited and exonerated** — every composite node carries
|
||||
scale 1.0 and an orthonormal matrix, so nothing on that side inflates a part;
|
||||
- **no metric caught this.** Coverage, cross-container consistency, the capture
|
||||
oracle and the twin invariant were all green while a 1 600-unit slab sat through
|
||||
the ship. It was found by *rendering the ship and looking at it*, and the
|
||||
numeric screens written afterwards to automate that check both failed.
|
||||
|
||||
The 2026-08-10 diagnosis follows, and its viewer-side pointers still stand.
|
||||
|
||||
**Status (2026-08-10):** 🔎 **the format layer is exonerated.** Runtime captures of three classes (`f105`, `e105`,
|
||||
`e106`) at controlled range reproduce `assemble_ship` to ≤0.43 units in translation
|
||||
and to 0.000 in rotation for every part that does not move; see
|
||||
[`ship-placement-capture-generalisation.md`](ship-placement-capture-generalisation.md)
|
||||
§4. So look at **the viewer**: first that it passes `include_external = true`
|
||||
(`iso_loader.rs:4012` — with `false` an e106 loses its bridge and both nacelles,
|
||||
5 parts instead of 11), then its own transform stack.
|
||||
|
||||
One real format-side bug was found on the way and is **fixed**: index-less parts
|
||||
(`e105_brg`) never matched their `GN_Bridge_01` hardpoint, so 34 (stage, ship) entries
|
||||
— `e102`, `e104`, `e105` across Stages 02–29 — assembled without a bridge. The other
|
||||
apparent exception (`e105_eng_01` rotation) was an aggregation artefact and is 0.000.
|
||||
|
||||
The original report and its reasoning follow.
|
||||
|
||||
The reborn viewer builds capital ships from the split XBG7 parts via
|
||||
`sylpheed-formats::ship::assemble_ship`, and they come out **wrong** — parts in the
|
||||
wrong place / wrong orientation.
|
||||
|
||||
**Why this is a real finding and not a known limitation:** the RE write-up
|
||||
[`ship-placement-runtime-capture.md`](ship-placement-runtime-capture.md) declares
|
||||
static assembly ✅ **exact** as of 2026-07-26 — 9-channel joint tables
|
||||
`[TX TY TZ RY RX RZ SX SY SZ]`, Euler `Ry·Rx·Rz`, with
|
||||
`ship::tests::static_assembly_matches_runtime_capture` asserting static == runtime
|
||||
capture (T < 1.0, R < 0.02). So either the viewer is not using that path, or the
|
||||
claim generalises worse than the test suggests.
|
||||
|
||||
**The likely gap:** that test is **one ship** — the `e106` destroyer, 8 parts plus
|
||||
two nacelles, two turrets and the hull mirror. Nothing pins the other classes.
|
||||
Rules that were derived from `e106` and could easily be `e106`-specific:
|
||||
|
||||
- the engine cluster rig mounted at `GN_Engine_01` (two mirrored nacelles + centre);
|
||||
- "X-reflect the shared-geometry twin whose lateral offset opposes the geometry's
|
||||
dominant side" — a heuristic, not a decoded flag;
|
||||
- cross-id turret instancing (×2).
|
||||
|
||||
**First step (the oracle already exists):** re-run the runtime capture on a *different*
|
||||
capital ship and diff static vs captured, exactly as `e106` was done — F10 in the
|
||||
`capture-ship-placement` build of `xenia-canary-native` dumps the ship shader's
|
||||
`c0..c2` WorldViewProjection rows per part; `WV_ref⁻¹ · WV_p` is the ship-space rigid
|
||||
transform, which is ground truth. Pick a class whose rig differs from `e106`
|
||||
(different engine count, a ship with no `sld`, a carrier). Then extend
|
||||
`static_assembly_matches_runtime_capture` into a per-ship table so a regression in one
|
||||
class cannot hide behind `e106` passing.
|
||||
|
||||
**Also worth ruling out first, cheaply:** that the viewer's own transform stack (scale,
|
||||
handedness, node-instance recursion) is not re-breaking a correct assembly — compare
|
||||
the viewer's placement against `assemble_ship`'s output directly before blaming the
|
||||
format layer.
|
||||
|
||||
---
|
||||
|
||||
## Viewer: `include_external` is already on — that hypothesis is dead
|
||||
|
||||
**Checked 2026-08-11.** The item above names "first that it passes
|
||||
`include_external = true` (`iso_loader.rs:4012`)" as the cheap first step. It
|
||||
does: `ShipBrowser::show_external` defaults to `true`
|
||||
(`iso_loader.rs:643`), the checkbox reads it (`ui.rs:1593`) and it is threaded
|
||||
through `RequestShipRender` → `build_ship_model` → `assemble_ship` unchanged
|
||||
(`ui.rs:1689`, `iso_loader.rs:4012`). So a ship rendered by the viewer is the
|
||||
full external assembly, not the bare hull.
|
||||
|
||||
The viewer also does not have a transform stack of its own to blame: it bakes
|
||||
`ScenePart::apply` straight into the vertices and rotates normals by the same
|
||||
`p.m` (`iso_loader.rs:4030-4062`), so its placement is `assemble_ship`'s output
|
||||
by construction. What remains unexcluded, in order of cheapness: the mirror
|
||||
handling (`det < 0` reverses triangle winding only — a reflected part keeps its
|
||||
reflected geometry), `Xbg7Model::models_named` resolving the wrong sub-model when
|
||||
a resource name repeats, and the exhaust cones. **Next step is a visual**: the
|
||||
diagnosis has run out of things it can settle by reading, so the viewer needs to
|
||||
be run against a known-good class (`e106`) and its render compared with
|
||||
`ship_render`'s.
|
||||
|
||||
---
|
||||
|
||||
## Viewer: the duplicate-resource-name hypothesis is dead too
|
||||
|
||||
**Checked 2026-08-11.** The diagnosis above left three candidates for why capital
|
||||
ships assemble wrong in the viewer: mirror handling, `Xbg7Model::models_named`
|
||||
resolving the wrong sub-model when a resource name repeats, and the exhaust
|
||||
cones. The second is now **refuted**, and comprehensively.
|
||||
|
||||
`build_ship_model` resolves each placement with
|
||||
`base.iter().find(|m| m.name == p.resource)` (`iso_loader.rs:4041`) — first match
|
||||
wins — so a repeated resource name inside a container would silently draw the
|
||||
wrong geometry. It cannot happen: decoding **every** XBG7 resource in **all 22
|
||||
stage containers** gives **4 603 resources and zero repeated names**.
|
||||
|
||||
```
|
||||
Stage_S01 62/62 Stage_S07 323/323 Stage_S13 290/290 Stage_S25 351/351
|
||||
Stage_S02 304/304 Stage_S08 388/388 Stage_S14 22/22 Stage_S26 318/318
|
||||
Stage_S03 214/214 Stage_S09 316/316 Stage_S15 386/386 Stage_S27 321/321
|
||||
Stage_S04 179/179 Stage_S10 7/7 Stage_S16 65/65 Stage_S28 118/118
|
||||
Stage_S05 92/92 Stage_S11 157/157 Stage_S24 162/162 Stage_S29 386/386
|
||||
Stage_S06 266/266 Stage_S12 376/376
|
||||
```
|
||||
|
||||
Per-ship it is tighter still: `e106` wants 9 distinct names and decodes exactly
|
||||
9 models for 11 placements; `e105` 9 for 9; `f105` 5 for 6. Every placement
|
||||
resolves to the one model it names.
|
||||
|
||||
**So two of the three candidates are gone** (this one and `include_external`),
|
||||
leaving **mirror handling** and **the exhaust cones** — and the still-untried
|
||||
visual comparison, which remains the right next step.
|
||||
|
||||
---
|
||||
|
||||
## Viewer: mirror handling and the exhaust cones are cleared too — the static avenue is exhausted
|
||||
|
||||
**Checked 2026-08-11.** Both remaining candidates were tested across every ship
|
||||
on the disc, and neither shows the reported signature.
|
||||
|
||||
**Mirror handling.** The concern was that `ScenePart::apply` bakes `R·(S·v)+T`
|
||||
while the viewer takes its winding-flip decision from `det(m)` alone and rotates
|
||||
normals by `m` alone — both ignoring `s`. A mirror encoded as a *negative scale*
|
||||
would then reflect geometry without flipping winding, drawing the part
|
||||
inside-out. It never happens: across **1 485 assembled parts** in all 22
|
||||
containers there are **22 mirrored parts, every one with `det(m) < 0`**, and
|
||||
**zero** parts with a negative scale or a non-uniform one. `apply_twin_mirrors`
|
||||
writes the reflection into `m` (negating its X column), so the viewer's flip
|
||||
always fires, and ignoring `s` for normals is harmless because `s` is always
|
||||
uniform.
|
||||
|
||||
**Exhaust cones.** These are the one piece of geometry the viewer *invents* — a
|
||||
cone at each `GN_Jet`/`GN_SJet` frame, because the real engine geometry is
|
||||
recessed and the game draws FX there instead. If they landed wrongly they would
|
||||
read exactly as "a part in the wrong place". Across **335 assembled ships, 192 of
|
||||
which have exhaust frames, not one cone sits outside its hull's bounding box**
|
||||
(tolerance 10 % of the axis span).
|
||||
|
||||
**Caveat, stated rather than glossed:** "inside the hull box" does not prove a
|
||||
cone is *right* — orientation and size are untested, and a cone could be wrong
|
||||
while still inside. What it does rule out is the reported symptom for that part.
|
||||
|
||||
So every mechanism this diagnosis proposed is now eliminated: `include_external`,
|
||||
duplicate resource names, mirror handling, and cones-in-the-wrong-place. The
|
||||
format and assembly layers pass every static test available, and **the visual
|
||||
comparison is no longer merely the next step — it is the only remaining one.**
|
||||
Render `e106` in the viewer beside `ship_render`'s output of the same
|
||||
`assemble_ship` result; if they agree, the bug is in neither and the original
|
||||
report needs re-grounding against a specific ship and a specific expectation.
|
||||
|
||||
---
|
||||
|
||||
## ⚠️ DIAGNOSED 2026-08-12 — a mis-decode; the locality fix was written, then withdrawn
|
||||
|
||||
> Resolution at the end of this entry. Kept in full because the two wrong turns
|
||||
> along the way (a "stray volume", then "monotonic anchoring") are the useful part.
|
||||
|
||||
## ⚠️ The format layer is NOT exonerated — but the cause is a MIS-DECODE, not a stray volume
|
||||
|
||||
**Found 2026-08-11 by finally doing the visual**, which the notes above kept
|
||||
naming as the next step. It overturns their conclusion.
|
||||
|
||||
Render `e106` from the static assembly and from the baked runtime capture and
|
||||
compare — `ship_render` does both:
|
||||
|
||||
| | placements | parts |
|
||||
|---|---|---|
|
||||
| runtime capture (ground truth) | **8** | `bdy_01…04`, `brg_01`, `eng_01`, `eng_02`, `wep_02_01` |
|
||||
| `assemble_ship(--static)` | **11** | the same 8, **plus `e303_wep_01` ×2** and a second `e106_eng_01` |
|
||||
|
||||
The render makes it obvious: the destroyer sits inside a white slab that dwarfs
|
||||
it ([capture](captures/e106-static-assembly-volume-bug.png)). That slab is
|
||||
`e303_wep_01`, and its own geometry is:
|
||||
|
||||
```
|
||||
e303_wep_01 172 verts, 110 tris bounds X[-1000, 600] Y[-1050, 1050] Z[-2400, 2400] 1600 x 2100 x 4800
|
||||
e106_wep_02_01 1002 verts, 772 tris 269 x 179 x 417 ← what a real e106 turret looks like
|
||||
e106_brg_01 202 verts, 202 tris 105 x 76 x 305
|
||||
```
|
||||
|
||||
**110 triangles, perfectly round axis-aligned bounds, and bigger than the ship it
|
||||
is mounted on.**
|
||||
|
||||
### CORRECTION (same day, one iteration later): it is not a volume — it is a bad decode
|
||||
|
||||
The first reading of this was that `e303_wep_01` is a collision/trigger volume
|
||||
the assembler wrongly draws. **That is wrong, and the evidence that settles it is
|
||||
decoding the same resource from every container that holds it:**
|
||||
|
||||
```
|
||||
Stage_S01 172 verts 110 tris X[-24.5, 24.5] Y[0.0, 23.4] Z[-20.8, 20.8] ← 49 × 23 × 42, a turret
|
||||
Stage_S02 172 verts 110 tris X[-1000, 600] Y[±1050] Z[±2400] ← 1600 × 2100 × 4800
|
||||
Stage_S03… 172 verts 110 tris 49 × 23 × 42 (correct)
|
||||
Stage_S08 … 1600 × 2100 × 4800
|
||||
Stage_S26 … 1600 × 2100 × 4800
|
||||
```
|
||||
|
||||
Same resource, same vertex and triangle count, **decoding correctly in eleven
|
||||
containers and wrongly in exactly three** (`Stage_S02`, `S08`, `S26`). So:
|
||||
|
||||
- the **placement is legitimate** — `e303_wep_01` is a small shared turret,
|
||||
cross-mounted on `e101` and `e106`, and at its true size it is unremarkable;
|
||||
- the original author's explanation of the capture's silence (**vbase dedup**)
|
||||
stands, and my "dedup would show one, not zero" objection does not survive:
|
||||
with the correct decode the turret is small, ordinary geometry;
|
||||
- **the defect is in the mesh decoder**, which resolved this resource's vertex
|
||||
data differently in three containers.
|
||||
|
||||
The render and the symptom are real; the cause named in the first version of this
|
||||
entry was not.
|
||||
|
||||
### The part that matters more than this one resource
|
||||
|
||||
**The decoder can produce wrong geometry without declining.** The
|
||||
[XBG7 audit](structures/xbg7-mesh.md) counted 814 resources it *refuses* — a
|
||||
visible, honest failure. This is the other kind: `e303_wep_01` decodes "fine" in
|
||||
`Stage_S02` and is silently 100× too large. Screening for the signature (bounds
|
||||
that are exact multiples of 50 with a span over 1000) flags 22–32 models in each
|
||||
of `S02`, `S03`, `S08`, `S26`, `S27` — **but that screen also catches legitimate
|
||||
`e_rou_*` composite proxies**, so it is a candidate list, not a count of bugs.
|
||||
|
||||
**Next:** diff the anchor scan's chosen `vb0` for `e303_wep_01` between
|
||||
`Stage_S01` (correct) and `Stage_S02` (wrong) — same resource, two outcomes, so
|
||||
the divergence is directly observable — then use whatever distinguishes them to
|
||||
add a post-decode sanity check, so a silent 100× mis-decode becomes a decline.
|
||||
|
||||
### Why this was missed
|
||||
|
||||
`assemble_ship` treats **every** `rou_*` node in the composite as a drawable
|
||||
part, and the doc comment states the cross-id mount as intended behaviour —
|
||||
`"INCLUDING repeated instances and cross-id turret mounts (rou_e303_wep_01_root
|
||||
×2 on the e106 hull)"` — with
|
||||
`ship::tests::static_assembly_matches_runtime_capture` asserting
|
||||
`count("e303_wep_01") == 2`. The absence from the capture was explained away as
|
||||
vbase dedup, but **dedup would show one instance, not zero**.
|
||||
|
||||
The test cannot catch it either: it walks the capture's parts and looks each up
|
||||
in the static output, so **extra** static placements are invisible to it. That is
|
||||
the same shape of gap as the earlier `include_external` hypothesis — a test that
|
||||
can only fail one way.
|
||||
|
||||
### Scope, stated carefully
|
||||
|
||||
Sweeping all 335 assembled ships for the signature *ship-scale span with under
|
||||
400 triangles* flags **20 ships and 58 placements** over 28 distinct resources
|
||||
(`e005_ant_*`, `f001_ant_*`, `f002_bdy_*`, `f301_barrel`, `f303_body`,
|
||||
`e303_wep_01`, …). **Only the `e106`/`e303_wep_01` case is proven** — by render,
|
||||
by capture absence, and by geometry. Some of the others may be legitimately large
|
||||
low-poly parts, and each needs the same three checks before being called a bug.
|
||||
|
||||
**Still true, and independent of the correction above:**
|
||||
`static_assembly_matches_runtime_capture` walks the capture's parts and looks each
|
||||
up in the static output, so **extra static placements can never fail it**. That is
|
||||
worth fixing regardless — it is the same one-way-test shape as the earlier
|
||||
`include_external` hypothesis.
|
||||
|
||||
Also unchanged: only **two** cross-id placements exist fleet-wide (`e303_wep_01`
|
||||
on `e101` ×24 and `e106` ×36, across 335 assembled ships), so cross-id mounting is
|
||||
a narrow, real feature rather than a systemic guess.
|
||||
|
||||
---
|
||||
|
||||
## Resolution (2026-08-12)
|
||||
|
||||
`anchor_pool_mesh` took the **first** candidate in file order from a
|
||||
container-global scan, so a resource could be handed another resource's block
|
||||
whenever both shared `(stride, vertex count, index count)`. Fixed by anchoring
|
||||
each resource near its **descriptor neighbours** (two-pass: learn, then re-anchor).
|
||||
|
||||
- it took inconsistency **125 → 51** with coverage unchanged, and made `e106`
|
||||
render correctly ([after](captures/e106-static-assembly-fixed.png))
|
||||
- **but it flipped the `e106` twin-mirror decision**, which
|
||||
`static_assembly_matches_runtime_capture` (ISO-gated, so it skips in a plain
|
||||
`cargo test`) catches against the runtime capture — so it was **reverted**
|
||||
- the user-reported "capital ships assemble wrong" is therefore **diagnosed, not
|
||||
yet fixed**; see [xbg7](structures/xbg7-mesh.md) for what the real fix needs
|
||||
|
||||
Still open from this entry: `static_assembly_matches_runtime_capture` walks only
|
||||
the capture's parts, so **extra** static placements still cannot fail it.
|
||||
@@ -13,30 +13,14 @@ Promote to a prose `structures/…md` file when a format needs behavioural notes
|
||||
| IPFB `.pak` archive | ✅ | `sylpheed-formats/src/pak.rs` + `tests/pak_idxd_disc.rs` | header + 12-byte TOC, Z1/zlib payloads |
|
||||
| name-hash (TOC keys) | ✅ | `sylpheed-formats/src/hash.rs` | Barrett-reduction hash; recovers original paths |
|
||||
| IDXD object/table | ✅ | `sylpheed-formats/src/idxd.rs` | self-describing; ship/weapon stats verified vs known values |
|
||||
| XPR2 texture + cubemap | 🟡/✅ | `sylpheed-formats/src/texture.rs` + [colour check](xpr2-colour-check.md) | de-tile + A8R8G8B8 and DXT1. **Channel order ✅ confirmed against the running game**: the Delta Saber's decoded atlas is orange-dominant (median saturated hue 23.3°, *zero* cool pixels) and the game renders the same hull at 9.3° — a red↔blue swap would sit at ≈200°. Exact fidelity (gamma/sRGB curve, premultiplied alpha, per-channel scale) is 🟡 untested, since a hue comparison cannot see it; cubemap face ordering ❔ |
|
||||
| T8aD 2D texture | ✅ | `sylpheed-formats/src/t8ad.rs` | **100 % of the disc decodes** (19 216/19 216, measured). The "~15 % deferred variants" were a wrong model, not a variant: a surface is a list of **arbitrary sub-rectangles**, each with a 16-byte header of `dst X, dst Y, width, height`, not a 256×256 grid — `0x1c` is the **rectangle count**. Uncovered area stays transparent. **Colours ✅ CONFIRMED** ([k8888](structures/texture-color-k8888.md)) |
|
||||
| RATC bundle | ✅ | `sylpheed-formats/src/ratc.rs` | child listing confirmed. **"One level deep" is not a limitation — there is nothing deeper**: 2 859 bundles hold 18 002 children at depth 1 and **0 at depth 2**, with no parse failures. Nested RATC blobs are **leaf records that reference siblings by name** (`opt `, the sprite name): 3 311 leaves, all embedding sibling names, **10 144 of 10 148 references resolve**. The 4 that do not are one dangling asset — `pmbase.rat` → `pmbase.t32` in `GP_STAGE_CLEAR.pak`'s four language builds, and `pmbase.t32` is **on the disc nowhere** |
|
||||
| LSTA sprite list | ✅ | `sylpheed-formats/src/lsta.rs` | A display list of inline elements: **T8aD sprites and `PRMD` primitives**. The `count` at `0x04` is **exact and counts both** — `count == T8aD + PRMD` for **64/64** lists on the disc, which retires the old "a few entries disagree" note (it compared sprites against a total including primitives). **All 1 281 sprite frames decode** after the T8aD rectangle-list fix |
|
||||
| IXUD subtitle | 🟡/✅ | `sylpheed-formats/src/ixud.rs` + [movie link](movie-subtitle-link.md) | timed cues. **The movie↔subtitle↔voice link is solved — statically**, from the movie config record in `tables.pak` (schema `0x067025b9`), not from the running game as this row previously assumed: [101 movies mapped](captures/movie-subtitle-voice-map.csv), 94 with subtitles, 83 with voice, 21 with a telop overlay. 93 of 94 subtitle refs resolve in the language paks; **`SUBTITLE_S12B.tbl` is missing from all six languages** — a dangling reference on the disc. Naming is `SUBTITLE_<base>.tbl` / `VOICE_<base>` with six documented exceptions. The record's ~104 **script ids** are ❔ — positional pairing drifts by three because the IDXD pool dedupes repeated values |
|
||||
| XPR2 texture + cubemap | 🟡 | `sylpheed-formats/src/texture.rs` | de-tile + A8R8G8B8; **colours unverified** (dynamic item) |
|
||||
| T8aD 2D texture | 🟡 | `sylpheed-formats/src/t8ad.rs` | ~85% decode; **colours ✅ CONFIRMED** ([k8888](structures/texture-color-k8888.md)); ~15% variants deferred |
|
||||
| RATC bundle | 🟡 | `sylpheed-formats/src/ratc.rs` | child listing confirmed; one level deep |
|
||||
| LSTA sprite list | 🟡 | `sylpheed-formats/src/lsta.rs` | inline T8aD frames |
|
||||
| IXUD subtitle | 🟡 | `sylpheed-formats/src/ixud.rs` | timed cues; **movie↔track link unknown** (dynamic item) |
|
||||
| Fonts (ttf/otf/ttc) | ✅ | `sylpheed-formats/src/font.rs` | standard OpenType, parsed via ttf-parser |
|
||||
| XBG7 mesh | ✅/🟡 | `sylpheed-formats/src/mesh.rs` + `tests/mesh_disc.rs` ([xbg7](structures/xbg7-mesh.md)) | **6 294 resources, 6 209 decode (98.7 %), 82 searched-and-missed** (2026-08-12, up from 5 480 / 87.1 %). Five evidence-driven fixes got there: **distinct anchor assignment** (no two resources may claim one buffer — proved by a capture showing the container holds both mirrored `e106` hull halves), the connectivity cap replaced by a **winding-consistency gate at 0.70**, **structural requirements on pre-pivot sub-meshes** (index range, then exact pool coverage), and **filtering after the assignment** so a subset query cannot differ from the full decode. Validated against a runtime capture that names the file offset of every buffer the engine drew: **46/46 drawn buffers claimed, 45 anchored exactly**. **No real mesh now decodes differently in different containers** — all 89 remaining cross-container disagreements are interchangeable 24-vertex bounding boxes, which no anchoring rule can pin (monotone order re-tested and refuted). Remaining misses attribute to the degeneracy/extent gate (42), winding (31) and coverage (9); the first was probed and its "obvious" fix refuted. Every decoded sub-mesh covers its own vertex pool |
|
||||
| Capital-ship part placement | ✅ | `sylpheed-formats/src/ship.rs` (static) + [runtime capture](ship-placement-runtime-capture.md) | Placement is **sound** (hull static-exact against the `e106` capture; cross-id mounting genuinely narrow, 2 pairs across 335 ships). The XBG7 mis-decode this row used to blame for "ships assemble wrong" — a shared turret ~100× too large in some containers — is **fixed** (2026-08-12, the exact-coverage requirement): `e303_wep_01` now decodes 49×23×42 everywhere and places at ±179 on the `e106` hull, and no real mesh disagrees across containers. A composite-node audit confirmed the assembler itself never applied a bad scale (all nodes scale 1.0, orthonormal). Still open: `static_assembly_matches_runtime_capture` walks capture parts only, so **extra** static placements cannot fail it |
|
||||
| Weapon fields defaulted on disc | ✅ | [runtime struct](structures/weapon-struct-runtime.md) · [DATA SHEET route](weapon-datasheet-runtime.md) | **Solved.** Canary maps guest RAM into `/dev/shm`, so the parsed `Weapon`/`Shell` objects are readable live; their layout is solved against disc ground truth (zero contradictions over 100+ records). All 126 weapons, exact numbers, no story progress needed — [4 393 values](captures/weapon-runtime-fields.csv) the disc does not carry. Supersedes the letter-bucket limit of the DATA SHEET route, which now serves as the independent cross-check |
|
||||
| Unit (craft/vessel) fields defaulted on disc | ✅/🟡 | [runtime struct](structures/unit-struct-runtime.md) | The parsed `unit\UN_*.tbl` definition object, vtable `0x820af844`, ≥`0x380` bytes, one per unit — **discovered, not assumed** (`unit_discover.py`), and distinguished from the spawned-entity class `0x820af030` by being one-per-ID and byte-constant within a run. Across runs only pointer words move — `--crosscheck` proves **no reported field offset is run-dependent** (two words, `+0x2c8`/`+0x2d0`, are stage-dependent and remain unidentified). 27 fields ✅ (21 units, 7 runs); the `Maneuver` block is **schema declaration order, 4 bytes/field, base `0x9c` with a two-slot gap after `AA_Roll_Min`** (29 anchors, 0 conflicts), which also pins 5 fields *no* disc record ever values. Angles are **radians at runtime, degrees on disc**. **Re-derived independently 2026-08-13 from the loader's own key strings** (`sub_82341A20`; the field name for each store is a string in the image): **159 fields**, agreeing with this solver on **25 of 25 shared offsets**, verified at **406 values matching the disc and 0 disagreeing** over 11 live objects spanning UNIT and VESSEL — landed as `data/unit_definition_layout.txt` + `sylpheed_formats::unit_layout` + a no-emulator test, with **121 defaulted fields** read out ([live-unit-definitions](live-unit-definitions.md)). Unlike weapons, unit definitions are instantiated **per stage**, so coverage (21/110) grows by visiting missions — but a defaulted field is **not** a global constant: `Size_Y` provably inherits `Size_X` (7 independent units, 6 distinct values), and three more sibling rules are recorded ❔, recovering 65 values in units never visited — [values](captures/unit-runtime-fields.csv) |
|
||||
| Arsenal develop economy | ✅/❔ | [arsenal-develop-economy](arsenal-develop-economy.md) + [conditions](captures/arsenal-develop-conditions.csv) | The Arsenal reads `weapon.tbl` (item ids, in the 8-category display order) and `strings.tbl` (names, descriptions, and a **"Conditions to obtain"** block per item) out of `GP_HANGAR_ARSENAL.pak`. All **60** conditions are extracted: gates are stage completion, a predecessor item, or an **ace kill**; costs run 3 000–350 000 P and **20 items are free** once gated. `weapon.tbl`'s first record reproduces the in-game DATA SHEET exactly (Range D / Power E / Speed – / Weight 0.3 = Light / 4000 P) — later records are unreadable from the string pool alone because IDXD **dedupes repeated values**. Used to identify the save blob's index space, now **solved**: the blob follows **`strings.tbl`'s** order — the display order *plus* the cut items only the localisation file lists (`Adhesive Mine B2A`, `Ballista GSH`, …) — pinned by four hand-written probe saves (9 Stiletto, 21 Falcon, 39 Tomahawk, 48 Jamming System) and closing exactly at index 53. `weapon.tbl`'s id list is **not** the index space; that it is also 54 long is a coincidence, and the two agree only to index 32. The retail save's five unexplained owned entries are the cut items, shipped owned and never rendered |
|
||||
| UI screen layout (`.rat`) | ✅/🟡 | [ui-rat-layout](structures/ui-rat-layout.md) | One pak per UI screen; each RATC = one (context × language) build; every `<name>.t32` sprite has a `<name>.rat` **layout record** (BE u32; 1280×720 design space; scale/tint/X/Y, keyframes for animated elements, `opt ` link to the focused state). **The tutorial PAUSE menu and the title main menu both rebuild pixel-accurately from the disc.** `loop1.rat` is decoded — it is a **looping sprite animation**, not a composition. The **screen's draw list is the RATC bundle's own declaration table** (elements in back-to-front order, including the `eff*`/`deli*`/`msg` sprites that have no `.rat`, and excluding focused button variants reached via `opt `); its entry also carries a **parent element index** at `+32`. **A screen is fully reconstructible from its bundle**: the placement region right after the declaration table gives every element a keyframe group (header = element index + keyframe count, then 40-byte blocks of scale/tint/X/Y), including the `.rat`-less sprites — verified 11/11 on the tutorial pause bundle, with `pgp_ttrl_btn10`'s inline (546,288) matching its own record exactly |
|
||||
| Save file (`savedata`) | ✅/❔ | [savegame-format](structures/savegame-format.md) + [`tools/re-capture/savegame.py`](../../tools/re-capture/savegame.py) | `GDHA` container, zlib payload, chunk stream (`GDAA` / phase name / `GHAD` 122 B progress block / 16×20 B slot table / trailer). **Container and layout read off the title's own serializer `0x822C00E8` and verified by a byte-identical round-trip**; the whole save is 545 B. Payload offsets are also the live save object's offsets (`save+8` GHAD, `save+136` slots). A second save made in-game names **Points** (+24), **flight time in ms** (+4) and **clear ratio %** (+8) off the game's own Details panel; the payload is a **pure function of game state** (same state saved twice = byte-identical, only the header FILETIME and its uninitialised pointer padding move), and the 16 `SHAB` records are **not** the UI's 20 save slots. Difficulty vs stage is undecided — three fields hold 2. **A third save, taken after developing exactly one Arsenal weapon** (Light Machine Gun MG I, 4000 P), moves exactly three things: `+24` Points 4101→101 (which **separates it from `+28`**, that did not move), `+8` clear ratio 5→6 (so the ratio counts *collection*, not only stages), and two entries of the 54-byte blob — `2→4` for the item bought and `0→2` for the successor the game announced as newly developable, giving the blob its alphabet ✅ *0 locked / 2 developable / 4 developed* (only the `4`s are stored — `2` is re-derived at load). **Saves can also be written back**: three derived header fields (length at `+0x30`, payload length at `+0x8c`, `adler32` at `+0x8e`) are all that stand between a parse and a hand-written save that the title loads, and [`savegame_edit.py`](../../tools/re-capture/savegame_edit.py) re-wraps a real save byte-identically. That turned the blob's index space from blocked-on-story-progress into four probe saves — see the [economy note](arsenal-develop-economy.md) |
|
||||
|
||||
## Runtime / dynamic-capture technique
|
||||
|
||||
| Technique | Conf. | Spec | Notes |
|
||||
|-----------|-------|------|-------|
|
||||
| Live guest-memory read | ✅ | [`tools/re-capture/gmem.py`](../../tools/re-capture/gmem.py) | Canary backs the guest address space with `/dev/shm/xenia_memory_*`; guest VAs map in through Xenia's fixed table. Full-RAM search ~0.2 s (sparse, `SEEK_DATA`). No debugger, no emulator patch, game keeps running |
|
||||
| IDXD object layout solver | ✅ | [`tools/re-capture/weapon_runtime.py`](../../tools/re-capture/weapon_runtime.py) | Scan RAM for a class's vtable → enumerate its objects → brute-force `(field, offset, encoding)` against the disc records. Accepts a binding only on **zero** contradictions. Generalizes to any IDXD-backed definition |
|
||||
| Live entity state, anchored on the definition | ✅ | [`tools/re-capture/own_state.py`](../../tools/re-capture/own_state.py) · [autopilot](autopilot-memory-driven.md) | An undamaged craft holds its definition's own numbers, so a *solved definition field* locates the matching live field without a value scan: definition `HP` (1500) → **hull at `position+0x154`**, confirmed by a trace across a death (30/60/90 per hit, negative at 0). Reusable for any live counter whose maximum the definition carries |
|
||||
| Mission / escort state, every entity's hull | ✅ | [`tools/re-capture/mission_state.py`](../../tools/re-capture/mission_state.py) · [escort state](mission-escort-state.md) | `hull = position + 0x154` is a property of the **entity class**, not of the player object: at t=0 it equals each entity's own definition `HP` across 7 classes and 5 distinct HP values (turret 100, fighter 500, destroyer 10000, cruiser 30000, **ACROPOLIS 25000**), falls under fire (780 damage events in 240 s), goes negative at death, and the object then leaves the heap. So an escort objective is scoreable live — `UN_f101_TCAF_Acropolis` measured at 25000 → 23038 over 240 s, attack starting only at t≈170 s. `REMAINING OB` counts objectives, not hostiles (012 on the HUD vs 118 live ADAN); its address is still ❔ |
|
||||
| In-flight control mapping | ✅/🟡 | [`tools/re-capture/fire_probe.sh`](../../tools/re-capture/fire_probe.sh) · [controls](flight-controls-runtime.md) | Measured by holding each pad input and photographing the HUD ammo counters: **`RB` = nose gun** (6000→5956 in 4 s, ~11 rounds/s, HEAT rises), **`Y` = main mount** (missiles, 300→299), d-pad = **tactical map** overlay, nothing else moves a counter. No target-cycle input exists — the `TARGET` marker is present with nothing pressed, so targeting is automatic and a missile lock is **time-on-target**. That, not target choice or ballistics, is what caps lethality at 2 kills per 98 missiles |
|
||||
| Input → dynamics calibration | ✅ | [`tools/re-capture/ctrl_probe.py`](../../tools/re-capture/ctrl_probe.py) · [`binq.py`](../../tools/re-capture/binq.py) | Hold each pad input in turn and measure the craft's speed as displacement/s of its own position triple — no speed field needed first. Settled the throttle: **`RT` accelerates, `LT` brakes, and the setting persists** (488 → 1510 → 174 units/s), overturning an earlier field-scan conclusion |
|
||||
| XBG7 mesh | 🟡/❔ | `sylpheed-formats/src/mesh.rs` + `tests/mesh_disc.rs` ([xbg7](structures/xbg7-mesh.md)) | weapons/props: declaration-driven variable stride (36 models), GPU-confirmed. **Stage containers: 5662 sub-models across 22 stages** via content-anchored grouped pools (`stage_models`). Quantized hero bodies (DeltaSaber `f004`) still declined |
|
||||
| Capital-ship part placement | 🟡 | `sylpheed-formats/src/ship.rs` (static) + [runtime capture](ship-placement-runtime-capture.md) | hull placement static-exact; external parts approximate statically. **Runtime capture** (Canary F10 → VS-constant WorldView) gives ground truth — validated on `e106` destroyer; not yet baked into the viewer |
|
||||
|
||||
## Functions / code paths
|
||||
|
||||
|
||||
@@ -1,69 +0,0 @@
|
||||
# Session log — 2026-08-11 (autonomous run)
|
||||
|
||||
What changed today, in the order a reviewer would want it, with the one item
|
||||
that needs **your decision** called out first.
|
||||
|
||||
## Needs a decision from you
|
||||
|
||||
**Editing save slot 01.** Save files can now be written back
|
||||
([savegame_edit.py](../../tools/re-capture/savegame_edit.py) re-wraps a real save
|
||||
**byte-identically**), and hand-written saves load. That unblocked several
|
||||
questions by probing throwaway slots. But the **title-menu screens read the
|
||||
auto-save (slot 01)**, so the remaining save-field questions (the difficulty
|
||||
enum, `SHAB.b`) need slot 01 itself edited — the only save with real progress.
|
||||
Not done. Recoverable (full content backup + slot 01's bytes archived), but it is
|
||||
your call. Everything else below was done in throwaway slots.
|
||||
|
||||
## Findings, by area
|
||||
|
||||
### Save format
|
||||
- **The develop differential**: buying one Arsenal weapon moves exactly three
|
||||
fields — Points `+24` (which **separates it from `+28`**), clear ratio `+8`
|
||||
(so the ratio counts *collection*, not stages), and two entries of the 54-byte
|
||||
blob. Blob alphabet: `0` locked / `2` developable / `4` owned; only the `4`s
|
||||
are stored, `2` is re-derived at load.
|
||||
- **The blob's index space is solved** — it follows `strings.tbl`'s item order,
|
||||
**cut items included**, pinned by four probe saves and closing exactly at 53.
|
||||
- **`SHAB` is the per-stage record table**: record 0 = Stage 01, and `c` is its
|
||||
best clear time in ms (`324773` = the `05:24.77` MISSION SELECT shows).
|
||||
- **Refuted**: every GHAD scalar as stage/difficulty (16 elements probed), and
|
||||
"stage = filled `SHAB` count + 1".
|
||||
|
||||
### Formats
|
||||
- **T8aD 96 % → 100 %** of the disc: a surface is a list of **sub-rectangles**
|
||||
(`dst X, dst Y, w, h` per rectangle), not a 256 grid. The "~15 % variants" were
|
||||
a wrong model.
|
||||
- **LSTA**: the count was never unreliable — it counts **sprites *and* `PRMD`
|
||||
primitives** (64/64 exact).
|
||||
- **RATC**: "one level deep" is not a limitation; nested records are **leaves
|
||||
that reference siblings by name** (10 144/10 148 resolve).
|
||||
- **UI screens are fully reconstructible from their bundle** — element list +
|
||||
order (declaration table, with a **parent index**) and placement/animation
|
||||
(keyframe region). **Validated against the running game to ±2 px.**
|
||||
- **Movie ↔ subtitle ↔ voice link solved statically** (101 movies) — `INDEX` had
|
||||
it filed as needing the running game.
|
||||
- **XPR2 channel order confirmed** against the game (hue 23.3° vs 9.3°).
|
||||
|
||||
### Meshes — the user-reported viewer bug
|
||||
- Root-caused, **after one wrong turn I corrected in place**: the giant slab on
|
||||
`e106` is not a stray volume but an **XBG7 mis-decode** — the same resource is a
|
||||
49×23×42 turret in 11 containers and 1600×2100×4800 in 3.
|
||||
- **New detector**: a resource shared across containers must decode to the same
|
||||
bounds. **125 of 681** shared resources fail that check — a measured lower
|
||||
bound on *silent* mis-decodes (distinct from the 814 honest declines).
|
||||
|
||||
## Two disc defects found
|
||||
`SUBTITLE_S12B.tbl` (referenced by the movie table, present in **no** language)
|
||||
and `pmbase.t32` (placed by `pmbase.rat`, present **nowhere**). A reimplementation
|
||||
should skip a missing asset rather than treat it as a decode failure.
|
||||
|
||||
## Process notes worth keeping
|
||||
- Several "the data is inconsistent" comments meant **our model was incomplete**
|
||||
(T8aD variants, the LSTA count). Re-test such notes rather than routing around
|
||||
them.
|
||||
- A test that walks the *oracle's* items and looks each up in our output **can
|
||||
only fail one way** — it never sees extras. That shape hid the ship bug and,
|
||||
earlier, `include_external`.
|
||||
- When a diagnosis has eliminated every hypothesis and the last step is *a
|
||||
visual*, do the visual first. Three iterations went by before a 30-second
|
||||
render showed it.
|
||||
@@ -1,255 +0,0 @@
|
||||
# The Arsenal develop economy, and what the save's blob indexes
|
||||
|
||||
**2026-08-11.** The save file's 54-byte blob was shown to be per-item development
|
||||
state by [a runtime differential](structures/savegame-format.md#the-develop-differential-one-weapon-three-fields) —
|
||||
one weapon bought, two entries moved, `2 → 4` for the item and `0 → 2` for the
|
||||
successor. That named the *values*. This note names the *index space*, and in
|
||||
passing recovers the whole develop economy from the disc.
|
||||
|
||||
## Where the Arsenal gets its data
|
||||
|
||||
`dat/GP_HANGAR_ARSENAL.pak` carries one screen-config record per language whose
|
||||
fields point at the rest:
|
||||
|
||||
```
|
||||
PATH = dat\GP_HANGAR_ARSENAL.pak+eng\
|
||||
WEAPON = weapon.tbl STRINGS = strings.tbl
|
||||
WEAPON_CATEGORIES = 8 Detail_Window_Known / Detail_Window_Unknown
|
||||
ConditionToDevelop = 757,228 WeaponDesc = 734,502 Range = 891,73 …
|
||||
```
|
||||
|
||||
`WEAPON_CATEGORIES = 8` is the eight tabs the screen cycles with LB/RB (GUN,
|
||||
BEAM, LASER, MULTIPURPOSE MISSILE, ANTI-SHIP MISSILE, BOMB/ROCKET, CANNON,
|
||||
SPECIAL). The `…= x,y` fields are screen positions for that screen's labels —
|
||||
`ConditionToDevelop` is *where the conditions text is drawn*, not a condition.
|
||||
|
||||
### `eng\weapon.tbl` — the item table (IDXD, schema `0x03c244b5`, 66 records)
|
||||
|
||||
Its string pool opens with a stage list, then the literal key `WEAPONS`
|
||||
followed by the item ids **in table order**:
|
||||
|
||||
```
|
||||
No_Equipment, Machiene_Cannon_MG1, Machiene_Cannon_MG2H, Machiene_Cannon_MG3,
|
||||
Machiene_Cannon_MG5H, Broad_Sword_SG1, Swing_Sword_SG2H, Twin_Sword_SG3II,
|
||||
Frail_GP37, Stiletto_BG1, Dagger_BG2, Rapier_BG4H, Pilum_BP, … , Wep_83,
|
||||
Wep_84, Wep_85, NullWeapon_Arm1, NullWeapon_Arm2, NullWeapon_Arm3
|
||||
```
|
||||
|
||||
The ids are grouped by the eight categories in the same order the screen shows
|
||||
them — verified item-for-item against the running game (see the all-owned probe
|
||||
below). Note one **coincidence that cost time**: the run `No_Equipment … Wep_83`
|
||||
is also 54 entries, the save blob's length, which invites the conclusion that this
|
||||
list *is* the blob's index space. It is not — the two agree only up to index 32.
|
||||
The blob follows `strings.tbl`'s order, which carries items this list omits.
|
||||
|
||||
Each item then has a record: `Size, Weight, Range, Power, Speed, Stage,
|
||||
MissionObjective, Dependency, Points`. For the **first** record all of it reads
|
||||
straight out, and it matches the running game exactly:
|
||||
|
||||
| field | disc | in-game DATA SHEET for Light Machine Gun MG I |
|
||||
|---|---|---|
|
||||
| Range | `D` | `Range Class D` |
|
||||
| Power | `E` | `Damage Class E` |
|
||||
| Speed | `-` | `Speed Class –` |
|
||||
| Weight | `0.3` | `Weight Class Light` |
|
||||
| Points | `4000` | `4000 P` on the develop row |
|
||||
|
||||
**Caveat, and it is a real one:** IDXD string pools store each distinct string
|
||||
*once*, so from the second record onward every value that repeats an earlier
|
||||
string is absent from the token stream. Record 2 (MG2H) shows only its unique
|
||||
values — `0.4` and `3000` — and record 6 shows no number at all because its cost
|
||||
had already been seen. So `weapon.tbl`'s per-item fields cannot be read from the
|
||||
pool alone; they need the binary node/index region, which is still undecoded
|
||||
(see the module docs in `idxd.rs`). The prose table below is the practical
|
||||
substitute.
|
||||
|
||||
### `eng\strings.tbl` — the economy in prose (IXUD, UTF-16BE)
|
||||
|
||||
The same pak's string table holds, per item: the internal id, the display name,
|
||||
the description, and a **"Conditions to obtain …"** block that spells out the
|
||||
gate and the price:
|
||||
|
||||
> Conditions to obtain Light Swivel Machine Gun MG2H — Completed development of
|
||||
> the Light Machine Gun MG1 — Must spend 3000 points to develop
|
||||
|
||||
All 60 of them are extracted to
|
||||
[`captures/arsenal-develop-conditions.csv`](captures/arsenal-develop-conditions.csv)
|
||||
with the stage gate, the cost and the prerequisite split out. The shape of the
|
||||
economy:
|
||||
|
||||
- gates are **stage completion** (`Complete Stage 1 … 15`), **a predecessor
|
||||
item** (`Completed development of the …`), or **an ace kill** (`Shoot down the
|
||||
ace pilot in Stage 11/13/14`);
|
||||
- costs run 3 000 → 350 000 points, and **twenty items have no cost at all**
|
||||
(`Tomahawk Alpha Rail Gun — Complete Stage 1`). Those are still *bought*, for
|
||||
**0 P** — see the probe below, which caught one at `0 P` — which is why they
|
||||
read as `Developed` in a list the player never spent points in;
|
||||
- two items are anomalies worth flagging: `Adhesive Mine B2A` says "Must spend
|
||||
points to develop" with **no number**, and ten late entries (`Ballista GSH`,
|
||||
`Designator LH`, `Smoke Marker Launcher`, `Bumble UV`, `Ballista 24 Rocket
|
||||
Launcher`, `Thrush 220AM`, `Divider L3GP`, `Mace GP25H`, `Thor Gun System`,
|
||||
`Spitfire BX`) have a conditions *header* and no conditions — ❔ cut content or
|
||||
non-player weapons.
|
||||
|
||||
## How the first 32 entries were confirmed
|
||||
|
||||
Predicting the save state from the conditions and comparing against the actual
|
||||
blob is a strong test, because it is made **before** looking at the blob. At the
|
||||
captured state (Stage 1 complete, Stage 02 at standby, 4101 P) the conditions say
|
||||
exactly six items are developable — Light Machine Gun MG1, Broad Sword SG1,
|
||||
Dagger BG2, Pilum BP, Hound SMH, Dart 23 Rocket — and the blob's **six** `2`s sit
|
||||
at WEAPONS-order indices **1, 5, 10, 12, 27, 31**, which are those six items, in
|
||||
order. Nothing had to be fitted.
|
||||
|
||||
Indices 0–32 are the same item in either order, so this table stands unchanged
|
||||
under the final mapping.
|
||||
|
||||
| blob | value | item | confirmed by |
|
||||
|---|---|---|---|
|
||||
| 0 | 4 | `No_Equipment` | always available |
|
||||
| 1 | 2→4 | `Machiene_Cannon_MG1` | the differential: bought for 4000 P |
|
||||
| 2 | 0→2 | `Machiene_Cannon_MG2H` | the differential: announced as newly developable |
|
||||
| 5 | 2 | `Broad_Sword_SG1` | `BROAD SWORD SG1 5000P`, **below the fold** in the GUN list |
|
||||
| 9 | 4 | `Stiletto_BG1` | `Developed`; "Initially Mounted"; mounted as NOSE WEAPON |
|
||||
| 10 | 2 | `Dagger_BG2` | `DAGGER BG2 5000P` |
|
||||
| 12 | 2 | `Pilum_BP` | `PILUM BP 6000P` |
|
||||
| 21 | 4 | `Falcon_9AM` | `Developed`; "Initially Mounted"; mounted as MAIN WEAPON 1 |
|
||||
| 22 | 4 | `Buzzard_10AM` | `Developed`; free at Stage 1 |
|
||||
| 26 | 4 | `Terrier_SMH` | `Developed`; free at Stage 1 |
|
||||
| 27 | 2 | `Hound_SMH` | `HOUND SMH 10000P` |
|
||||
| 31 | 2 | `Dirt_23_Rocket` | `DART 23 ROCKET 3500P` ("Dart" is the localised "Dirt") |
|
||||
|
||||
Twelve concordances, no contradiction, over indices 0–31.
|
||||
|
||||
## The full index space ✅ — it is the **localisation** order, cut items included
|
||||
|
||||
Written after the probes below, which settled it. The blob is **not** indexed by
|
||||
`weapon.tbl`'s `WEAPONS` id list. It is indexed by the order the items appear in
|
||||
`strings.tbl` — the same order, *plus* the handful of items that exist only there:
|
||||
`Adhesive Mine B2A` (a "Conditions to obtain" block whose cost is missing) and the
|
||||
four late entries with a conditions *header* and no conditions. Those never appear
|
||||
in the Arsenal, but they **hold slots in the save**, and that is the whole reason
|
||||
the tail looked broken.
|
||||
|
||||
| blob | block | items (display names, in order) |
|
||||
|---|---|---|
|
||||
| 0 | — | `No_Equipment` |
|
||||
| 1–8 | GUN | Light Machine Gun MG1, Light Swivel MG2H, Heavy MG3, Heavy Swivel MG5H, Broad Sword SG1, Swing Sword SG2H, Twin Sword SG3II, Flail GP37 |
|
||||
| 9–16 | BEAM | **Stiletto BG1** ⌾, Dagger BG2, Rapier BG4H, Pilum BP, Multi Pike BP, Spear HBP, Long Spear HBP, Gray Head T76H |
|
||||
| 17–20 | LASER | Saber LG1, Twin Saber LG2H, Needle L1GP, Fire Arrow L2GP |
|
||||
| 21–25 | MPM | **Falcon 9AM** ⌾, Buzzard 10AM, Hawk 75AM, Condor 105AM, Eagle 120AM |
|
||||
| 26–30 | ASM | Terrier SMH, Hound SMH, Pointer SM, Piranha T53, White Shark T53R |
|
||||
| 31–38 | BOMB/ROCKET | **Dart 23 Rocket** ⌾, Arrow 27 Rocket, *Adhesive Mine B2A — never displayed*, EMP Mine B8E, Laser Mine B9L, Cauldron 50 Rocket, Cluster Mine B10, Maelstrom Bomb |
|
||||
| 39–47 | CANNON | **Tomahawk Alpha Rail Gun** ⌾, Sling 75KG, Glaive 120mm Cannon, Arbalest 155KG, Monoceros Long Cannon, Grav Cannon XGS, *+ three never-displayed slots* |
|
||||
| 48–53 | SPECIAL | **Jamming System** ⌾, Shield Doubler, Booster, Fire Control System, Regenerator, Cartridge Holder |
|
||||
|
||||
⌾ = pinned by an anchor: `9`, `21`, `39` and `48` were each **written into a save by
|
||||
hand** and read back off the screen; `31` is the Dart 23 Rocket's price row in the
|
||||
untouched save. The array ends exactly at 53 with the last SPECIAL item, with
|
||||
nothing left over — 8+8+4+5+5+8+9+6 plus `No_Equipment` is 54.
|
||||
|
||||
The three never-displayed CANNON-block slots are three of `Ballista GSH`,
|
||||
`Designator LH`, `Smoke Marker Launcher`, `Bumble UV` — the four cut entries
|
||||
`strings.tbl` lists between Grav Cannon XGS and Jamming System. **Which three** is
|
||||
🟡 undetermined and does not matter for reading a save; nothing displays them.
|
||||
|
||||
**This explains every anomaly in the retail save.** Its `4`s at 33 and at 45/46/47
|
||||
are the cut items — `Adhesive Mine B2A` and three of the four above — shipped
|
||||
flagged as owned. They never render, so no player ever sees them, and they are
|
||||
exactly the five "unexplained" owned entries that made the tail look wrong. The
|
||||
Tomahawk reading `Developed` at `blob[39]` while `weapon.tbl` puts it at 38 was
|
||||
the same off-by-N, seen from the other side.
|
||||
|
||||
## How the tail was actually settled (and what was wrong first)
|
||||
|
||||
Past index 31 the `weapon.tbl` alignment fails, and it fails against the screen,
|
||||
not against a theory — this is the evidence that sent the investigation to the
|
||||
localisation order above:
|
||||
|
||||
- `Tomahawk_a_Rail_Gun` is WEAPONS index **38** and the CANNON list shows it
|
||||
`Developed` (it is free once Stage 1 is complete) — but **blob[38] = 0**.
|
||||
- The blob's remaining `4`s are at **33, 39, 45, 46, 47**. In WEAPONS order those
|
||||
are `EMP_Mine_B8E`, `Sling_75KG`, `Shield_Doubler`, `Booster`,
|
||||
`FireControlSystem` — and **every one of them is shown as not developed**:
|
||||
BOMB/ROCKET lists only `DART 23 ROCKET 3500P`, CANNON only the Tomahawk, and
|
||||
**the SPECIAL tab is entirely empty** (all rows dashed). Their conditions agree
|
||||
— Shield Doubler needs Stage 12, Booster an ace kill in Stage 11, FCS Stage 6.
|
||||
|
||||
So five `4`s in the tail correspond to nothing the Arsenal reports as owned, and
|
||||
one genuinely-owned item reads `0`. A single `+1` shift does not repair it
|
||||
either: `blob[39] = 4` would put the Tomahawk right, but then `blob[33] = 4`
|
||||
lands on `Arrow_27_Rocket` (Stage 2 + 5000 P, unreachable here) and 45/46/47
|
||||
still land on locked SPECIAL items.
|
||||
|
||||
### Tested actively, with a hand-written save
|
||||
|
||||
Waiting for a mission payout was not necessary. The save container's derived
|
||||
fields turned out to be reproducible (see
|
||||
[`savegame_edit.py`](../../tools/re-capture/savegame_edit.py) — the whole
|
||||
container re-wraps **byte-identically**), so the blob could be *written* and the
|
||||
result read off the screen. A probe save was built in our own throwaway slot 03
|
||||
with the blob zeroed except `0, 9, 21, 33, 38, 45 = 4` and `39, 46 = 2`, and it
|
||||
**loaded**.
|
||||
|
||||
What it showed:
|
||||
|
||||
- **The controls rendered.** `9` → BEAM shows `STILETTO BG1 Developed`; `21` →
|
||||
MULTIPURPOSE MISSILE shows `FALCON 9AM Developed`. So a hand-written `4` does
|
||||
reach the screen, and indices 9 and 21 are those items — now by experiment,
|
||||
not by correlation.
|
||||
- **The tail probes rendered nothing.** `33` should have made a BOMB/ROCKET row
|
||||
`Developed` (row 3 of that list, on screen, not below the fold) — it stayed
|
||||
dashed. `45` should have made a SPECIAL row `Developed` — the SPECIAL tab
|
||||
stayed entirely empty. And `38` should have been the Tomahawk — instead the
|
||||
CANNON list showed `TOMAHAWK ALPHA RAIL GUN — 0 P`, i.e. *not owned*.
|
||||
- **Clearing the real save's tail `4`s cost the Tomahawk its status.** In the
|
||||
unedited save the Tomahawk reads `Developed` while `blob[38] = 0`; the probe
|
||||
cleared `{22, 26, 39, 46, 47}` and the Tomahawk stopped being owned — so its
|
||||
flag is one of the cleared entries, with **39** the positional candidate. A
|
||||
uniform `+1` shift past index 32 would explain that, but it fails elsewhere:
|
||||
under it the real save's `45/46/47` are Chaff Flare Dispencer / Shield Doubler
|
||||
/ Booster, and the SPECIAL tab is empty in that same save.
|
||||
|
||||
Three further probes settled it, and the reasoning is worth keeping because the
|
||||
first read of the same evidence was wrong.
|
||||
|
||||
1. **Every slot owned.** With all 54 entries set to `4`, every tab filled and the
|
||||
lists **wrap**, which gives exact counts: GUN 8, BEAM 8, LASER 4, MPM 5, ASM 5,
|
||||
BOMB/ROCKET **7**, CANNON 6, SPECIAL 6 — 43 items — and the display order is
|
||||
`weapon.tbl`'s order, item for item. Note what this probe *cannot* do: with
|
||||
everything owned, any surjective mapping looks the same. It bounds, it does not
|
||||
pin. It also killed the "gate-unmet flags are suppressed" idea outright —
|
||||
Maelstrom Bomb (Stage 6) and Grav Cannon XGS (Stage 12) both rendered
|
||||
`Developed` at a Stage-2 save.
|
||||
2. **One slot owned: `39`.** `blob = 0` except `9` (control) and `39` → BEAM showed
|
||||
`STILETTO BG1 Developed` **and CANNON showed `TOMAHAWK ALPHA RAIL GUN
|
||||
Developed`**. So the CANNON block starts at 39, not 38: exactly one slot more
|
||||
than the display between Dart 23 (31) and the Tomahawk.
|
||||
3. **One slot owned: `48`.** `blob = 0` except `39` and `48` → SPECIAL showed
|
||||
`JAMMING SYSTEM Developed`. That fixes the SPECIAL base, and with six SPECIAL
|
||||
items the array closes exactly at 53.
|
||||
|
||||
The earlier probe's `45 = 4` leaving SPECIAL empty — which had looked like the
|
||||
mapping failing — is simply a cut item: 45 is in the CANNON block's
|
||||
never-displayed tail, not in SPECIAL at all.
|
||||
|
||||
### Two behaviours the probe exposed
|
||||
|
||||
- **`2` is derived, not stored.** On load the title recomputes which items are
|
||||
developable from its own conditions and *announces the difference* — zeroing
|
||||
Light Machine Gun MG1 and Broad Sword SG1 produced "You can now develop Broad
|
||||
Sword …" and both came back priced in the list. Only the owned (`4`) entries
|
||||
are authoritative state; writing `2` is pointless, and writing `0` over an
|
||||
item whose conditions are met is undone at load.
|
||||
- **The free items are bought for zero, not granted.** `TOMAHAWK ALPHA RAIL GUN
|
||||
— 0 P` is what an unowned no-cost item looks like. That is the real reason a
|
||||
save where the player never spent points still shows items as `Developed`
|
||||
(this note previously said "granted" — the mechanism is a 0 P purchase).
|
||||
|
||||
## Evidence
|
||||
|
||||
- [`captures/arsenal-develop-conditions.csv`](captures/arsenal-develop-conditions.csv) — all 60 conditions blocks.
|
||||
- [`captures/arsenal-categories-all.png`](captures/arsenal-categories-all.png) — the eight category tabs.
|
||||
- [`captures/arsenal-gun-below-fold.png`](captures/arsenal-gun-below-fold.png) — Broad Sword SG1, the entry that is not visible without scrolling.
|
||||
- [`captures/arsenal-probe-save-result.png`](captures/arsenal-probe-save-result.png) — the hand-written save's result: controls at 9/21 render `Developed`, the tail probes render nothing, and the Tomahawk shows `0 P`.
|
||||
- [`captures/arsenal-gun-list-predevelop.png`](captures/arsenal-gun-list-predevelop.png) · [`captures/arsenal-mg1-developed.png`](captures/arsenal-mg1-developed.png) — the differential itself.
|
||||
@@ -1,299 +0,0 @@
|
||||
# Memory-driven autopilot — build log and current state
|
||||
|
||||
**Status: 🟢 IT FLIES, KILLS AND SURVIVES — but it loses the mission anyway.**
|
||||
Updated 2026-07-30. `pilot.py` flew Stage 02 for **300 s with the hull untouched
|
||||
at 1500/1500** and scored the first confirmed autopilot kill (`YOU KILLED
|
||||
WARPLANES 0001` on the HUD, screenshots `shots/pilot1-*.png`); the scene's
|
||||
hostile count fell from 134 to 111 over the run. The day before, every run was
|
||||
dead inside 35 s. What is still missing is the *end* of a mission: the objective
|
||||
counter (`REMAINING OB`) rises as new waves spawn, and nothing yet tracks which
|
||||
targets actually close it out — and the second run proved the point the hard
|
||||
way: `GAME OVER` with the hull at 1500/1500, because Stage 02 is an **escort**
|
||||
and the ACROPOLIS was sunk while the pilot chased fighters two kilometres away.
|
||||
|
||||
## 2026-07-30 — the numbers survival needs
|
||||
|
||||
Three things the loop was missing were measured this session, each by
|
||||
consequence rather than by reading a field and hoping.
|
||||
|
||||
### Hull is `position + 0x154` ✅ CONFIRMED
|
||||
|
||||
The unit definition already had `HP` solved at `+0x054`
|
||||
([unit-struct-runtime](structures/unit-struct-runtime.md)); the Delta Saber's is
|
||||
**1500**. A craft that has taken no damage must therefore *contain that number*,
|
||||
which turns "find the HP field" into a two-float lookup rather than a value scan
|
||||
(`own_state.py`). It appears once in the entity object, at `pos+0x154`, and the
|
||||
trace across a death settles it (`ctrl_probe.py` capture, `binq.py trace`):
|
||||
|
||||
```
|
||||
t phase hull
|
||||
0.00 base 1500.00 <- == definition HP
|
||||
23.25 rest_A 1380.00 <- first hit, -120
|
||||
26.68 … 27.18 B 1320 … 930 <- seven hits in 0.5 s
|
||||
31.93 X 150.00
|
||||
35.21 Y -30.00 <- goes negative
|
||||
35.26 Y -180.00 -> GAME OVER on screen
|
||||
```
|
||||
|
||||
Damage arrives in 30/60/90-point steps and the field goes *negative* at death,
|
||||
so it is the raw hull counter, not a clamped display value. **1500 hull lost in
|
||||
12 s** of sitting in a turret's line of fire is the whole reason every earlier
|
||||
run died.
|
||||
|
||||
### Shield is `position + 0x430` 🟡 PROBABLE — not yet confirmed live
|
||||
|
||||
Same anchor trick: the definition's shield `MaxValue` is **400** and
|
||||
`ChargeSpeed` **25**, and the entity object holds `400.0` at `+0x430`, `+0x434`
|
||||
and `+0x438`, with `25.0` at `+0x448`. Which of the three is the *current* value
|
||||
is unproven — the capture that spanned the death used a ±0x400 window and
|
||||
cropped them out. `ctrl_probe.py` now samples ±0x800.
|
||||
|
||||
### `RT` accelerates, `LT` brakes, and the throttle is a *setting* ✅ CONFIRMED
|
||||
|
||||
`ctrl_probe.py` holds each input in turn and measures the craft's own speed as
|
||||
displacement per second from the position triple, so no speed field is needed.
|
||||
Distance flown / phase duration, one 3 s hold each, sticks neutral:
|
||||
|
||||
| phase | speed (units/s) | | phase | speed (units/s) |
|
||||
|---|---|---|---|---|
|
||||
| base (no input) | 488 | | A | 287 |
|
||||
| **RT** | **1510** | | B | 139 |
|
||||
| rest after RT | 1056 | | X | 125 |
|
||||
| **LT** | **174** | | Y | (dying) |
|
||||
| rest after LT | 428 | | LB / LS / RS / RY / RX / dpad | no effect |
|
||||
|
||||
RT triples the speed, LT cuts it to a third, and **the braked state persists**:
|
||||
after the LT phase the craft sat at 125–140 units/s with the sticks and triggers
|
||||
neutral for the remaining 40 s, and nothing but RT brought it back. So these are
|
||||
a throttle setting, not a momentary boost — which also means a control loop must
|
||||
send only the *changes*.
|
||||
|
||||
This **corrects** the earlier note in this file ("`RT` is *not* the throttle,
|
||||
and no button tested is"). That conclusion came from `findspeed.py`, which
|
||||
assumed the control and went looking for a *field* that rose; measuring the
|
||||
speed directly reverses it.
|
||||
|
||||
### Two method corrections
|
||||
|
||||
* **Pick the attitude block by the flight path, not by address order.** The
|
||||
player object contains **20** orthonormal 3×3 blocks (identity frames, bone
|
||||
or camera frames), and `pos-0x70` and `pos-0x30` hold the *same* matrix.
|
||||
Taking `found[0]` wrote a config with `rot_delta = -0x764` and a nonsense
|
||||
forward axis; `entities2.py self` now scores every block against the measured
|
||||
direction of travel and picks the best (`cos = +1.000`, row 2, sign +1).
|
||||
* **The entity-heap scan has to be numpy.** A per-word Python loop over the
|
||||
16 MB entity region costs seconds per scan, which is the whole budget of a
|
||||
10 Hz control loop; `np.isin` over a `>u4` view is milliseconds.
|
||||
|
||||
### Stage 02 as an autopilot testbed (from the in-flight HUD)
|
||||
|
||||
`OBJECTIVE: shoot down all invading enemy fighters while watching out for
|
||||
attacks on the ACROPOLIS` · `DEFEAT: your fighter is shot down, or the ACROPOLIS
|
||||
is sunk` · `HINT: you can resupply at the ACROPOLIS`. The HUD shows
|
||||
**`REMAINING OB 004`** — only four objective targets — so this mission is
|
||||
winnable by an autopilot that survives. It also shows separate **SHIELD** and
|
||||
**ARMOR** bars (matching a 400-point shield over 1500 hull), `A/B 7,635`
|
||||
afterburner, and `NOSE BM 06000` / `MAIN MPM 00300` ammo.
|
||||
|
||||
## What the loop did before that, observed
|
||||
|
||||
```
|
||||
[ 82.5] tgt=e007_ADAN_Turret d=3384 yaw= -7.3 pit=+14.6 stick=(-0.13,-0.34) fire=0
|
||||
[ 85.7] tgt=e007_ADAN_Turret d=2797 yaw= +1.9 pit=+27.2 stick=(+0.20,-0.59) fire=0
|
||||
[117.3] tgt=e007_ADAN_Turret d=4211 yaw= +5.7 pit= +9.0 stick=(+0.25,-0.40) fire=1
|
||||
```
|
||||
|
||||
Distance closes monotonically, yaw error is driven from −8° to ~0, and once both
|
||||
errors are inside the firing cone it holds RB and the ammo counter falls. A
|
||||
rescan reports the scene as e.g. `136 entities {'TCAF': 16, 'ADAN': 120}`.
|
||||
|
||||
**The chain that made it work** — each link checked, not assumed:
|
||||
|
||||
1. **Entity typing.** A live entity's definition pointer sits at
|
||||
**position + 0x130**. One heap scan then yields every craft *with its unit
|
||||
type*, which is what separates 20-odd real combatants from ~30 000 moving
|
||||
particles. Verified by the result being coherent: wingmen, enemy turrets and
|
||||
attackers, friendly capital ships, and exactly one `…_Player`.
|
||||
2. **Orientation.** A 3×3 rotation at **position − 0x70**, stored with a
|
||||
**16-byte row stride** (a 4×4 transform whose translation row *is* the
|
||||
position). An earlier search for nine *contiguous* floats structurally could
|
||||
not find this, which is why the first pass concluded "no transform". The
|
||||
binding is confirmed independently: its row 2 matches the craft's measured
|
||||
direction of travel with **cos = +1.000**.
|
||||
3. **The fire button is RB** — established by consequence, not by guessing:
|
||||
of RB/LB/A/B/X/Y/RT/LT, pressing RB is the only one that makes the nose-ammo
|
||||
counter in RAM fall (5958 → 5940). (This entry also claimed `RT` is *not* the
|
||||
throttle — **wrong**, see the 2026-07-30 measurement above.)
|
||||
4. **Control.** PD on the aiming error with the derivative taken from the
|
||||
craft's own body angular velocity (from two consecutive rotation matrices),
|
||||
and target selection weighted by off-boresight angle
|
||||
(`score = d·(1 + 3·(θ/π)²)`) rather than pure nearest — closing on a target
|
||||
90° off the nose only raises the bearing rate, which is what held the first
|
||||
run outside its firing cone at a steady ~27° pitch error.
|
||||
|
||||
## Goal
|
||||
|
||||
Fly and fight a mission by reading the game's own world state out of guest RAM
|
||||
and driving the pad from it — the RE payoff being an oracle for the
|
||||
reimplementation's flight model and AI, and a way to reach missions the save
|
||||
cannot otherwise reach (unit coverage for
|
||||
[unit-struct-runtime](structures/unit-struct-runtime.md) is capped at 21/110
|
||||
because definitions load **per stage**).
|
||||
|
||||
## What works (verified)
|
||||
|
||||
| Piece | Tool | Evidence |
|
||||
|---|---|---|
|
||||
| Live guest-RAM reads at loop rate | `gworld.py` | `/dev/shm` file opened once, `pread` per tick; a whole-RAM scan is ~6 s, a targeted read is microseconds |
|
||||
| Whole-RAM float scanning | numpy over `SEEK_DATA` extents | 1 270 orthonormal 3×3 blocks located in 6.2 s |
|
||||
| Entity enumeration by unit type | `gworld.py entities` | 116 live instances in Stage 02, typed by unit ID, incl. exactly one `…_Player` |
|
||||
| Pad control at loop rate | `flight_probe.Pad` | writes command lines straight into the vgamepad FIFO; the `vgamepad` CLI spawns a process per command and its `tap`/`hold` sleep *inside* the server, so neither is usable in a control loop |
|
||||
| Unattended mission entry | `launch_mission.sh` | title → LOAD GAME → slot 01 → READY ROOM → TAKE OFF → in flight, repeatable |
|
||||
| Hangar loadout | `launch_mission.sh --hangar` | the "Recommended" control is **AUTO SELECT — "Mount most suitable weapons"**, already the default cursor position. At 5 % progress it is a no-op: only two weapons are developed, and they are already mounted |
|
||||
| Finding moving objects | `findplayer.py` | position triples recovered from motion alone — straight-line, constant-speed filter over K whole-RAM samples |
|
||||
|
||||
## What is NOT solved
|
||||
|
||||
**Survival, and therefore mission completion.** The loop has no evasion, no
|
||||
shield/armour awareness and no throttle control, so it flies a straight pursuit
|
||||
into defended space and is eventually shot down — every long run so far has
|
||||
ended in GAME OVER. Completing a mission needs, at least: reading own
|
||||
shield/armour, breaking off when hit, and prioritising the mission's actual
|
||||
objective targets over the nearest turret.
|
||||
|
||||
### Superseded (kept because the reasoning still matters)
|
||||
|
||||
The notes below were written before the chain above worked. They remain true as
|
||||
statements about `0x820af030`, which is *not* the live entity —
|
||||
|
||||
1. **The `0x820af030` class is not the live entity.** It has one object per
|
||||
spawned thing and carries the unit-ID string, so it looked like the entity
|
||||
list — but over a 29 s in-flight capture **all 384 words of it are
|
||||
constant** (`whatchanges.py`). It is a static spawn record. The earlier
|
||||
claim in `unit-struct-runtime.md` that this class is "the spawned entity
|
||||
instance — live state" is **wrong in the second half**: it is per-spawn, but
|
||||
it is not live state. The parts of that document that depend on the
|
||||
*definition* class `0x820af844` are unaffected.
|
||||
2. **No transform in or one hop from that object**: no orthonormal 3×3, and no
|
||||
unit quaternion, within `0x2000` of it or behind any of its 121 pointers.
|
||||
3. **Input correlation finds *a* self-object, but not obviously the craft.**
|
||||
Holding hard-left then hard-right yaw and looking for a position whose turn
|
||||
axis reverses (`findself.py`, `selfstate.py`) gives clean hits
|
||||
(`cos ≈ −0.99`), but they cluster at `0x40009xxx` in what looks like an
|
||||
8-corner box with ±45 000 coordinates — a camera/skybox volume that follows
|
||||
the player, not the craft. Its speed (≈359/s) is suspiciously close to the
|
||||
HUD's 350, which supports "follows the player" but is not proof of identity.
|
||||
4. **Entity typing is unavailable**: no definition pointer within ±0x800 of the
|
||||
self-position, so the trick of learning one object's layout and applying it
|
||||
to all the others has nothing to anchor on. Without typing, the 33 418
|
||||
moving triples in a firefight cannot be separated into enemies, friendlies
|
||||
and bullets, so there is nothing to aim at.
|
||||
|
||||
## Dead ends, recorded so they are not re-run
|
||||
|
||||
* **Speed-scan for the player object** (`findspeed.py`, the classic two-state
|
||||
value scan: coast → boost → coast). Sound method, but **`RT` is not the
|
||||
throttle** — 5 864 floats matched the cruise speed and none rose. The control
|
||||
actually bound to acceleration was never established, and the run that would
|
||||
have established it ended in GAME OVER.
|
||||
* **Comparing orientation matrices 2 s apart.** At a real turn rate that is far
|
||||
outside the small-angle regime, so the skew part of `A·Bᵀ` is not the rotation
|
||||
vector and the "angular velocity" comes out as ~30 000. Sample incrementally
|
||||
(6 Hz) and re-check orthonormality on every read — blocks found by a scan get
|
||||
overwritten between the scan and the read.
|
||||
|
||||
## The second run lost the mission **without being hit** (2026-07-30)
|
||||
|
||||
A second 240 s flight, with the two fixes above, ended on the `GAME OVER`
|
||||
screen — while the hull read **1500/1500 on the last live tick**. Nothing shot
|
||||
us down. The other defeat condition fired: *the ACROPOLIS is sunk*. The HUD had
|
||||
been showing a red `WARNING` banner for a while, and the pilot spent the whole
|
||||
run pursuing an `e010_ADAN_Attacker_S` two kilometres away.
|
||||
|
||||
So surviving is necessary and not sufficient, and "nearest hostile fighter" is
|
||||
the wrong objective function for this stage. **The mission is an escort.** What
|
||||
follows:
|
||||
|
||||
* **Prioritise hostiles by their distance to the protected asset, not to us.**
|
||||
The attackers worth killing are the ones closing on the ACROPOLIS.
|
||||
* **The protected asset's health is readable with the same anchor as ours** —
|
||||
hull at `position + 0x154`, its maximum being its own definition's `HP`. That
|
||||
gives a live "are we winning" signal for the escort, and it should drive the
|
||||
target choice directly.
|
||||
* A frozen tail in the log (identical position, speed and target for the last
|
||||
five seconds) is what mission-end looks like from the outside, **not** an
|
||||
emulator wedge. Worth knowing before diagnosing the wrong thing.
|
||||
* Practical: do **not** pipe a long run's log through `tail` — that discards
|
||||
everything but the end, and the interesting part of this run is gone.
|
||||
|
||||
## After survival, the blocker is lethality (2026-07-30)
|
||||
|
||||
The 300 s run took **no damage at all** and killed **one** warplane, spending
|
||||
~800 rounds of nose ammo (`06000` → `05193`) to do it, while `REMAINING OB` rose
|
||||
from `004` to `011` as fresh waves spawned. So attrition at this rate never
|
||||
finishes the mission, and the ranking of open problems has changed:
|
||||
|
||||
1. **Hit rate.** It opens fire at 2–5 km with a 9° cone and a crude lead
|
||||
(`p + v·d/speed`, no projectile speed). The `Shell` records in
|
||||
[weapon-struct-runtime](structures/weapon-struct-runtime.md) carry the real
|
||||
projectile speed and `MaximumRange` per weapon — the lead and the firing
|
||||
range should come from *those*, not from constants.
|
||||
2. **Which targets count.** `REMAINING OB` is the mission's own objective
|
||||
counter and it is on screen, so it is in RAM; finding it turns "shoot
|
||||
whatever is nearest" into "shoot what closes the mission". Objective-marked
|
||||
entities also draw an `OB` badge in the HUD, so the flag is likely a word in
|
||||
the entity object.
|
||||
3. **Confirming the shield word** — needs a run that actually takes damage; the
|
||||
pilot is now good enough at avoiding that to make it awkward, so drive
|
||||
straight at a turret on purpose with `--dry` steering disabled.
|
||||
4. **Does the ACROPOLIS repair?** RETIRE mode has never triggered (the hull
|
||||
never fell), so the resupply hint is still untested.
|
||||
|
||||
## The next step that unblocks the most (superseded — kept for the reasoning)
|
||||
|
||||
**Update 2026-07-30: this is no longer the blocker.** Entity typing via the
|
||||
definition pointer already solved target selection, so the game's own target
|
||||
pointer is now a convenience rather than a prerequisite. It would still be the
|
||||
cheapest route to problem 2 above (objective targets), because whatever the HUD
|
||||
locks on to is what the game itself considers a target.
|
||||
|
||||
**Find the game's own target pointer instead of typing entities ourselves.**
|
||||
The HUD has a lock-on system (a `TARGET` marker and a target-cycle button), so
|
||||
a global almost certainly holds a pointer to the currently-targeted entity.
|
||||
Reading that gives an enemy's live object address directly — which yields both
|
||||
target selection *and* the entity layout (position offset within it), i.e. it
|
||||
collapses problems 3 and 4 into one. It is also cheap to find: cycle the target
|
||||
with the pad and watch which pointer-shaped global changes in step.
|
||||
|
||||
## Operational notes
|
||||
|
||||
* An unattended craft **dies** — the ship flies straight into a firefight, and
|
||||
two long scans were invalidated by a GAME OVER mid-run. Any scan longer than
|
||||
~30 s needs either a survivable holding pattern or a fresh mission.
|
||||
* `Xvfb` and the emulator die on their own every few minutes here, cleanly
|
||||
(exit 0), cause unidentified. Everything that must not be interrupted is run
|
||||
as **one background task** that starts the display, the emulator, the
|
||||
navigation and the measurement together, so nothing has to survive between
|
||||
tool calls.
|
||||
* `pgrep` cannot be used for liveness in this container: PID 1 is
|
||||
`sleep infinity` and never reaps, so dead processes linger as `<defunct>` and
|
||||
still match by name. Use `ps -o stat=` and skip `Z`, or `xdpyinfo` for X.
|
||||
* numpy is not installed system-wide; `pip install --break-system-packages
|
||||
numpy` puts it in `/sylph-home/.local`, which is only on `sys.path` when
|
||||
`HOME=/sylph-home`. Scripts run with `HOME=/sylph-home/re` need
|
||||
`PYTHONPATH=/sylph-home/.local/lib/python3.12/site-packages`.
|
||||
|
||||
## Files
|
||||
|
||||
`pilot.py` (**the survival loop**) · `ctrl_probe.py` (input → speed calibration,
|
||||
plus a per-tick window of the player object) · `binq.py` (query that capture) ·
|
||||
`own_state.py` (definition-anchored hull/shield lookup) · `fly_session.sh`
|
||||
(boot → mission → bind → fly, one task) · `wait_flight.sh` (wait for the real
|
||||
HUD instead of a fixed sleep) · `navigator.py` (drift-aware steering + CPA
|
||||
avoidance, reused by the pilot) ·
|
||||
`gworld.py` (live reader + entity list) · `flight_probe.py` (scripted inputs +
|
||||
sampling, and the `Pad` FIFO client) · `flight_analyze.py` · `whatchanges.py`
|
||||
(encoding-agnostic "which words are live") · `findplayer.py` · `findself.py` ·
|
||||
`findrot_global.py` · `findspeed.py` · `liveents.py` · `selfstate.py` (the
|
||||
whole chain → JSON) · `autopilot2.py` (PD controller; **untested — it has never
|
||||
had a valid config to run against**) · `launch_mission.sh`.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 590 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 860 KiB |
@@ -1,61 +0,0 @@
|
||||
item,stage_required,points_cost,other_conditions,raw_text
|
||||
Light Machine Gun MG1,1,4000,,Conditions to obtain Light Machine Gun MG1 - Complete Stage 1 - Must spend 4000 points to develop
|
||||
Light Swivel Machine Gun MG2H,,3000,Completed development of the Light Machine Gun MG1,Conditions to obtain Light Swivel Machine Gun MG2H - Completed development of the Light Machine Gun MG1 - Must spend 3000 points to develop
|
||||
Heavy Machine Gun MG3,6,6000,,Conditions to obtain Heavy Machine Gun MG3 - Complete Stage 6 - Must spend 6000 points to develop
|
||||
Heavy Swivel Machine Gun MG5H,,10000,Completed development of the Heavy Machine Gun MG3,Conditions to obtain Heavy Swivel Machine Gun MG5H - Completed development of the Heavy Machine Gun MG3 - Must spend 10000 points to develop
|
||||
Broad Sword SG1,1,5000,,Conditions to obtain Broad Sword SG1 - Complete Stage 1 - Must spend 5000 points to develop
|
||||
Swing Sword SG2H,,10000,Completed development of the Twin Sword SG3II,Conditions to obtain Swing Sword SG2H - Completed development of the Twin Sword SG3II - Must spend 10000 points to develop
|
||||
Twin Sword SG3II,,8000,Completed development of the Broad Sword SG1,Conditions to obtain Twin Sword SG3II - Completed development of the Broad Sword SG1 - Must spend 8000 points to develop
|
||||
Flail GP37,6,,,Conditions to obtain Flail GP37 - Complete Stage 6
|
||||
Stiletto BG1,,,Initially Mounted,Conditions to obtain Stiletto BG1 - Initially Mounted
|
||||
Dagger BG2,,5000,Development Possible,Conditions to obtain Dagger BG2 - Development Possible - Must spend 5000 points to develop
|
||||
Rapier BG4H,,12000,Completed development of the Dagger BG2,Conditions to obtain Rapier BG4H - Completed development of the Dagger BG2 - Must spend 12000 points to develop
|
||||
Pilum BP,,6000,Development Possible,Conditions to obtain Pilum BP - Development Possible - Must spend 6000 points to develop
|
||||
Multi Pike BP,,30000,Completed development of the Pilum BP,Conditions to obtain Multi Pike BP - Completed development of the Pilum BP - Must spend 30000 points to develop
|
||||
Spear HBP,,10000,Completed development of the Multi Pike BP,Conditions to obtain Spear HBP - Completed development of the Multi Pike BP - Must spend 10000 points to develop
|
||||
Long Spear HBP,7,350000,Completed development of the Gray Head T76H,Conditions to obtain Long Spear HBP - Complete Stage 7 - Completed development of the Gray Head T76H - Must spend 350000 points to develop
|
||||
Gray Head T76H,,25000,Completed development of the Spear HBP,Conditions to obtain Gray Head T76H - Completed development of the Spear HBP - Must spend 25000 points to develop
|
||||
Saber LG1,14,,,Conditions to obtain Saber LG1 - Complete Stage 14
|
||||
Twin Saber LG2H,15,,,Conditions to obtain Twin Saber LG2H - Complete Stage 15
|
||||
Needle L1GP,6,10000,,Conditions to obtain Needle L1GP - Complete Stage 6 - Must spend 10000 points to develop
|
||||
Fire Arrow L2GP,,20000,Completed development of the Needle L1GP,Conditions to obtain Fire Arrow L2GP - Completed development of the Needle L1GP - Must spend 20000 points to develop
|
||||
Falcon 9AM,,,Initially Mounted,Conditions to obtain Falcon 9AM - Initially Mounted
|
||||
Buzzard 10AM,1,,,Conditions to obtain Buzzard 10AM - Complete Stage 1
|
||||
Hawk 75AM,6,10000,Possess Buzzard 10AM,Conditions to obtain Hawk 75AM - Complete Stage 6 - Possess Buzzard 10AM - Must spend 10000 points to develop
|
||||
Condor 105AM,6,,,Conditions to obtain Condor 105AM - Complete Stage 6
|
||||
Eagle 120AM,12,15000,Completed development of the Hawk 75AM,Conditions to obtain Eagle 120AM - Complete Stage 12 - Completed development of the Hawk 75AM - Must spend 15000 points to develop
|
||||
Terrier SMH,1,,,Conditions to obtain Terrier SMH - Complete Stage 1
|
||||
Hound SMH,,10000,Development Possible,Conditions to obtain Hound SMH - Development Possible - Must spend 10000 points to develop
|
||||
Pointer SM,,40000,Completed development of Piranha T53,Conditions to obtain Pointer SM - Completed development of Piranha T53 - Must spend 40000 points to develop
|
||||
Piranha T53,,25000,Obtain White Shark T53R,Conditions to obtain Piranha T53 - Obtain White Shark T53R - Must spend 25000 points to develop
|
||||
White Shark T53R,6,,,Conditions to obtain White Shark T53R - Complete Stage 6
|
||||
Dart 23 Rocket,1,3500,,Conditions to obtain Dart 23 Rocket - Complete Stage 1 - Must spend 3500 points to develop
|
||||
Arrow 27 Rocket,2,5000,,Conditions to obtain Arrow 27 Rocket - Complete Stage 2 - Must spend 5000 points to develop
|
||||
Adhesive Mine B2A,3,MISSING,,Conditions to obtain Adhesive Mine B2A - Complete Stage 3 - Must spend points to develop
|
||||
EMP Mine B8E,6,50000,,Conditions to obtain EMP Mine B8E - Complete Stage 6 - Must spend 50000 points to develop
|
||||
Laser Mine B9L,6,15000,,Conditions to obtain Laser Mine B9L - Complete Stage 6 - Must spend 15000 points to develop
|
||||
Cauldron 50 Rocket,14,,,Conditions to obtain Cauldron 50 Rocket - Complete Stage 14
|
||||
Cluster Mine B10,6,5000,,Conditions to obtain Cluster Mine B10 - Complete Stage 6 - Must spend 5000 points to develop
|
||||
Maelstrom Bomb,6,200000,,Conditions to obtain Maelstrom Bomb - Complete Stage 6 - Must spend 200000 points to develop
|
||||
Tomahawk Alpha Rail Gun,1,,,Conditions to obtain Tomahawk Alpha Rail Gun - Complete Stage 1
|
||||
Sling 75KG,2,5000,,Conditions to obtain Sling 75KG - Complete Stage 2 - Must spend 5000 points to develop
|
||||
Glaive 120mm Cannon,6,,,Conditions to obtain Glaive 120mm Cannon - Complete Stage 6
|
||||
Arbalest 155KG,6,25000,,Conditions to obtain Arbalest 155KG - Complete Stage 6 - Must spend 25000 points to develop
|
||||
Monoceros Long Cannon,,,Shoot down the ace pilot in Stage 14,Conditions to obtain Monoceros Long Cannon - Shoot down the ace pilot in Stage 14
|
||||
Grav Cannon XGS,12,60000,,Conditions to obtain Grav Cannon XGS - Complete Stage 12 - Must spend 60000 points to develop
|
||||
Ballista GSH,,,,Conditions to obtain Ballista GSH
|
||||
Designator LH,,,,Conditions to obtain Designator LH
|
||||
Smoke Marker Launcher,,,,Conditions to obtain Smoke Marker Launcher
|
||||
Bumble UV,,,,Conditions to obtain Bumble UV
|
||||
Jamming System,3,15000,,Conditions to obtain Jamming System - Complete Stage 3 - Must spend 15000 points to develop
|
||||
Shield Doubler,12,50000,,Conditions to obtain Shield Doubler - Complete Stage 12 - Must spend 50000 points to develop
|
||||
Booster,,,Shoot down the ace pilot in Stage 11,Conditions to obtain Booster - Shoot down the ace pilot in Stage 11
|
||||
Fire Control System,6,15000,,Conditions to obtain Fire Control System - Complete Stage 6 - Must spend 15000 points to develop
|
||||
Regenerator,12,100000,,Conditions to obtain Regenerator - Complete Stage 12 - Must spend 100000 points to develop
|
||||
Cartridge Holder,,,Shoot down the ace pilot in Stage 13,Conditions to obtain Cartridge Holder - Shoot down the ace pilot in Stage 13
|
||||
Ballista 24 Rocket Launcher,,,,Conditions to obtain Ballista 24 Rocket Launcher
|
||||
Thrush 220AM,,,,Conditions to obtain Thrush 220AM
|
||||
Divider L3GP,,,,Conditions to obtain Divider L3GP
|
||||
Mace GP25H,,,,Conditions to obtain Mace GP25H
|
||||
Thor Gun System,,,,Conditions to obtain Thor Gun System
|
||||
Spitfire BX,,,,Conditions to obtain Spitfire BX
|
||||
|
Binary file not shown.
|
Before Width: | Height: | Size: 158 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 764 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 620 KiB |
@@ -1,50 +0,0 @@
|
||||
=== eng\prmain_scr.prt ===
|
||||
23 elements
|
||||
# element parent kind pivot kf placement
|
||||
0 preff01.t32 - 0x0 (164,156) 5 rest (256,214) t=6..22 [6:256,214 22:256,214 31:256,214 42:256,214 1:256,214]
|
||||
1 preff02.t32 - 0x0 (155,175) 7 rest (156,121) t=8..37 [4:305,240 6:193,150 7:165,128 8:156,121 37:155,120 44:155,120 2:305,240]
|
||||
2 preff03.t32 - 0x0 (155,175) 7 rest (374,269) t=8..37 [4:225,150 6:337,240 7:365,262 8:374,269 37:375,270 44:375,270 3:225,150]
|
||||
3 preff04.t32 - 0x0 (247,237) 6 rest (173,133) t=8..37 [4:173,133 6:173,133 8:173,133 37:173,133 44:173,133 4:173,133]
|
||||
4 prwinbase.t32 - 0x0 (136,130) 5 rest (284,240) t=14..35 [6:284,240 14:284,240 35:284,240 43:284,240 5:284,240]
|
||||
5 prbtn1.rat - 0x3002 (28,14) 5 rest (242,166) t=16..33 [10:242,166 16:242,166 33:242,166 37:242,166 6:242,166]
|
||||
6 prbtn2.rat - 0x3002 (43,14) 5 rest (242,220) t=17..33 [11:242,220 17:242,220 33:242,220 37:242,220 7:242,220]
|
||||
7 prbtn3.rat - 0x3002 (58,14) 5 rest (242,276) t=18..33 [12:242,276 18:242,276 33:242,276 37:242,276 8:242,276]
|
||||
8 prbtn4.rat - 0x3002 (89,14) 5 rest (242,331) t=19..33 [13:242,331 19:242,331 33:242,331 37:242,331 9:242,331]
|
||||
9 prbtn5.rat - 0x3002 (89,14) 5 rest (242,385) t=20..33 [14:242,385 20:242,385 33:242,385 37:242,385 10:242,385]
|
||||
10 prbtn6.rat - 0x3002 (104,14) 5 rest (242,441) t=21..33 [15:242,441 21:242,441 33:242,441 37:242,441 11:242,441]
|
||||
11 prbtn7.rat - 0x3002 (58,14) 5 rest (242,496) t=22..33 [16:242,496 22:242,496 33:242,496 37:242,496 12:242,496]
|
||||
12 prbtn8.rat - 0x3002 (30,14) 5 rest (242,551) t=23..33 [17:242,551 23:242,551 33:242,551 37:242,551 13:242,551]
|
||||
13 prexp1.t32 - 0x0 (277,30) 8 rest (726,143) t=31..37 [21:726,143 25:1286,143 27:866,143 28:756,143 29:731,143 31:726,143 37:726,143 14:1286,143]
|
||||
14 prexp1a.t32 13 0x1 (277,30) 3 rest (1126,143) t=31..37 [31:1126,143 37:1126,143 15:1126,143]
|
||||
15 prexp3.t32 - 0x0 (205,5) 5 rest (726,381) t=10..29 [10:726,381 29:726,381 31:726,381 39:726,381 16:726,381]
|
||||
16 prmsg.t32 - 0x0 (330,19) 5 rest (151,645) t=21..29 [21:151,645 29:151,645 31:151,645 37:151,645 17:151,645]
|
||||
17 prexp3.t32 - 0x4 (205,5) 5 rest (726,415) t=10..29 [10:726,415 29:726,415 31:726,415 39:726,415 18:726,415]
|
||||
18 prexp3.t32 - 0x4 (205,5) 5 rest (726,449) t=10..29 [10:726,449 29:726,449 31:726,449 39:726,449 19:726,449]
|
||||
19 prexp3.t32 - 0x4 (205,5) 5 rest (726,483) t=10..29 [10:726,483 29:726,483 31:726,483 39:726,483 20:726,483]
|
||||
20 prexp3.t32 - 0x4 (205,5) 5 rest (726,517) t=10..29 [10:726,517 29:726,517 31:726,517 39:726,517 21:726,517]
|
||||
21 prexp3.t32 - 0x4 (205,5) 5 rest (726,551) t=10..29 [10:726,551 29:726,551 31:726,551 39:726,551 22:726,551]
|
||||
22 prexp3.t32 - 0x4 (205,5) 5 rest (726,585) t=39..1869640736 [10:726,585 29:726,585 31:726,585 39:726,585 1869640736:726,585]
|
||||
=== eng\prselect_scr.prt ===
|
||||
8 elements
|
||||
# element parent kind pivot kf placement
|
||||
0 prselect_win1.t32 - 0x0 (256,200) 10 rest (127,155) t=8..23 [4:-516,155 6:-71,155 7:81,155 8:127,155 23:134,155 24:134,155 25:127,155 27:81,155 31:-71,155 1:-516,155]
|
||||
1 prselect_win2.t32 0 0x1 (256,200) 1 (135,560)
|
||||
2 prselect_win1eff.t32 0 0x1 (256,200) 5 rest (71,92) t=2..14 [2:71,92 14:71,92 21:71,92 27:71,92 3:71,92]
|
||||
3 prselect_win2eff.t32 0 0x1 (256,200) 5 rest (71,499) t=2..14 [2:71,499 14:71,499 21:71,499 27:71,499 4:71,499]
|
||||
4 prselect_sbar.sbo 0 0x1 (256,200) 1 (614,172)
|
||||
5 prselect_type_line.t32 - 0x0 (260,24) 5 rest (123,142) t=14..21 [8:123,142 14:123,142 21:123,142 25:123,142 6:123,142]
|
||||
6 prselect_msg.t32 - 0x0 (468,19) 5 rest (151,645) t=11..19 [11:151,645 19:151,645 21:151,645 27:151,645 7:151,645]
|
||||
7 prselect_msgbtn1.t32 - 0x2 (128,19) 5 rest (809,645) t=27..1869640736 [11:809,645 19:809,645 21:809,645 27:809,645 1869640736:809,645]
|
||||
=== eng\prselect_win3.prt ===
|
||||
2 elements
|
||||
# element parent kind pivot kf placement
|
||||
0 prselect_win3.t32 - 0x0 (245,300) 4 rest (704,39) t=10..16 [8:704,39 10:704,39 16:704,39 1:704,39]
|
||||
1 prselect_win3eff.t32 - 0x0 (309,352) 4 rest (640,0) t=16..1869640736 [8:640,0 10:640,0 16:640,0 1869640736:640,0]
|
||||
=== eng\prtitle.prt ===
|
||||
5 elements
|
||||
# element parent kind pivot kf placement
|
||||
0 preff11.t32 - 0x0 (221,6) 6 rest (-160,82) t=16..35 [12:-440,82 14:-440,82 16:-160,82 35:0,82 41:0,82 1:-440,82]
|
||||
1 preff12.t32 - 0x0 (75,3) 5 rest (0,72) t=20..34 [14:0,72 20:0,72 34:0,72 38:0,72 2:0,72]
|
||||
2 preff13.t32 - 0x0 (53,3) 5 rest (407,78) t=22..33 [16:407,78 22:407,78 33:407,78 37:407,78 3:407,78]
|
||||
3 preff14.t32 - 0x0 (52,3) 5 rest (427,68) t=24..32 [18:427,68 24:427,68 32:427,68 36:427,68 4:427,68]
|
||||
4 prtitle.t32 - 0x0 (94,35) 7 rest (162,26) t=37..1869640736 [20:142,26 23:142,26 25:157,26 26:161,26 31:162,26 37:162,26 1869640736:142,26]
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 478 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 430 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 148 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 381 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.7 MiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.6 MiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.3 MiB |
File diff suppressed because it is too large
Load Diff
@@ -1,115 +0,0 @@
|
||||
|
||||
|
||||
id hp size_x size_y size_z kind
|
||||
UN_e006_ADAN_Vindicator_MargrasF 6400 12 5 30 unit
|
||||
UN_be005_ADAN_SpaceFortress 10000 2500 3100 2600 unit
|
||||
UN_f001_TCAF_DeltaSaber_T 1000 10 7 29 unit
|
||||
UN_f002_TCAF_DeltaSaber_W 1000 10 7 29 unit
|
||||
UN_e009_ADAN_Phantom 1000 18 16 24 unit
|
||||
UN_e001_ADAN_Elan_EX4 500 25 10 30 unit
|
||||
UN_e011_ADAN_Attacker_B 1500 200 50 100 unit
|
||||
UN_f001_TCAF_DeltaSaber_T_Ttrl 1000 10 7 29 unit
|
||||
UN_f202_TCAF_Cargo 4000 1400 600 2000 unit
|
||||
UN_e007_ADAN_Turret_EX4 100 20 9 22 unit
|
||||
UN_e010_ADAN_Attacker_S 500 100 40 50 unit
|
||||
UN_be001_ADAN_TerrafoamingUnit 10000 2600 2200 — unit
|
||||
UN_e005_ADAN_ElanTypeQ_Margras 3200 24 15 38 unit
|
||||
UN_e001_ADAN_Elan_GR_Violeta 1200 25 10 30 unit
|
||||
UN_e004_ADAN_ElanPlus_N 800 24 10 30 unit
|
||||
UN_e201_ADAN_ISCMissile 3000 300 — 2800 unit
|
||||
UN_f001_TCAF_DeltaSaber_T_Player_Ttrl1 1500 10 7 29 unit
|
||||
UN_f001_TCAF_DeltaSaber_T_Player_Ttrl2 1500 10 7 29 unit
|
||||
UN_f003_TCAF_ArrowHead_EX4 300 10 5 20 unit
|
||||
UN_f003_TCAF_ArrowHead_EX5 300 10 5 20 unit
|
||||
UN_e011_ADAN_Attacker_B_HF 2250 200 50 100 unit
|
||||
UN_e015_ADAN_Puppy — 7 5.5 10 unit
|
||||
Ship_Test 100 20 14 29 unit
|
||||
UN_e010_ADAN_Attacker_S_HF 750 100 40 50 unit
|
||||
Test_ADAN_PrometheusDriver 10000 1 — — unit
|
||||
UN_f001_TCAF_DeltaSaber_T_EX5 1000 10 7 29 unit
|
||||
UN_e002_ADAN_Elan_N 800 20 10 30 unit
|
||||
UN_e008_ADAN_TurretPlus 300 24 9 35 unit
|
||||
UN_mn040_Asteroid_Big 10000 2000 3500 — unit
|
||||
UN_mn500_ADAN_FloatingMine 1000 200 — — unit
|
||||
UN_S04_Asteroid_cmesh_01 10000 46900 55500 13600 unit
|
||||
UN_S05_Asteroid_cmesh_01 10000 10400 13000 34400 unit
|
||||
UN_S04_Asteroid_cmesh_03 10000 42800 37700 47400 unit
|
||||
UN_S04_Asteroid_cmesh_04 10000 59000 56900 21800 unit
|
||||
UN_S05_Asteroid_cmesh_03 10000 8300 13000 19800 unit
|
||||
UN_S04_Asteroid_cmesh_05 — 26000 21800 72400 unit
|
||||
UN_S05_Asteroid_cmesh_04 10000 7400 15800 30100 unit
|
||||
UN_e011_ADAN_Attacker_B_EX4 1500 200 50 100 unit
|
||||
UN_e910_core_ADAN_GeneratorCore 10000 2000 — — unit
|
||||
UN_n001_TTRL_Box 100 0.1 — — unit
|
||||
UN_e006_ADAN_Vindicator_Margras 6400 12 5 30 unit
|
||||
UN_e010_ADAN_Attacker_S_EX4 500 100 40 50 unit
|
||||
UN_bf001_TCAF_SchlosBase 10000 2500 3100 2600 unit
|
||||
UN_f001_TCAF_DeltaSaber_T_EX5_el 1000 10 7 29 unit
|
||||
UN_n001_TTRL_Box_move 100 0.1 — — unit
|
||||
UN_e004_ADAN_ElanPlus_NF 800 24 10 30 unit
|
||||
Test_ADAN_PrometheusDriver_InsideP2_01 10000 1 — — unit
|
||||
UN_e001_ADAN_Elan 500 25 10 30 unit
|
||||
UN_e007_ADAN_Turret 100 20 9 22 unit
|
||||
UN_e003_ADAN_ElanPlus_Margras 1600 24 10 30 unit
|
||||
UN_e901_ADAN_Boss 10000 500 1700 — unit
|
||||
UN_e013_ADAN_ElanPlus_Taskent 1300 24 10 30 unit
|
||||
UN_e011_ADAN_Attacker_B_HF_Wayne 3000 200 50 100 unit
|
||||
UN_f003_TCAF_ArrowHead 300 10 5 20 unit
|
||||
UN_f004_TCAF_DeltaSaber_A_Player 1500 10 7 29 unit
|
||||
UN_e010_ADAN_Attacker_S_HF_Wayne 1000 100 40 50 unit
|
||||
UN_e015_ADAN_Puppy_2 — 7 5.5 10 unit
|
||||
UN_S01_Asteroid_cmesh_01a — 23000 21700 13400 unit
|
||||
UN_S01_Asteroid_cmesh_02a 10000 20900 24000 23800 unit
|
||||
UN_S01_Asteroid_cmesh_01b — 18000 20900 14200 unit
|
||||
UN_S01_Asteroid_cmesh_02b — 20400 21800 26700 unit
|
||||
UN_S01_Asteroid_cmesh_03a 10000 23600 11700 30300 unit
|
||||
UN_bf002_TCAF_TransitPlatform 10000 2500 3100 4600 unit
|
||||
UN_e001_ADAN_Elan_GR 800 25 10 30 unit
|
||||
UN_S13_Asteroid_cmesh_01a 10000 14200 10200 14700 unit
|
||||
UN_S01_Asteroid_cmesh_03b — 21800 18600 37200 unit
|
||||
UN_S01_Asteroid_cmesh_04a — 32800 19900 23300 unit
|
||||
UN_S13_Asteroid_cmesh_01b 10000 8000 5400 16400 unit
|
||||
UN_S13_Asteroid_cmesh_02a 10000 6200 5400 11300 unit
|
||||
UN_S01_Asteroid_cmesh_04b — 26400 23100 19600 unit
|
||||
UN_S04_Asteroid_cmesh_02a — 25100 20800 61400 unit
|
||||
UN_S13_Asteroid_cmesh_02b 10000 5100 6900 10500 unit
|
||||
UN_S05_Asteroid_cmesh_02a 10000 10100 13200 9100 unit
|
||||
UN_S04_Asteroid_cmesh_02b 10000 25200 19700 67000 unit
|
||||
UN_S05_Asteroid_cmesh_02b 10000 8700 14900 12300 unit
|
||||
UN_S08_Asteroid_cmesh_01a 10000 14700 14900 21300 unit
|
||||
UN_S08_Asteroid_cmesh_01b 10000 14900 14600 15800 unit
|
||||
UN_S08_Asteroid_cmesh_02a 10000 17400 13400 15200 unit
|
||||
UN_S04_Asteroid_cmesh_06a — 14400 20800 45900 unit
|
||||
UN_S08_Asteroid_cmesh_02b 10000 16800 10700 14200 unit
|
||||
UN_S08_Asteroid_cmesh_03a — 14000 10000 13700 unit
|
||||
UN_S04_Asteroid_cmesh_06b 10000 14100 16200 21500 unit
|
||||
UN_S04_Asteroid_cmesh_07a — 23200 14000 67100 unit
|
||||
UN_S08_Asteroid_cmesh_03b 10000 13900 15100 15700 unit
|
||||
UN_S04_Asteroid_cmesh_07b 10000 25300 4900 40600 unit
|
||||
UN_e008_ADAN_TurretPlus_EX4 300 24 9 35 unit
|
||||
UN_f001_TCAF_DeltaSaber_T_Player 1500 10 7 29 unit
|
||||
UN_f003_TCAF_ArrowHead_Yoji 400 10 5 20 unit
|
||||
UN_f002_TCAF_DeltaSaber_W_Player 1500 10 7 29 unit
|
||||
UN_e104_ADAN_Carrier 20000 2300 1000 3300 vessel
|
||||
UN_f106_TCAF_Destroyer 10000 200 — 2000 vessel
|
||||
UN_e105_ADAN_Cruiser 30000 600 — 3800 vessel
|
||||
UN_e101_ADAN_SDBattleship 100000 1900 2100 12300 vessel
|
||||
UN_f105_TCAF_Cruiser 30000 700 — 3800 vessel
|
||||
UN_f102_TCAF_LightCarrier 20000 500 — 1600 vessel
|
||||
UN_e102_ADAN_BattleshipEX 50000 1900 2300 6500 vessel
|
||||
UN_e107_ADAN_AAFrigate_EX4 4000 100 200 — vessel
|
||||
UN_e102_ADAN_Battleship 50000 1900 2300 6500 vessel
|
||||
UN_f104_TCAF_Battleship 30000 2000 — 6000 vessel
|
||||
UN_f105_TCAF_Cruiser_EX5 30000 700 — 3800 vessel
|
||||
UN_e108_ADAN_ASFrigateEX 4000 80 — 350 vessel
|
||||
UN_f106_TCAF_Destroyer_Inv 10000 200 — 2000 vessel
|
||||
UN_e107_ADAN_AAFrigate 4000 100 200 — vessel
|
||||
UN_f104_TCAF_Battleship_EX5 30000 2000 — 6000 vessel
|
||||
UN_f105_TCAF_Cruiser_Inv 30000 700 — 3800 vessel
|
||||
UN_f102_TCAF_LightCarrier_Inv 20000 500 — 1600 vessel
|
||||
UN_e108_ADAN_ASFrigate 4000 80 — 350 vessel
|
||||
UN_e106_ADAN_DestroyerEX 10000 300 — 2100 vessel
|
||||
UN_f101_TCAF_Acropolis 25000 400 — 1400 vessel
|
||||
UN_e105_ADAN_CruiserEX 30000 600 — 3800 vessel
|
||||
UN_e101_ADAN_SDBattleshipEX 100000 1900 2100 12300 vessel
|
||||
UN_e106_ADAN_Destroyer 10000 300 — 2100 vessel
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 3.9 MiB |
Binary file not shown.
|
Before Width: | Height: | Size: 43 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB |
@@ -1,161 +0,0 @@
|
||||
run,turret_rule,t_s,acropolis_hull,e007_alive,e007_killed_cum
|
||||
mission01,off,0,25000.0,0,0
|
||||
mission01,off,10,25000.0,5,0
|
||||
mission01,off,20,25000.0,6,0
|
||||
mission01,off,30,25000.0,6,0
|
||||
mission01,off,40,25000.0,6,0
|
||||
mission01,off,50,25000.0,8,0
|
||||
mission01,off,60,25000.0,11,0
|
||||
mission01,off,70,25000.0,11,3
|
||||
mission01,off,80,25000.0,8,3
|
||||
mission01,off,90,25000.0,8,3
|
||||
mission01,off,100,25000.0,10,3
|
||||
mission01,off,110,25000.0,14,3
|
||||
mission01,off,120,25000.0,16,3
|
||||
mission01,off,130,25000.0,17,3
|
||||
mission01,off,140,25000.0,20,3
|
||||
mission01,off,150,25000.0,23,3
|
||||
mission01,off,160,25000.0,26,4
|
||||
mission01,off,170,24509.5,33,4
|
||||
mission01,off,180,24509.5,37,4
|
||||
mission01,off,190,24419.5,38,5
|
||||
mission01,off,200,24212.5,41,5
|
||||
mission01,off,210,23447.5,40,5
|
||||
mission01,off,220,23447.5,40,5
|
||||
mission01,off,220,23447.5,40,5
|
||||
mission01,off,230,23447.5,41,5
|
||||
mission01,off,230,23447.5,41,5
|
||||
mission01,off,240,22912.0,43,5
|
||||
mission01,off,240,22867.0,43,5
|
||||
mission01,off,250,22667.0,42,6
|
||||
mission01,off,250,22647.0,42,6
|
||||
mission01,off,260,22334.5,44,6
|
||||
mission01,off,260,22177.9,44,6
|
||||
mission01,off,270,21101.2,46,6
|
||||
mission01,off,270,21101.2,45,6
|
||||
mission01,off,280,20292.6,46,6
|
||||
mission01,off,280,20279.1,46,6
|
||||
mission01,off,290,19598.5,58,6
|
||||
mission01,off,290,19598.5,58,6
|
||||
mission01,off,300,18725.2,58,6
|
||||
mission01,off,300,18658.5,47,6
|
||||
mission01,off,310,18231.9,47,6
|
||||
mission01,off,310,18231.9,47,6
|
||||
mission01,off,320,17425.2,47,6
|
||||
mission01,off,330,17046.9,49,6
|
||||
mission01,off,340,16044.8,49,7
|
||||
mission01,off,350,15461.5,50,7
|
||||
mission01,off,360,14956.3,51,7
|
||||
mission01,off,370,14425.5,51,8
|
||||
mission01,off,380,13910.5,51,8
|
||||
mission01,off,390,13418.9,49,11
|
||||
mission01,off,400,13218.9,45,12
|
||||
mission01,off,410,12517.9,44,12
|
||||
mission01,off,420,12161.3,44,13
|
||||
mission01,off,430,11601.3,44,13
|
||||
mission02,on,0,25000.0,0,0
|
||||
mission02,on,10,25000.0,5,0
|
||||
mission02,on,20,25000.0,6,0
|
||||
mission02,on,30,25000.0,5,0
|
||||
mission02,on,40,25000.0,5,1
|
||||
mission02,on,50,25000.0,7,1
|
||||
mission02,on,60,25000.0,10,1
|
||||
mission02,on,70,25000.0,7,4
|
||||
mission02,on,80,25000.0,7,4
|
||||
mission02,on,90,25000.0,7,4
|
||||
mission02,on,100,25000.0,7,4
|
||||
mission02,on,110,25000.0,9,4
|
||||
mission02,on,120,25000.0,14,4
|
||||
mission02,on,130,25000.0,16,4
|
||||
mission02,on,140,25000.0,19,4
|
||||
mission02,on,150,25000.0,19,4
|
||||
mission02,on,160,25000.0,23,5
|
||||
mission02,on,170,24730.0,28,5
|
||||
mission02,on,180,24730.0,32,5
|
||||
mission02,on,190,24730.0,36,5
|
||||
mission02,on,200,24640.0,43,6
|
||||
mission02,on,210,24190.0,46,6
|
||||
mission02,on,220,24055.0,47,6
|
||||
mission02,on,220,24055.0,47,6
|
||||
mission02,on,230,24055.0,49,6
|
||||
mission02,on,230,24055.0,49,6
|
||||
mission02,on,240,23474.5,52,6
|
||||
mission02,on,240,23474.5,52,6
|
||||
mission02,on,250,23474.5,53,6
|
||||
mission02,on,250,23474.5,53,6
|
||||
mission02,on,260,23474.5,54,6
|
||||
mission02,on,260,23474.5,54,6
|
||||
mission02,on,270,22697.0,54,6
|
||||
mission02,on,270,22697.0,54,6
|
||||
mission02,on,280,22091.2,56,6
|
||||
mission02,on,280,22091.2,55,7
|
||||
mission02,on,290,21577.9,55,7
|
||||
mission02,on,290,21555.4,55,7
|
||||
mission02,on,300,20799.1,56,7
|
||||
mission02,on,310,19781.1,55,7
|
||||
mission02,on,320,18925.8,56,8
|
||||
mission02,on,330,18592.5,56,8
|
||||
mission02,on,340,17432.5,57,8
|
||||
mission02,on,350,16932.6,59,8
|
||||
mission02,on,360,16171.6,58,9
|
||||
mission02,on,370,15017.6,58,11
|
||||
mission02,on,380,14217.2,59,11
|
||||
mission02,on,390,13322.2,59,12
|
||||
mission02,on,400,12808.9,58,13
|
||||
mission02,on,410,12090.6,61,16
|
||||
mission02,on,420,11440.6,66,19
|
||||
mission02,on,430,11127.3,55,19
|
||||
mission03,on,0,25000.0,0,0
|
||||
mission03,on,10,25000.0,3,0
|
||||
mission03,on,20,25000.0,8,0
|
||||
mission03,on,30,25000.0,5,0
|
||||
mission03,on,40,25000.0,6,0
|
||||
mission03,on,50,25000.0,8,0
|
||||
mission03,on,60,25000.0,9,0
|
||||
mission03,on,70,25000.0,16,0
|
||||
mission03,on,80,25000.0,10,0
|
||||
mission03,on,90,25000.0,11,0
|
||||
mission03,on,100,25000.0,10,2
|
||||
mission03,on,110,25000.0,15,2
|
||||
mission03,on,120,25000.0,12,2
|
||||
mission03,on,130,25000.0,10,4
|
||||
mission03,on,140,25000.0,11,6
|
||||
mission03,on,150,25000.0,14,6
|
||||
mission03,on,160,25000.0,17,7
|
||||
mission03,on,170,24685.0,24,7
|
||||
mission03,on,180,24640.0,23,7
|
||||
mission03,on,190,24640.0,27,7
|
||||
mission03,on,200,24460.0,26,8
|
||||
mission03,on,210,24100.0,28,8
|
||||
mission03,on,220,24100.0,29,9
|
||||
mission03,on,230,24100.0,28,11
|
||||
mission03,on,230,24100.0,28,11
|
||||
mission03,on,240,23810.0,35,11
|
||||
mission03,on,240,23810.0,36,11
|
||||
mission03,on,250,23630.0,36,12
|
||||
mission03,on,250,23630.0,36,12
|
||||
mission03,on,260,23630.0,38,13
|
||||
mission03,on,260,23630.0,38,13
|
||||
mission03,on,270,22998.0,39,13
|
||||
mission03,on,270,22908.0,39,13
|
||||
mission03,on,280,22197.5,40,13
|
||||
mission03,on,280,22188.5,40,13
|
||||
mission03,on,290,21602.4,38,13
|
||||
mission03,on,290,21602.4,38,13
|
||||
mission03,on,300,21042.4,39,13
|
||||
mission03,on,300,20975.8,39,13
|
||||
mission03,on,310,20529.1,41,15
|
||||
mission03,on,310,20529.1,41,15
|
||||
mission03,on,320,19812.5,38,17
|
||||
mission03,on,320,19767.5,38,17
|
||||
mission03,on,330,19434.2,39,18
|
||||
mission03,on,340,18785.9,37,19
|
||||
mission03,on,350,18339.2,37,19
|
||||
mission03,on,360,17528.1,38,19
|
||||
mission03,on,370,16901.5,37,19
|
||||
mission03,on,380,16260.7,35,19
|
||||
mission03,on,390,15708.2,37,19
|
||||
mission03,on,400,15346.2,37,19
|
||||
mission03,on,410,14412.1,36,20
|
||||
mission03,on,420,13951.9,37,22
|
||||
mission03,on,430,13211.9,35,23
|
||||
|
Binary file not shown.
|
Before Width: | Height: | Size: 1.7 MiB |
Binary file not shown.
|
Before Width: | Height: | Size: 3.6 MiB |
Binary file not shown.
|
Before Width: | Height: | Size: 215 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 918 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 195 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 233 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 218 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 185 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 156 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.2 MiB |
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Binary file not shown.
|
Before Width: | Height: | Size: 1.7 MiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.3 MiB |
@@ -1,102 +0,0 @@
|
||||
movie,telop,subtitle,voicetrack
|
||||
logo1.wmv,,,
|
||||
logo2.wmv,,,
|
||||
logo3.wmv,,,
|
||||
logo4.wmv,,,
|
||||
ADV.wmv,,,VOICE_ADV
|
||||
SYLPH_HD720p_8M-CBR_2ch.wmv,pwterop_s01a.prt,SYLPH_HD720p_8M-CBR_2ch.tbl,
|
||||
S00A.wmv,,SUBTITLE_S00A.tbl,VOICE_S00A
|
||||
S01A.wmv,,SUBTITLE_S01A.tbl,VOICE_S01A
|
||||
RT01A.wmv,pwrt01.prt,SUBTITLE_RT01A.tbl,VOICE_RT01A
|
||||
RT01B.wmv,,SUBTITLE_RT01B.tbl,VOICE_RT01B
|
||||
RT01C_1.wmv,,SUBTITLE_RT01C_1.tbl,VOICE_RT01C_1
|
||||
RT01C_2.wmv,,SUBTITLE_RT01C_2.tbl,VOICE_RT01C_2
|
||||
S02A.wmv,pwterop_s02a.prt,SUBTITLE_S02A.tbl,VOICE_S02A
|
||||
S02B.wmv,,SUBTITLE_S02B.tbl,VOICE_S02B
|
||||
S02C.wmv,,SUBTITLE_S02C.tbl,VOICE_S02C
|
||||
RT02A.wmv,pwrt02.prt,SUBTITLE_RT02A.tbl,VOICE_RT02A
|
||||
RT02B.wmv,,SUBTITLE_RT02B.tbl,VOICE_RT02B
|
||||
RT02C.wmv,,SUBTITLE_RT02C.tbl,VOICE_RT02C
|
||||
RT02D_1.wmv,,SUBTITLE_RT02D_1.tbl,VOICE_RT02D_1
|
||||
RT02D_2.wmv,,SUBTITLE_RT02D_2.tbl,VOICE_RT02D_2
|
||||
hokyu_LS_s02A.wmv,,SUBTITLE_hokyu_LS_s02A.tbl,VOICE_D_450
|
||||
hokyu_LS_s02H.wmv,,SUBTITLE_hokyu_LS_s02H.tbl,VOICE_D_453
|
||||
S03A.wmv,,SUBTITLE_S03A.tbl,VOICE_S03A
|
||||
RT03A.wmv,pwrt03.prt,SUBTITLE_RT03A.tbl,VOICE_RT03A
|
||||
RT03B.wmv,,SUBTITLE_RT03B.tbl,VOICE_RT03B
|
||||
RT03C.wmv,,SUBTITLE_RT03C.tbl,VOICE_RT03C
|
||||
RT03D.wmv,,SUBTITLE_RT03D.tbl,VOICE_RT03D
|
||||
hokyu_LS_s03A.wmv,,SUBTITLE_hokyu_LS_s03A.tbl,
|
||||
hokyu_LS_s03H.wmv,,SUBTITLE_hokyu_LS_s03H.tbl,
|
||||
S04A.wmv,,SUBTITLE_S04A.tbl,VOICE_S04A
|
||||
S04B.wmv,,SUBTITLE_S04B.tbl,VOICE_S04B
|
||||
RT04A.wmv,pwrt04.prt,SUBTITLE_RT04A.tbl,VOICE_RT04A
|
||||
RT04B.wmv,,SUBTITLE_RT04B.tbl,VOICE_RT04B
|
||||
hokyu_DS_s02A.wmv,,SUBTITLE_hokyu_DS_s02A.tbl,VOICE_D_452
|
||||
S05A.wmv,,SUBTITLE_S05A.tbl,VOICE_S05A
|
||||
RT05A.wmv,pwrt05.prt,SUBTITLE_RT05A.tbl,VOICE_RT05A
|
||||
RT05B.wmv,,SUBTITLE_RT05B.tbl,VOICE_RT05B
|
||||
RT05C.wmv,,SUBTITLE_RT05C.tbl,VOICE_RT05C
|
||||
S06A.wmv,pwterop_s06a.prt,SUBTITLE_S06A.tbl,VOICE_S06A
|
||||
S06B.wmv,,SUBTITLE_S06B.tbl,VOICE_S06B
|
||||
RT06A.wmv,pwrt06.prt,SUBTITLE_RT06A.tbl,VOICE_RT06A
|
||||
RT06B.wmv,,SUBTITLE_RT06B.tbl,VOICE_RT06B
|
||||
RT06C.wmv,,SUBTITLE_RT06C.tbl,VOICE_RT06C
|
||||
RT06D.wmv,,SUBTITLE_RT06D.tbl,VOICE_RT06D
|
||||
hokyu_LS_s06A.wmv,,SUBTITLE_hokyu_LS_s06A.tbl,
|
||||
hokyu_LS_s06H.wmv,,SUBTITLE_hokyu_LS_s06H.tbl,
|
||||
S07A.wmv,,SUBTITLE_S07A.tbl,VOICE_S07A
|
||||
S07B.wmv,,SUBTITLE_S07B.tbl,VOICE_S07B
|
||||
RT07A.wmv,pwrt07.prt,SUBTITLE_RT07A.tbl,VOICE_RT07A
|
||||
RT07B.wmv,,SUBTITLE_RT07B.tbl,VOICE_RT07B
|
||||
RT07C.wmv,,SUBTITLE_RT07C.tbl,VOICE_RT07C
|
||||
hokyu_DS_s07A.wmv,,SUBTITLE_hokyu_DS_s07A.tbl,
|
||||
hokyu_DS_s07H.wmv,,SUBTITLE_hokyu_DS_s07H.tbl,VOICE_D_454
|
||||
RT08A.wmv,pwrt08.prt,SUBTITLE_RT08A.tbl,VOICE_RT08A
|
||||
RT08B.wmv,,SUBTITLE_RT08B.tbl,VOICE_RT08B
|
||||
RT08C.wmv,,SUBTITLE_RT08C.tbl,VOICE_RT08C
|
||||
hokyu_DS_s08A.wmv,,SUBTITLE_hokyu_DS_s08A.tbl,
|
||||
S09B.wmv,,SUBTITLE_S09B.tbl,VOICE_S09B
|
||||
RT09A.wmv,pwrt09.prt,SUBTITLE_RT09A.tbl,VOICE_RT09A
|
||||
RT09B.wmv,,SUBTITLE_RT09B.tbl,VOICE_RT09B
|
||||
RT09C.wmv,,SUBTITLE_RT09C.tbl,VOICE_RT09C
|
||||
RT09D.wmv,,SUBTITLE_RT09D.tbl,VOICE_RT09D
|
||||
hokyu_LS_s09A.wmv,,SUBTITLE_hokyu_LS_s09A.tbl,VOICE_D_451
|
||||
hokyu_LS_s09H.wmv,,SUBTITLE_hokyu_LS_s09H.tbl,
|
||||
S10B.wmv,,SUBTITLE_S10B.tbl,VOICE_S10B
|
||||
RT10A.wmv,pwrt10.prt,SUBTITLE_RT10A.tbl,VOICE_RT10A
|
||||
RT10B.wmv,,SUBTITLE_RT10B.tbl,VOICE_RT10B
|
||||
S11A.wmv,,SUBTITLE_S11A.tbl,VOICE_S11A
|
||||
S11C.wmv,,SUBTITLE_S11C.tbl,VOICE_S11C
|
||||
RT11A.wmv,pwrt11.prt,SUBTITLE_RT11A.tbl,VOICE_RT11A
|
||||
RT11B.wmv,,SUBTITLE_RT11B.tbl,VOICE_RT11B
|
||||
RT11C.wmv,,SUBTITLE_RT11C.tbl,VOICE_RT11C
|
||||
hokyu_LS_s11A.wmv,,SUBTITLE_hokyu_LS_s11A.tbl,
|
||||
S12A.wmv,,SUBTITLE_S12A.tbl,VOICE_S12A
|
||||
S12B.wmv,,SUBTITLE_S12B.tbl,VOICE_S12B
|
||||
S12C.wmv,,SUBTITLE_S12C.tbl,VOICE_S12C
|
||||
RT12A.wmv,pwrt12.prt,SUBTITLE_RT12A.tbl,VOICE_RT12A
|
||||
RT12B_1.wmv,,SUBTITLE_RT12B_1.tbl,VOICE_RT12B_1
|
||||
RT12B_2.wmv,,SUBTITLE_RT12B_2.tbl,VOICE_RT12B_2
|
||||
S13A.wmv,,SUBTITLE_S13A.tbl,VOICE_S13A
|
||||
S13B.wmv,,SUBTITLE_S13B.tbl,VOICE_S13B
|
||||
RT13A.wmv,pwrt13.prt,SUBTITLE_RT13A.tbl,VOICE_RT13A
|
||||
RT13B_1.wmv,,SUBTITLE_RT13B_1.tbl,VOICE_RT13B_1
|
||||
RT13B_2.wmv,,SUBTITLE_RT13B_2.tbl,VOICE_RT13B_2
|
||||
hokyu_DS_s13A.wmv,,SUBTITLE_hokyu_DS_s13A.tbl,
|
||||
S14A.wmv,,SUBTITLE_S14A.tbl,VOICE_S14A
|
||||
RT14A.wmv,pwrt14.prt,SUBTITLE_RT14A.tbl,VOICE_RT14A
|
||||
RT14B.wmv,,SUBTITLE_RT14B.tbl,VOICE_RT14B
|
||||
RT14C.wmv,,SUBTITLE_RT14C.tbl,VOICE_RT14C
|
||||
hokyu_DS_s14H.wmv,,SUBTITLE_hokyu_DS_s14H.tbl,
|
||||
S15A.wmv,pwterop_s15a.prt,SUBTITLE_S15A.tbl,VOICE_S15A
|
||||
S15B.wmv,,SUBTITLE_S15B.tbl,VOICE_S15B
|
||||
S15C.wmv,,SUBTITLE_S15C.tbl,VOICE_S15C
|
||||
RT15A.wmv,pwrt15.prt,SUBTITLE_RT15A.tbl,VOICE_RT15A
|
||||
RT15B.wmv,,SUBTITLE_RT15B.tbl,VOICE_RT15B
|
||||
RT15C.wmv,,SUBTITLE_RT15C.tbl,VOICE_RT15C
|
||||
hokyu_LS_s15A.wmv,,SUBTITLE_hokyu_LS_s15A.tbl,
|
||||
S16A.wmv,pwterop_s16a.prt,SUBTITLE_S16A.tbl,VOICE_S16A
|
||||
RT16C.wmv,pwrt16.prt,SUBTITLE_RT16C.tbl,VOICE_RT16C
|
||||
hokyu_LS_s24A.wmv,,,
|
||||
hokyu_LS_s27A.wmv,,,
|
||||
|
Binary file not shown.
|
Before Width: | Height: | Size: 881 KiB |
@@ -1,13 +0,0 @@
|
||||
11 elements
|
||||
# element parent kind pivot kf placement
|
||||
0 pgp_ttrl_eff11.t32 - 0x0 (34,33) 7 rest (470,121) t=9..25 [3:603,121 6:603,121 8:503,121 9:470,121 25:463,121 30:463,121 1:493,121]
|
||||
1 pgp_ttrl_eff12.t32 - 0x0 (34,33) 7 rest (742,121) t=9..25 [3:609,121 6:609,121 8:709,121 9:742,121 25:749,121 30:749,121 2:719,121]
|
||||
2 pgp_ttrl_eff10.t32 - 0x0 (204,60) 5 rest (436,94) t=14..23 [8:436,94 14:436,94 23:436,94 30:436,94 3:436,94]
|
||||
3 pgp_ttrl_eff22.t32 - 0x0 (133,130) 5 rest (480,225) t=11..25 [5:480,225 11:480,225 25:460,225 30:460,225 4:490,225]
|
||||
4 pgp_ttrl_eff23.t32 - 0x0 (138,130) 5 rest (524,271) t=11..25 [5:524,271 11:524,271 25:544,271 30:544,271 5:514,271]
|
||||
5 pgp_ttrl_eff21.t32 - 0x0 (214,180) 5 rest (426,198) t=9..21 [9:426,198 21:426,198 23:426,198 30:426,198 6:426,198]
|
||||
6 pgp_ttrl_title.rat - 0x0 (101,36) 6 rest (540,119) t=13..23 [5:540,119 13:540,119 23:540,119 28:540,119 30:540,119 7:540,119]
|
||||
7 pgp_ttrl_btn10.rat - 0x3002 (43,21) 5 rest (546,288) t=15..23 [9:546,288 15:546,288 23:546,288 26:546,288 8:546,288]
|
||||
8 pgp_ttrl_btn11.rat - 0x3002 (86,22) 5 rest (546,358) t=11..17 [11:546,358 17:546,358 23:546,358 26:546,358 9:546,358]
|
||||
9 pgp_ttrl_btn12.rat - 0x3002 (110,21) 5 rest (546,428) t=13..19 [13:546,428 19:546,428 23:546,428 26:546,428 10:546,428]
|
||||
10 pgp_ttrl_msg.t32 - 0x0 (190,19) 5 rest (451,545) t=28..1869640736 [16:451,545 21:451,545 23:451,545 28:451,545 1869640736:451,545]
|
||||
Binary file not shown.
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user