Compare commits
3 Commits
feature/ip
...
archive/lo
| Author | SHA1 | Date | |
|---|---|---|---|
|
8ed8c85f18 | ||
|
|
3e1040b472 | ||
|
|
390c67cb61 |
40
Cargo.lock
generated
40
Cargo.lock
generated
@@ -1892,25 +1892,6 @@ dependencies = [
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-deque"
|
||||
version = "0.8.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
|
||||
dependencies = [
|
||||
"crossbeam-epoch",
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-epoch"
|
||||
version = "0.9.20"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
|
||||
dependencies = [
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-utils"
|
||||
version = "0.8.21"
|
||||
@@ -4126,26 +4107,6 @@ version = "0.6.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
|
||||
|
||||
[[package]]
|
||||
name = "rayon"
|
||||
version = "1.12.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
|
||||
dependencies = [
|
||||
"either",
|
||||
"rayon-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rayon-core"
|
||||
version = "1.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
|
||||
dependencies = [
|
||||
"crossbeam-deque",
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "redox_syscall"
|
||||
version = "0.4.1"
|
||||
@@ -4626,7 +4587,6 @@ dependencies = [
|
||||
"binrw",
|
||||
"flate2",
|
||||
"futures",
|
||||
"rayon",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.18",
|
||||
|
||||
@@ -103,6 +103,21 @@ enum Commands {
|
||||
#[command(subcommand)]
|
||||
cmd: MeshCommands,
|
||||
},
|
||||
|
||||
/// Audio tools (identify WAV/XMA/XMA2 + metadata)
|
||||
Audio {
|
||||
#[command(subcommand)]
|
||||
cmd: AudioCommands,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
enum AudioCommands {
|
||||
/// Identify an audio file/stream and print its metadata
|
||||
Info {
|
||||
/// Path to a WAV / XMA / raw audio stream
|
||||
file: PathBuf,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
@@ -122,17 +137,6 @@ enum PakCommands {
|
||||
/// Entry name-hash, e.g. `0x7c96296c`
|
||||
hash: String,
|
||||
},
|
||||
/// Decode every T8aD texture in the pak (direct, RATC-nested, and LSTA
|
||||
/// frames) to PNG — our decoder's output, for A/B against the running game.
|
||||
Textures {
|
||||
/// Path to the `.pak` index
|
||||
pak: PathBuf,
|
||||
/// Output directory for the PNGs (created if missing)
|
||||
output: PathBuf,
|
||||
/// Print per-texture dimensions + tile count.
|
||||
#[arg(long)]
|
||||
verbose: bool,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Subcommand)]
|
||||
@@ -157,9 +161,6 @@ enum MeshCommands {
|
||||
/// Camera pitch in degrees
|
||||
#[arg(long, default_value_t = 22.0)]
|
||||
pitch: f32,
|
||||
/// Camera distance multiplier (1.0 = framed; <1 zooms in, >1 out)
|
||||
#[arg(long, default_value_t = 1.0)]
|
||||
dist: f32,
|
||||
/// Force the stage grid layout even for single models
|
||||
#[arg(long)]
|
||||
row: bool,
|
||||
@@ -208,20 +209,49 @@ async fn main() -> Result<()> {
|
||||
},
|
||||
Commands::Mesh { cmd } => match cmd {
|
||||
MeshCommands::Info { file } => cmd_mesh_info(&file),
|
||||
MeshCommands::Render { file, output, size, yaw, pitch, dist, row, only } => {
|
||||
cmd_mesh_render(&file, &output, size, yaw, pitch, dist, row, only)
|
||||
MeshCommands::Render { file, output, size, yaw, pitch, row, only } => {
|
||||
cmd_mesh_render(&file, &output, size, yaw, pitch, row, only)
|
||||
}
|
||||
},
|
||||
Commands::Pak { cmd } => match cmd {
|
||||
PakCommands::List { pak, idxd_only } => cmd_pak_list(&pak, idxd_only),
|
||||
PakCommands::Dump { pak, hash } => cmd_pak_dump(&pak, &hash),
|
||||
PakCommands::Textures { pak, output, verbose } => {
|
||||
cmd_pak_textures(&pak, &output, verbose)
|
||||
}
|
||||
PakCommands::List { pak, idxd_only } => cmd_pak_list(&pak, idxd_only),
|
||||
PakCommands::Dump { pak, hash } => cmd_pak_dump(&pak, &hash),
|
||||
},
|
||||
Commands::Audio { cmd } => match cmd {
|
||||
AudioCommands::Info { file } => cmd_audio_info(&file),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// ── audio info ───────────────────────────────────────────────────────────────
|
||||
|
||||
fn cmd_audio_info(file: &Path) -> Result<()> {
|
||||
use sylpheed_formats::AudioInfo;
|
||||
let bytes = std::fs::read(file).with_context(|| format!("Cannot read {}", file.display()))?;
|
||||
let info = AudioInfo::probe(&bytes);
|
||||
|
||||
println!("{} {}", "Audio:".green().bold(), file.display());
|
||||
println!(" Codec : {}", info.codec.label().yellow());
|
||||
let opt = |v: Option<String>| v.unwrap_or_else(|| "—".dimmed().to_string());
|
||||
println!(" Channels : {}", opt(info.channels.map(|c| c.to_string())));
|
||||
println!(" Sample rate: {}", opt(info.sample_rate.map(|r| format!("{r} Hz"))));
|
||||
println!(" Bit depth : {}", opt(info.bits_per_sample.map(|b| format!("{b}-bit"))));
|
||||
if let Some(d) = info.duration_secs {
|
||||
println!(" Duration : {d:.2} s");
|
||||
}
|
||||
if let Some(p) = info.xma_packets {
|
||||
println!(" XMA packets: {} (2048 B each)", p.to_string().yellow());
|
||||
}
|
||||
println!(" Size : {} bytes", info.size_bytes.to_string().yellow());
|
||||
if info.codec.needs_decoder() {
|
||||
println!(
|
||||
" {} decode not supported (needs an XMA2 decoder + the sound-bank descriptor)",
|
||||
"note:".dimmed()
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ── extract ────────────────────────────────────────────────────────────────
|
||||
|
||||
async fn cmd_extract(iso_path: &Path, output_dir: &Path) -> Result<()> {
|
||||
@@ -376,9 +406,16 @@ fn cmd_texture_info(file: &Path) -> Result<()> {
|
||||
let tex = X360Texture::from_xpr2(&bytes)
|
||||
.with_context(|| format!("Failed to parse texture: {}", file.display()))?;
|
||||
|
||||
let d = tex.format.desc();
|
||||
println!("{} {}", "Texture:".green().bold(), file.display());
|
||||
println!(" Resolution : {}×{}", tex.width.to_string().yellow(), tex.height.to_string().yellow());
|
||||
println!(" Format : {:?}", tex.format);
|
||||
println!(
|
||||
" Format : {} ({:?}) · {} bpp, {}",
|
||||
tex.format.gpu_name().yellow(),
|
||||
tex.format,
|
||||
d.bpp,
|
||||
if d.compressed { "compressed" } else { "uncompressed" },
|
||||
);
|
||||
println!(" Mip levels : {}", tex.mip_levels);
|
||||
println!(" Data size : {} bytes", tex.data.len().to_string().yellow());
|
||||
|
||||
@@ -423,30 +460,17 @@ fn cmd_texture_export(file: &Path, output: &Path) -> Result<()> {
|
||||
/// a single model (weapon / prop) OR a stage's many sub-models — whichever
|
||||
/// yields more geometry.
|
||||
fn decode_models(bytes: &[u8]) -> Vec<sylpheed_formats::mesh::Xbg7Model> {
|
||||
use sylpheed_formats::mesh::{count_xbg7, Xbg7Model};
|
||||
// Route by container kind, NOT by whichever decoder yields more verts (that
|
||||
// old heuristic let `stage_models`' content-anchoring win on single-model
|
||||
// files, fabricating phantom / duplicate / mis-anchored blocks). A file with
|
||||
// one XBG7 resource is a single model (weapon / prop) → use only the
|
||||
// validated records-based list decode; content-anchoring a single-model file
|
||||
// invents geometry. Many XBG7 resources → a Stage_* collection → anchor them.
|
||||
if count_xbg7(bytes) > 1 {
|
||||
// Multi-resource Stage_* collection → content-anchor every resource
|
||||
// (each anchor now gated by stored-normal agreement).
|
||||
Xbg7Model::stage_models(bytes)
|
||||
} else if let Some(m) = Xbg7Model::from_xpr2(bytes)
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
let single = Xbg7Model::from_xpr2(bytes)
|
||||
.ok()
|
||||
.filter(|m| !m.meshes.is_empty())
|
||||
{
|
||||
// Single model the records-based list decode carved (authoritative).
|
||||
vec![m]
|
||||
.filter(|m| !m.meshes.is_empty());
|
||||
let single_verts = single.as_ref().map(|m| m.totals().0).unwrap_or(0);
|
||||
let stage = Xbg7Model::stage_models(bytes);
|
||||
let stage_verts: usize = stage.iter().map(|m| m.totals().0).sum();
|
||||
if !stage.is_empty() && stage_verts > single_verts {
|
||||
stage
|
||||
} else {
|
||||
// Single model from_xpr2 couldn't locate (its sequential carve missed
|
||||
// the block) — fall back to content-anchoring, which finds it by shape.
|
||||
// Use a STRICT winding-consistency gate (0.85): on a single-model file a
|
||||
// mis-anchor is an obvious phantom / spike-mess and must be declined,
|
||||
// unlike the large stage corpus which keeps the ungated path.
|
||||
Xbg7Model::anchor_models(bytes, 0.85)
|
||||
single.into_iter().collect()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -482,65 +506,6 @@ fn cmd_mesh_info(file: &Path) -> Result<()> {
|
||||
hi[1] - lo[1],
|
||||
hi[2] - lo[2]
|
||||
);
|
||||
// Per-sub-mesh integrity diagnostics: degenerate triangles (a zero-area
|
||||
// "hole"), vertices referenced by no triangle (dropped geometry), and the
|
||||
// referenced index range vs the vertex count (short/over reads).
|
||||
for (si, sub) in m.meshes.iter().enumerate() {
|
||||
let nv = sub.positions.len();
|
||||
let mut referenced = vec![false; nv];
|
||||
let (mut degen, mut oob, mut imax) = (0usize, 0usize, 0u32);
|
||||
for tri in sub.indices.chunks_exact(3) {
|
||||
let (a, b, c) = (tri[0], tri[1], tri[2]);
|
||||
imax = imax.max(a).max(b).max(c);
|
||||
if a == b || b == c || a == c {
|
||||
degen += 1;
|
||||
}
|
||||
for &i in tri {
|
||||
if (i as usize) < nv {
|
||||
referenced[i as usize] = true;
|
||||
} else {
|
||||
oob += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
let unref = referenced.iter().filter(|&&r| !r).count();
|
||||
// Spanning triangles: longest edge ≫ the median (strip-junction spikes).
|
||||
let edge = |a: u32, b: u32| {
|
||||
let (p, q) = (sub.positions[a as usize], sub.positions[b as usize]);
|
||||
((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2) + (p[2] - q[2]).powi(2)).sqrt()
|
||||
};
|
||||
let mut maxedges: Vec<f32> = sub
|
||||
.indices
|
||||
.chunks_exact(3)
|
||||
.map(|t| edge(t[0], t[1]).max(edge(t[1], t[2])).max(edge(t[0], t[2])))
|
||||
.collect();
|
||||
maxedges.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
let median = maxedges.get(maxedges.len() / 2).copied().unwrap_or(1.0).max(1e-6);
|
||||
let spanning = maxedges.iter().filter(|&&e| e > 6.0 * median).count();
|
||||
println!(
|
||||
" sub{si}: {nv} v, {} tris | degenerate {degen}, unref-verts {unref}, spanning>6×med {spanning}, idx_max {imax}/{}{}",
|
||||
sub.indices.len() / 3,
|
||||
nv.saturating_sub(1),
|
||||
if oob > 0 { format!(", OOB {oob}") } else { String::new() },
|
||||
);
|
||||
// XDUMPVERT=1 → print the first few vertex positions per sub-mesh, for
|
||||
// content-matching a decoded sub-mesh against the GPU draw log.
|
||||
if std::env::var("XDUMPVERT").is_ok() {
|
||||
let mut lo = [f32::MAX; 3];
|
||||
let mut hi = [f32::MIN; 3];
|
||||
for p in &sub.positions {
|
||||
for a in 0..3 {
|
||||
lo[a] = lo[a].min(p[a]);
|
||||
hi[a] = hi[a].max(p[a]);
|
||||
}
|
||||
}
|
||||
println!(
|
||||
" bbox X[{:.2}..{:.2}] Y[{:.2}..{:.2}] Z[{:.2}..{:.2}] ctr({:.2},{:.2},{:.2})",
|
||||
lo[0], hi[0], lo[1], hi[1], lo[2], hi[2],
|
||||
(lo[0]+hi[0])/2.0, (lo[1]+hi[1])/2.0, (lo[2]+hi[2])/2.0
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
println!(
|
||||
" {} {} sub-models · {} verts · {} tris",
|
||||
@@ -559,21 +524,13 @@ fn cmd_mesh_render(
|
||||
size: u32,
|
||||
yaw: f32,
|
||||
pitch: f32,
|
||||
dist: f32,
|
||||
force_row: bool,
|
||||
only: Option<String>,
|
||||
) -> Result<()> {
|
||||
let bytes = std::fs::read(file).with_context(|| format!("Cannot read {}", file.display()))?;
|
||||
let mut models = decode_models(&bytes);
|
||||
if let Some(sub) = &only {
|
||||
// Prefer an exact name match (e.g. `f001` for the neutral ship pose,
|
||||
// excluding the `_rou_f001_mnv*` animation poses that also *contain*
|
||||
// "f001"); fall back to substring when nothing matches exactly.
|
||||
if models.iter().any(|m| m.name == *sub) {
|
||||
models.retain(|m| m.name == *sub);
|
||||
} else {
|
||||
models.retain(|m| m.name.contains(sub.as_str()));
|
||||
}
|
||||
models.retain(|m| m.name.contains(sub.as_str()));
|
||||
}
|
||||
if models.is_empty() {
|
||||
anyhow::bail!("no decodable XBG7 geometry in {}", file.display());
|
||||
@@ -585,32 +542,7 @@ fn cmd_mesh_render(
|
||||
// uniformly scaled to a fixed cell, so all are equally visible regardless of
|
||||
// native scale (mirrors `spawn_stage_models`).
|
||||
let multi = models.len() > 1 || force_row;
|
||||
// XMIRROR=x|y|z → negate that axis, to test an Xbox(LH)→Bevy(RH) handedness
|
||||
// flip against reference screenshots.
|
||||
let mirror: [f32; 3] = match std::env::var("XMIRROR").ok().as_deref() {
|
||||
Some("x") => [-1.0, 1.0, 1.0],
|
||||
Some("y") => [1.0, -1.0, 1.0],
|
||||
Some("z") => [1.0, 1.0, -1.0],
|
||||
_ => [1.0, 1.0, 1.0],
|
||||
};
|
||||
let mut tris: Vec<[[f32; 3]; 3]> = Vec::new();
|
||||
// XCOLORSUB=1 tints each sub-mesh a distinct colour (to see which sub is
|
||||
// which part / where the "extra fin" comes from). Parallel to `tris`.
|
||||
let color_sub = std::env::var("XCOLORSUB").is_ok();
|
||||
// XONLYSUB=N renders only the N-th global sub-mesh (to isolate one part).
|
||||
let only_sub: Option<usize> = std::env::var("XONLYSUB").ok().and_then(|s| s.parse().ok());
|
||||
let mut tints: Vec<[f32; 3]> = Vec::new();
|
||||
const PALETTE: [[f32; 3]; 8] = [
|
||||
[1.0, 1.0, 1.0], // sub0 body = white
|
||||
[1.0, 0.35, 0.35], // sub1 red
|
||||
[0.35, 1.0, 0.35], // sub2 green
|
||||
[0.4, 0.55, 1.0], // sub3 blue
|
||||
[1.0, 0.9, 0.3], // sub4 yellow
|
||||
[1.0, 0.5, 1.0], // sub5 magenta
|
||||
[0.3, 1.0, 1.0], // sub6 cyan
|
||||
[1.0, 0.6, 0.2], // sub7 orange
|
||||
];
|
||||
let mut sub_gi = 0usize;
|
||||
const CELL: f32 = 10.0;
|
||||
const GAP: f32 = 4.0;
|
||||
let grid_pitch = CELL + GAP;
|
||||
@@ -642,105 +574,29 @@ fn cmd_mesh_render(
|
||||
} else {
|
||||
(1.0, [0.0, 0.0, 0.0])
|
||||
};
|
||||
// XNODEXFORM=1 applies the XBG7 scene-graph node placement (fins move to
|
||||
// the tail) — to verify the transforms recovered from the graph.
|
||||
let placements = if std::env::var("XNODEXFORM").is_ok() {
|
||||
sylpheed_formats::mesh::node_transforms(&bytes, &m.name)
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
for (sub_local, sub) in m.meshes.iter().enumerate() {
|
||||
// Every scene-graph instance that draws this sub-mesh (mirrored fin
|
||||
// pair, L/R winglets…); `None` = no graph placement → identity.
|
||||
let mine: Vec<Option<&sylpheed_formats::mesh::NodePlacement>> = {
|
||||
let v: Vec<_> = placements
|
||||
.iter()
|
||||
.filter(|p| p.sub_index == sub_local)
|
||||
.map(Some)
|
||||
.collect();
|
||||
if v.is_empty() {
|
||||
vec![None]
|
||||
} else {
|
||||
v
|
||||
}
|
||||
};
|
||||
// Sub-mesh indices are a triangle list (the decoder has already
|
||||
// expanded the file's triangle strips).
|
||||
let n = sub.positions.len();
|
||||
// XSPANONLY=1 renders ONLY long-edge ("spanning") triangles; XSPANHIDE=1
|
||||
// renders everything EXCEPT them — to see whether the flagged spanning
|
||||
// triangles are real geometry or decode artifacts (phantom sheets).
|
||||
let span_only = std::env::var("XSPANONLY").is_ok();
|
||||
let span_hide = std::env::var("XSPANHIDE").is_ok();
|
||||
let med = {
|
||||
let mut e: Vec<f32> = sub
|
||||
.indices
|
||||
.chunks_exact(3)
|
||||
.filter(|t| (t[0] as usize) < n && (t[1] as usize) < n && (t[2] as usize) < n)
|
||||
.map(|t| {
|
||||
let d = |a: u32, b: u32| {
|
||||
let (p, q) = (sub.positions[a as usize], sub.positions[b as usize]);
|
||||
((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2) + (p[2] - q[2]).powi(2))
|
||||
.sqrt()
|
||||
};
|
||||
d(t[0], t[1]).max(d(t[1], t[2])).max(d(t[0], t[2]))
|
||||
})
|
||||
.collect();
|
||||
e.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
e.get(e.len() / 2).copied().unwrap_or(1.0).max(1e-6)
|
||||
};
|
||||
if let Some(want) = only_sub {
|
||||
if sub_gi != want {
|
||||
sub_gi += 1;
|
||||
for sub in &m.meshes {
|
||||
for tri in sub.indices.chunks_exact(3) {
|
||||
let (a, b, c) = (tri[0] as usize, tri[1] as usize, tri[2] as usize);
|
||||
if a >= sub.positions.len() || b >= sub.positions.len() || c >= sub.positions.len() {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let tint = if color_sub {
|
||||
PALETTE[sub_gi % PALETTE.len()]
|
||||
} else {
|
||||
[1.0, 1.0, 1.0]
|
||||
};
|
||||
for place in &mine {
|
||||
let f = |i: usize| {
|
||||
let p = place.map(|pl| pl.apply(sub.positions[i])).unwrap_or(sub.positions[i]);
|
||||
let p = sub.positions[i];
|
||||
[
|
||||
(p[0] - center[0]) * scale * mirror[0] + cell[0],
|
||||
(p[1] - center[1]) * scale * mirror[1] + cell[1],
|
||||
(p[2] - center[2]) * scale * mirror[2] + cell[2],
|
||||
(p[0] - center[0]) * scale + cell[0],
|
||||
(p[1] - center[1]) * scale + cell[1],
|
||||
(p[2] - center[2]) * scale + cell[2],
|
||||
]
|
||||
};
|
||||
for tri in sub.indices.chunks_exact(3) {
|
||||
let (a, b, c) = (tri[0] as usize, tri[1] as usize, tri[2] as usize);
|
||||
if a < n && b < n && c < n {
|
||||
if span_only || span_hide {
|
||||
let d = |i: usize, j: usize| {
|
||||
let (p, q) = (sub.positions[i], sub.positions[j]);
|
||||
((p[0] - q[0]).powi(2)
|
||||
+ (p[1] - q[1]).powi(2)
|
||||
+ (p[2] - q[2]).powi(2))
|
||||
.sqrt()
|
||||
};
|
||||
let spanning = d(a, b).max(d(b, c)).max(d(a, c)) > 6.0 * med;
|
||||
if span_only && !spanning {
|
||||
continue;
|
||||
}
|
||||
if span_hide && spanning {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
tris.push([f(a), f(b), f(c)]);
|
||||
tints.push(tint);
|
||||
}
|
||||
}
|
||||
tris.push([f(a), f(b), f(c)]);
|
||||
}
|
||||
sub_gi += 1;
|
||||
}
|
||||
}
|
||||
if tris.is_empty() {
|
||||
anyhow::bail!("no triangles to render");
|
||||
}
|
||||
|
||||
let rgba = rasterize(&tris, &tints, size, yaw, pitch, dist);
|
||||
let rgba = rasterize(&tris, size, yaw, pitch);
|
||||
image::save_buffer(output, &rgba, size, size, image::ExtendedColorType::Rgba8)
|
||||
.with_context(|| format!("writing PNG {}", output.display()))?;
|
||||
println!(
|
||||
@@ -759,14 +615,7 @@ fn cmd_mesh_render(
|
||||
/// Minimal software rasterizer: orthographic, z-buffered, two-sided Lambert +
|
||||
/// headlight shading over a flat grey material on a dark background. Enough to
|
||||
/// judge whether recovered geometry is coherent.
|
||||
fn rasterize(
|
||||
tris: &[[[f32; 3]; 3]],
|
||||
tints: &[[f32; 3]],
|
||||
size: u32,
|
||||
yaw_deg: f32,
|
||||
pitch_deg: f32,
|
||||
dist: f32,
|
||||
) -> Vec<u8> {
|
||||
fn rasterize(tris: &[[[f32; 3]; 3]], size: u32, yaw_deg: f32, pitch_deg: f32) -> Vec<u8> {
|
||||
let n = size as usize;
|
||||
let (yaw, pitch) = (yaw_deg.to_radians(), pitch_deg.to_radians());
|
||||
let (cy, sy) = (yaw.cos(), yaw.sin());
|
||||
@@ -793,7 +642,7 @@ fn rasterize(
|
||||
}
|
||||
}
|
||||
let span = (hi[0] - lo[0]).max(hi[1] - lo[1]).max(1e-3);
|
||||
let scale = (n as f32) * 0.9 / (span * dist.max(1e-3));
|
||||
let scale = (n as f32) * 0.9 / span;
|
||||
let cx = (lo[0] + hi[0]) * 0.5;
|
||||
let cyv = (lo[1] + hi[1]) * 0.5;
|
||||
let to_screen = |q: [f32; 3]| -> (f32, f32, f32) {
|
||||
@@ -814,8 +663,7 @@ fn rasterize(
|
||||
[l[0] / m, l[1] / m, l[2] / m]
|
||||
};
|
||||
|
||||
for (ti, t) in tris.iter().enumerate() {
|
||||
let tint = tints.get(ti).copied().unwrap_or([1.0, 1.0, 1.0]);
|
||||
for t in tris {
|
||||
let v0 = view(t[0]);
|
||||
let v1 = view(t[1]);
|
||||
let v2 = view(t[2]);
|
||||
@@ -863,9 +711,9 @@ fn rasterize(
|
||||
let idx = py * n + px;
|
||||
if z < depth[idx] {
|
||||
depth[idx] = z;
|
||||
color[idx * 4] = (shade as f32 * tint[0]).min(255.0) as u8;
|
||||
color[idx * 4 + 1] = (shade as f32 * tint[1]).min(255.0) as u8;
|
||||
color[idx * 4 + 2] = (shade as f32 * tint[2] * 1.02).min(255.0) as u8;
|
||||
color[idx * 4] = shade;
|
||||
color[idx * 4 + 1] = shade;
|
||||
color[idx * 4 + 2] = (shade as f32 * 1.02).min(255.0) as u8;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -913,24 +761,6 @@ fn decode_to_rgba8(tex: &sylpheed_formats::texture::X360Texture) -> Result<Vec<u
|
||||
|
||||
use sylpheed_formats::pak::inner_format_label as inner_label;
|
||||
|
||||
/// Try to recover an IDXD entry's original TOC path from its identity tokens.
|
||||
/// Uses the entry's ID/Name/Model fields plus identifier-like pool tokens as
|
||||
/// candidates for [`sylpheed_formats::hash::recover_toc_name`].
|
||||
fn idxd_toc_name(obj: &IdxdObject, name_hash: u32) -> Option<String> {
|
||||
let mut cands: Vec<&str> = Vec::new();
|
||||
for key in ["ID", "Name", "Model"] {
|
||||
if let Some(v) = obj.get_raw(key) {
|
||||
cands.push(v);
|
||||
}
|
||||
}
|
||||
for t in obj.tokens() {
|
||||
if t.contains('_') || t.len() >= 5 {
|
||||
cands.push(t.as_str());
|
||||
}
|
||||
}
|
||||
sylpheed_formats::hash::recover_toc_name(name_hash, &cands)
|
||||
}
|
||||
|
||||
fn cmd_pak_list(pak: &Path, idxd_only: bool) -> Result<()> {
|
||||
let arc = PakArchive::open(pak).with_context(|| format!("opening {}", pak.display()))?;
|
||||
println!(
|
||||
@@ -958,7 +788,7 @@ fn cmd_pak_list(pak: &Path, idxd_only: bool) -> Result<()> {
|
||||
}
|
||||
let (detail, name) = if is_idxd {
|
||||
match IdxdObject::parse(&payload) {
|
||||
Ok(o) => (o.identity(), idxd_toc_name(&o, e.name_hash)),
|
||||
Ok(o) => (o.identity(), o.recover_toc_path(e.name_hash)),
|
||||
Err(_) => (String::new(), None),
|
||||
}
|
||||
} else {
|
||||
@@ -1039,179 +869,3 @@ fn cmd_pak_dump(pak: &Path, hash_str: &str) -> Result<()> {
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ── pak textures ─────────────────────────────────────────────────────────────
|
||||
|
||||
/// Turn a child name into a filesystem-safe fragment.
|
||||
fn safe_name(s: &str) -> String {
|
||||
s.chars()
|
||||
.map(|c| {
|
||||
if c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-') {
|
||||
c
|
||||
} else {
|
||||
'_'
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct TexStats {
|
||||
written: usize,
|
||||
skipped: usize,
|
||||
}
|
||||
|
||||
fn be32_at(b: &[u8], off: usize) -> u32 {
|
||||
u32::from_be_bytes([b[off], b[off + 1], b[off + 2], b[off + 3]])
|
||||
}
|
||||
|
||||
/// Decode one T8aD slice (whose first bytes are the magic) to PNG. With
|
||||
/// `verbose`, prints its dimensions + tile count; the `XDUMPHDR` env var dumps
|
||||
/// the raw header (base + offset table) for format RE.
|
||||
fn emit_t8ad(
|
||||
slice: &[u8],
|
||||
hash: u32,
|
||||
stem: &str,
|
||||
output: &Path,
|
||||
verbose: bool,
|
||||
stats: &mut TexStats,
|
||||
) -> Result<()> {
|
||||
use sylpheed_formats::t8ad;
|
||||
|
||||
if !t8ad::is_t8ad(slice) || slice.len() < 0x40 {
|
||||
return Ok(());
|
||||
}
|
||||
let (w, h, tiles) = (
|
||||
be32_at(slice, 0x14),
|
||||
be32_at(slice, 0x18),
|
||||
be32_at(slice, 0x1c),
|
||||
);
|
||||
|
||||
// Debug: dump the header — 44-byte base + the `tiles`-entry u32 offset table.
|
||||
if std::env::var("XDUMPHDR").is_ok() {
|
||||
println!("\n{stem} {w}x{h} tiles={tiles}");
|
||||
print!(" base[0x00..0x2c]:");
|
||||
for i in (0..44).step_by(4) {
|
||||
print!(" {:08x}", be32_at(slice, i));
|
||||
}
|
||||
print!("\n offsets:");
|
||||
for t in 0..(tiles as usize).min(64) {
|
||||
if 0x2c + t * 4 + 4 <= slice.len() {
|
||||
print!(" {}", be32_at(slice, 0x2c + t * 4));
|
||||
}
|
||||
}
|
||||
println!();
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if verbose {
|
||||
println!(" {hash:08x} {stem:<34} {w:>4}x{h:<4} tiles {tiles}");
|
||||
}
|
||||
match t8ad::parse(slice) {
|
||||
Some(img) => {
|
||||
let out =
|
||||
output.join(format!("{hash:08x}_{stem}_{}x{}.png", img.width, img.height));
|
||||
image::save_buffer(
|
||||
&out,
|
||||
&img.rgba,
|
||||
img.width,
|
||||
img.height,
|
||||
image::ExtendedColorType::Rgba8,
|
||||
)
|
||||
.with_context(|| format!("writing PNG {}", out.display()))?;
|
||||
stats.written += 1;
|
||||
}
|
||||
None => stats.skipped += 1,
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Decode every T8aD in a pak (direct entries, RATC-nested children, LSTA
|
||||
/// frames) to PNG — our decoder's exact output — for A/B against the game.
|
||||
fn cmd_pak_textures(pak: &Path, output: &Path, verbose: bool) -> Result<()> {
|
||||
use sylpheed_formats::{lsta, ratc, t8ad};
|
||||
|
||||
let arc = PakArchive::open(pak).with_context(|| format!("opening {}", pak.display()))?;
|
||||
std::fs::create_dir_all(output)
|
||||
.with_context(|| format!("creating {}", output.display()))?;
|
||||
|
||||
println!(
|
||||
"{} {} → {}",
|
||||
"Textures".green().bold(),
|
||||
pak.display().to_string().cyan(),
|
||||
output.display().to_string().cyan(),
|
||||
);
|
||||
|
||||
let mut stats = TexStats::default();
|
||||
|
||||
for e in arc.entries() {
|
||||
let payload = match arc.read(e) {
|
||||
Ok(p) => p,
|
||||
Err(_) => continue,
|
||||
};
|
||||
let hash = e.name_hash;
|
||||
|
||||
// Direct T8aD entry.
|
||||
if t8ad::is_t8ad(&payload) {
|
||||
emit_t8ad(&payload, hash, "direct", output, verbose, &mut stats)?;
|
||||
continue;
|
||||
}
|
||||
|
||||
// LSTA sprite list = N inline T8aD frames (walk by magic, emit each).
|
||||
if lsta::is_lsta(&payload) {
|
||||
let mut off = 0usize;
|
||||
let mut idx = 0usize;
|
||||
while let Some(pos) = payload[off..]
|
||||
.windows(4)
|
||||
.position(|w| w == &t8ad::T8AD_MAGIC)
|
||||
{
|
||||
let start = off + pos;
|
||||
let next = payload[start + 4..]
|
||||
.windows(4)
|
||||
.position(|w| w == &t8ad::T8AD_MAGIC)
|
||||
.map(|p| start + 4 + p)
|
||||
.unwrap_or(payload.len());
|
||||
emit_t8ad(
|
||||
&payload[start..next],
|
||||
hash,
|
||||
&format!("lsta{idx:03}"),
|
||||
output,
|
||||
verbose,
|
||||
&mut stats,
|
||||
)?;
|
||||
idx += 1;
|
||||
off = next;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// RATC bundle: decode its T8aD children (named, e.g. `foo.t32`).
|
||||
if ratc::is_ratc(&payload) {
|
||||
if let Some(children) = ratc::parse(&payload) {
|
||||
for (i, child) in children.iter().enumerate() {
|
||||
if child.kind != "T8aD" {
|
||||
continue;
|
||||
}
|
||||
let end = (child.offset + child.size).min(payload.len());
|
||||
if child.offset >= end {
|
||||
continue;
|
||||
}
|
||||
let stem = if child.name.is_empty() {
|
||||
format!("child{i:03}")
|
||||
} else {
|
||||
safe_name(&child.name)
|
||||
};
|
||||
emit_t8ad(&payload[child.offset..end], hash, &stem, output, verbose, &mut stats)?;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
println!(
|
||||
"\n {} PNG(s) written, {} undecodable (non-tilecount variants — likely DXT)",
|
||||
stats.written.to_string().green(),
|
||||
stats.skipped.to_string().yellow(),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -19,11 +19,5 @@ tracing = { workspace = true }
|
||||
serde = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
|
||||
# Native-only: parallelise the per-resource XBG7 stage anchoring (hundreds of
|
||||
# independent sub-models per container). rayon needs OS threads, so it is not
|
||||
# pulled in for the wasm32 build, which falls back to a sequential decode.
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
|
||||
rayon = "1"
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { workspace = true }
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
# Capital-ship part placements — runtime-captured ground truth (see
|
||||
# docs/re/ship-placement-runtime-capture.md and src/ship_capture.rs).
|
||||
#
|
||||
# Populate with:
|
||||
# SYLPHEED_ISO=... cargo run --release --example correlate_capture -- \
|
||||
# <capture.log> <Stage_SNN> <ship_id> [ref_part_substr] --emit
|
||||
# then paste the emitted `ship …` block(s) below. The viewer prefers a ship's
|
||||
# entry here over the static assembler when present.
|
||||
#
|
||||
# Per placement line: <part> <R00 R01 R02 R10 R11 R12 R20 R21 R22> <T0 T1 T2>
|
||||
#
|
||||
|
||||
ship e106 ref=e106_bdy_04
|
||||
e106_bdy_01 1 0 0 0 1 0 0 0 1 -263.9948 -150.43242 1164.8667
|
||||
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
|
||||
e106_eng_01 0.8659965 -0.50002277 0 0.4829627 0.83651507 0.25885975 -0.12941553 -0.22417325 0.96592265 131.2386 -133.06625 -132.06075
|
||||
e106_eng_02 1 0 0 0 1 0 0 0 1 0.0013684053 -49.088192 -139.47827
|
||||
e106_wep_02_01 1 0 0 0 1 0 0 0 1 0.000040663195 49.126797 1009.06744
|
||||
@@ -1,9 +0,0 @@
|
||||
use sylpheed_formats::{game_data as gd, PakArchive};
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let pak=PakArchive::open(format!("{disc}/dat/GP_HANGAR_ARSENAL.pak")).unwrap();
|
||||
let a=gd::load_arsenal(&pak);
|
||||
for (hp,list) in [("NOSE",&a.nose),("ARM1",&a.arm1),("ARM2",&a.arm2),("ARM3",&a.arm3)]{
|
||||
println!("{hp} ({}): {:?}", list.len(), list.iter().take(8).collect::<Vec<_>>());
|
||||
}
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
use sylpheed_formats::{game_data as gd, PakArchive};
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let pak=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let units=gd::load_units(&pak); let vessels=gd::load_vessels(&pak);
|
||||
let hp=|id:&str|->String{
|
||||
units.iter().find(|u|u.id.as_deref()==Some(id)).and_then(|u|u.hp).map(|h|format!("{h:.0}hp"))
|
||||
.or_else(||vessels.iter().find(|v|v.id.as_deref()==Some(id)).and_then(|v|v.hp).map(|h|format!("{h:.0}HP")))
|
||||
.unwrap_or("·".into())
|
||||
};
|
||||
let rosters=gd::load_unit_rosters(&pak);
|
||||
for r in rosters.iter().filter(|r|r.stage.is_some()).take(4){
|
||||
println!("\n{} — {} combatants:", r.stage.as_deref().unwrap(), r.units.len());
|
||||
for u in r.units.iter().filter(|u|u.contains("ADAN")).take(6){
|
||||
let short=u.trim_start_matches("UN_").split('_').skip(1).collect::<Vec<_>>().join("_");
|
||||
println!(" {short:32} {}", hp(u));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
use sylpheed_formats::{game_data, localization::TextIndex, PakArchive};
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let pak=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let text=TextIndex::build(&pak);
|
||||
let mut stages=game_data::load_stages(&pak);
|
||||
stages.retain(|s|s.id.starts_with('S') && s.id.len()==3 && s.id[1..].parse::<u32>().map(|n|n<=16).unwrap_or(false));
|
||||
stages.sort_by(|a,b|a.id.cmp(&b.id));
|
||||
println!("═══ CAMPAIGN (S01–S16) ═══");
|
||||
for s in &stages{
|
||||
let obj=text.objectives(&s.id,1);
|
||||
println!("\n{} · {}", s.id, s.location.as_deref().unwrap_or("?"));
|
||||
for o in obj.iter().take(2){ println!(" ▸ {o}"); }
|
||||
}
|
||||
// roster with real names
|
||||
let mut chars=game_data::load_characters(&pak);
|
||||
chars.retain(|c|c.faction.as_deref()==Some("TCAF") && c.unique==Some(true) && c.faces.len()>=4);
|
||||
println!("\n═══ PRINCIPAL CAST (TCAF, named) ═══");
|
||||
for c in &chars{
|
||||
let id=c.id.as_deref().unwrap_or("");
|
||||
let name=text.character_name(id.trim_start_matches("Character")).or_else(||c.name_key.as_deref().and_then(|k|text.get(k))).unwrap_or("?");
|
||||
println!(" {name:12} ({} portraits) [{}]", c.faces.len(), id.trim_start_matches("Character"));
|
||||
}
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
//! Identify which stage + ship a capture log came from: match the capture's
|
||||
//! draw vertex counts against every resource (incl. LODs) of every Stage_SNN.xpr.
|
||||
//! cargo run --release --example capture_match -- <capture.log> <resource3d dir>
|
||||
use sylpheed_formats::mesh::{xbg7_resource_names, Xbg7Model};
|
||||
use sylpheed_formats::ship_capture::{parse_capture, parse_drawlog};
|
||||
use std::collections::{BTreeMap, HashSet};
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let text = std::fs::read_to_string(&a[1]).unwrap();
|
||||
let mut draws = parse_capture(&text);
|
||||
if draws.is_empty() { draws = parse_drawlog(&text); }
|
||||
let caps: HashSet<u32> = draws.iter().map(|d| d.vcount).filter(|v| *v >= 100).collect();
|
||||
eprintln!("{} draws, {} distinct vcounts>=100", draws.len(), caps.len());
|
||||
|
||||
let mut entries: Vec<_> = std::fs::read_dir(&a[2]).unwrap().filter_map(|e| e.ok())
|
||||
.filter(|e| { let n = e.file_name().to_string_lossy().to_string(); n.starts_with("Stage_") && n.ends_with(".xpr") })
|
||||
.map(|e| e.path()).collect();
|
||||
entries.sort();
|
||||
for path in entries {
|
||||
let bytes = std::fs::read(&path).unwrap();
|
||||
let names = xbg7_resource_names(&bytes);
|
||||
let want: HashSet<String> = names.iter().cloned().collect();
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
// resource -> vcount; group hits by ship-id prefix
|
||||
let mut hits: BTreeMap<String, Vec<(String, u32)>> = BTreeMap::new();
|
||||
for m in &models {
|
||||
let vc: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
if vc >= 100 && caps.contains(&(vc as u32)) {
|
||||
let id = m.name.get(..4).unwrap_or("?").to_string();
|
||||
hits.entry(id).or_default().push((m.name.clone(), vc as u32));
|
||||
}
|
||||
}
|
||||
let total: usize = hits.values().map(|v| v.len()).sum();
|
||||
if total >= 3 {
|
||||
println!("== {} : {} matching resources ==", path.file_name().unwrap().to_string_lossy(), total);
|
||||
for (id, v) in &hits {
|
||||
let s: Vec<String> = v.iter().map(|(n, c)| format!("{n}({c})")).collect();
|
||||
println!(" {id}: {}", s.join(" "));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,192 +0,0 @@
|
||||
//! Verify static ship assembly against multi-snapshot, multi-instance F10
|
||||
//! captures: cluster every part's ship-relative transform across ALL ships in
|
||||
//! ALL snapshots, and compare the dominant clusters with `assemble_ship`.
|
||||
//!
|
||||
//! cargo run --release --example capture_verify -- <stage.xpr> <ship_id> <log> [log…]
|
||||
//!
|
||||
//! Every draw is position-validated against the ship's parts (any LOD, set
|
||||
//! based). Each `bdy_04`(-LOD) draw acts as a ship reference; every validated
|
||||
//! part draw within ship range contributes `rel = WV_ref⁻¹ ∘ WV_part`. The true
|
||||
//! per-part placements appear as tight clusters repeated once PER SHIP per
|
||||
//! snapshot; cross-ship pairings scatter and stay below the cluster threshold.
|
||||
use std::collections::HashSet;
|
||||
use sylpheed_formats::mesh::{xbg7_resource_names, Xbg7Model};
|
||||
use sylpheed_formats::ship::{assemble_ship, is_base_part, ship_id_of};
|
||||
use sylpheed_formats::ship_capture::{parse_capture, CapturedDraw};
|
||||
|
||||
type M3 = [[f64; 3]; 3];
|
||||
|
||||
fn transpose(m: &M3) -> M3 {
|
||||
[
|
||||
[m[0][0], m[1][0], m[2][0]],
|
||||
[m[0][1], m[1][1], m[2][1]],
|
||||
[m[0][2], m[1][2], m[2][2]],
|
||||
]
|
||||
}
|
||||
fn mmul(a: &M3, b: &M3) -> M3 {
|
||||
let mut o = [[0.0; 3]; 3];
|
||||
for i in 0..3 {
|
||||
for j in 0..3 {
|
||||
o[i][j] = (0..3).map(|k| a[i][k] * b[k][j]).sum();
|
||||
}
|
||||
}
|
||||
o
|
||||
}
|
||||
fn mv(m: &M3, v: [f64; 3]) -> [f64; 3] {
|
||||
[
|
||||
m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2],
|
||||
m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2],
|
||||
m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2],
|
||||
]
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).unwrap();
|
||||
let id = &a[2];
|
||||
|
||||
// Part position sets (base + LODs share the local frame) + per-variant vcounts.
|
||||
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);
|
||||
struct Part {
|
||||
base: String,
|
||||
vcounts: Vec<u32>,
|
||||
pos: Vec<[f32; 3]>, // union of variants
|
||||
}
|
||||
let mut parts: Vec<Part> = Vec::new();
|
||||
for p in &base_parts {
|
||||
let mut vcounts = Vec::new();
|
||||
let mut pos = Vec::new();
|
||||
for cand in [p.clone(), format!("{p}_m"), format!("{p}_l"), format!("{p}_d")] {
|
||||
if let Some(m) = models.iter().find(|m| m.name == cand) {
|
||||
let mp: Vec<[f32; 3]> =
|
||||
m.meshes.iter().flat_map(|s| s.positions.iter().copied()).collect();
|
||||
vcounts.push(mp.len() as u32);
|
||||
pos.extend(mp);
|
||||
}
|
||||
}
|
||||
parts.push(Part { base: p.clone(), vcounts, pos });
|
||||
}
|
||||
|
||||
// Validate a draw against a part (direct or X-mirrored), like ship_capture.
|
||||
let validate = |d: &CapturedDraw, p: &Part| -> Option<bool> {
|
||||
if !p.vcounts.contains(&d.vcount) || d.pos.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let near = |a: &[f32; 3], b: &[f32; 3]| {
|
||||
(a[0] - b[0]).abs() <= 1e-2 && (a[1] - b[1]).abs() <= 1e-2 && (a[2] - b[2]).abs() <= 1e-2
|
||||
};
|
||||
let (mut direct, mut mirror) = (0usize, 0usize);
|
||||
for q in &d.pos {
|
||||
if p.pos.iter().any(|v| near(q, v)) {
|
||||
direct += 1;
|
||||
}
|
||||
let qm = [-q[0], q[1], q[2]];
|
||||
if p.pos.iter().any(|v| near(&qm, v)) {
|
||||
mirror += 1;
|
||||
}
|
||||
}
|
||||
let need = d.pos.len().div_ceil(2);
|
||||
if direct >= need && direct >= mirror {
|
||||
Some(false)
|
||||
} else if mirror >= need {
|
||||
Some(true)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
|
||||
// Collect rel samples per part across all logs.
|
||||
let mut samples: std::collections::BTreeMap<String, Vec<[f64; 3]>> = Default::default();
|
||||
for log in &a[3..] {
|
||||
let text = std::fs::read_to_string(log).unwrap();
|
||||
let draws = parse_capture(&text);
|
||||
// label validated draws
|
||||
let mut labeled: Vec<(usize, usize, bool)> = Vec::new(); // (draw, part, mirrored)
|
||||
for (di, d) in draws.iter().enumerate() {
|
||||
for (pi, p) in parts.iter().enumerate() {
|
||||
if let Some(mir) = validate(d, p) {
|
||||
labeled.push((di, pi, mir));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
let refs: Vec<usize> = labeled
|
||||
.iter()
|
||||
.filter(|(_, pi, _)| parts[*pi].base.ends_with("bdy_04"))
|
||||
.map(|(di, ..)| *di)
|
||||
.collect();
|
||||
for &ri in &refs {
|
||||
let rf = &draws[ri];
|
||||
let rt = transpose(&rf.r);
|
||||
for &(di, pi, _mir) in &labeled {
|
||||
let d = &draws[di];
|
||||
let dt = [d.t[0] - rf.t[0], d.t[1] - rf.t[1], d.t[2] - rf.t[2]];
|
||||
let rel = mv(&rt, dt);
|
||||
if rel.iter().map(|v| v * v).sum::<f64>().sqrt() < 2600.0 {
|
||||
// also require the rel rotation be finite-sane
|
||||
let _rm = mmul(&rt, &d.r);
|
||||
samples.entry(parts[pi].base.clone()).or_default().push(rel);
|
||||
}
|
||||
}
|
||||
}
|
||||
eprintln!("{log}: {} validated draws, {} bdy_04 refs", labeled.len(), refs.len());
|
||||
}
|
||||
|
||||
// Cluster per part (greedy, 8-unit radius), print clusters with ≥3 samples.
|
||||
println!("\n== dominant ship-relative placements (clusters ≥3 samples) ==");
|
||||
for (part, mut v) in samples {
|
||||
v.sort_by(|x, y| x[0].partial_cmp(&y[0]).unwrap());
|
||||
let mut clusters: Vec<([f64; 3], usize)> = Vec::new();
|
||||
for s in &v {
|
||||
match clusters.iter_mut().find(|(c, _)| {
|
||||
(c[0] - s[0]).abs() < 8.0 && (c[1] - s[1]).abs() < 8.0 && (c[2] - s[2]).abs() < 8.0
|
||||
}) {
|
||||
Some((c, n)) => {
|
||||
for k in 0..3 {
|
||||
c[k] = (c[k] * *n as f64 + s[k]) / (*n as f64 + 1.0);
|
||||
}
|
||||
*n += 1;
|
||||
}
|
||||
None => clusters.push((*s, 1)),
|
||||
}
|
||||
}
|
||||
clusters.sort_by(|x, y| y.1.cmp(&x.1));
|
||||
let tops: Vec<String> = clusters
|
||||
.iter()
|
||||
.filter(|(_, n)| *n >= 3)
|
||||
.take(6)
|
||||
.map(|(c, n)| format!("[{:7.1} {:7.1} {:7.1}]×{n}", c[0], c[1], c[2]))
|
||||
.collect();
|
||||
println!(" {part:20} {}", tops.join(" "));
|
||||
}
|
||||
|
||||
// Static assembly rel bdy_04 for comparison.
|
||||
println!("\n== static assemble_ship rel bdy_04 ==");
|
||||
let placed = assemble_ship(&bytes, id, true);
|
||||
if let Some(r4) = placed.iter().find(|p| p.resource == format!("{id}_bdy_04")) {
|
||||
for p in &placed {
|
||||
println!(
|
||||
" {:20} [{:7.1} {:7.1} {:7.1}]",
|
||||
p.resource,
|
||||
p.t[0] - r4.t[0],
|
||||
p.t[1] - r4.t[1],
|
||||
p.t[2] - r4.t[2]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,136 +0,0 @@
|
||||
//! Recover exact capital-ship part placement from a Canary capture log
|
||||
//! and (optionally) emit a checked-in placement-table block.
|
||||
//!
|
||||
//! The correlation math lives in [`sylpheed_formats::ship_capture`]; this example
|
||||
//! is the CLI wrapper: it reads the log, decodes the ship's parts from the disc to
|
||||
//! get their vertex counts + leading positions (the match keys), correlates, and
|
||||
//! prints the result. With `--emit` it prints the `ship …` block to paste into
|
||||
//! `crates/sylpheed-formats/data/ship_placements.txt`.
|
||||
//!
|
||||
//! Matching is **LOD-aware**: a ship on screen at distance is drawn with its
|
||||
//! `_m`/`_l` LOD copies, which live in the same local frame as the base part — so
|
||||
//! each base part tries its own vcount first, then its LOD variants', and the
|
||||
//! recovered transform is recorded under the base name. Same-vcount twins
|
||||
//! (mirrored port/starboard hulls) are routed by the draw's position dump.
|
||||
//!
|
||||
//! 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
|
||||
//! Deception (USA, Europe) (En,Ja).iso" \
|
||||
//! cargo run --release --example correlate_capture -- \
|
||||
//! xenia_ship_capture.log Stage_S01 e106 bdy_04 --emit
|
||||
|
||||
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, serialize_table, PartKey,
|
||||
};
|
||||
use sylpheed_formats::xiso::open_iso;
|
||||
use std::collections::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 emit = args.iter().any(|a| a == "--emit");
|
||||
if positional.len() < 3 {
|
||||
eprintln!(
|
||||
"usage: correlate_capture <capture.log> <Stage_SNN> <ship_id> [ref_part_substr] [--emit]"
|
||||
);
|
||||
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_04");
|
||||
let iso = std::env::var("SYLPHEED_ISO").expect("SYLPHEED_ISO");
|
||||
|
||||
// Accept either the F10 ship-capture format or the draw-logger format;
|
||||
// auto-detect by trying the F10 parser first.
|
||||
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);
|
||||
eprintln!("parsed {} draws (draw-logger format)", draws.len());
|
||||
} else {
|
||||
eprintln!("parsed {} draws (F10 capture format)", draws.len());
|
||||
}
|
||||
|
||||
// Decode the ship's base parts AND their LOD copies (vcount + leading
|
||||
// positions are the match keys; LODs share the base part's local frame).
|
||||
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();
|
||||
// Candidate resources per base part: itself + `_m`/`_l`/`_d` LOD copies.
|
||||
let mut want: HashSet<String> = base_parts.iter().cloned().collect();
|
||||
for p in &base_parts {
|
||||
for suf in ["_m", "_l", "_d"] {
|
||||
let cand = format!("{p}{suf}");
|
||||
if names.contains(&cand) {
|
||||
want.insert(cand);
|
||||
}
|
||||
}
|
||||
}
|
||||
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())
|
||||
};
|
||||
|
||||
// One PartKey per (part, variant-vcount present in the capture) — correlate
|
||||
// takes the first that validates. Validation uses the UNION of the part's
|
||||
// variant position sets: a draw's `vcount` can match one LOD while its
|
||||
// buffer holds another variant's geometry (seen on the real e106: the
|
||||
// 558-vcount draw carried the FULL 1633-vert bdy_04 buffer), and every
|
||||
// variant is the same part in the same local frame.
|
||||
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();
|
||||
let mut any = false;
|
||||
for cand in &variants {
|
||||
if let Some(pos) = positions_of(cand) {
|
||||
let vcount = pos.len() as u32;
|
||||
if draws.iter().any(|d| d.vcount == vcount) {
|
||||
let lod = if cand == part { "full" } else { cand.rsplit('_').next().unwrap_or("?") };
|
||||
eprintln!(" {part:20} try vcount={vcount:6} [{lod}]");
|
||||
keys.push(PartKey { part: part.clone(), vcount, ref_pos: union.clone() });
|
||||
any = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if !any {
|
||||
eprintln!(" {part:20} — no draw matches any LOD (culled/off-screen?)");
|
||||
}
|
||||
}
|
||||
|
||||
let Some(ship) = correlate(id, &draws, &keys, ref_sub) else {
|
||||
eprintln!("no parts matched a captured draw");
|
||||
return;
|
||||
};
|
||||
|
||||
eprintln!("\nreference = {} → ship-relative placement:", ship.reference);
|
||||
for p in &ship.parts {
|
||||
eprintln!(" {:18} T=[{:9.1}{:9.1}{:9.1}]", p.part, p.t[0], p.t[1], p.t[2]);
|
||||
}
|
||||
for part in &base_parts {
|
||||
if !ship.parts.iter().any(|p| &p.part == part) {
|
||||
eprintln!(" {part:18} — NOT placed (culled, or its only vcount hit failed position validation)");
|
||||
}
|
||||
}
|
||||
|
||||
if emit {
|
||||
print!("{}", serialize_table(std::slice::from_ref(&ship)));
|
||||
}
|
||||
}
|
||||
@@ -1,59 +0,0 @@
|
||||
use sylpheed_formats::{ratc, idxd::IdxdObject, PakArchive};
|
||||
use std::collections::BTreeMap;
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
// 1. RATC child-type census across the big RATC paks
|
||||
let mut childtypes:BTreeMap<String,u64>=BTreeMap::new();
|
||||
let mut ratc_unparsed=0u64;
|
||||
for pk in ["GP_READY_ROOM","GP_MOVIE_THEATER","GP_DIALOG","GP_DEBRIEFING_PILOTLOG","GP_TITLE","GP_BUNK"]{
|
||||
let Ok(arc)=PakArchive::open(format!("{disc}/dat/{pk}.pak")) else{continue};
|
||||
for e in arc.entries(){
|
||||
let Ok(b)=arc.read(e) else{continue};
|
||||
if !ratc::is_ratc(&b){continue;}
|
||||
match ratc::parse(&b){
|
||||
Some(kids)=> for k in kids{
|
||||
let ext=k.name.rsplit('.').next().unwrap_or("?").to_lowercase();
|
||||
*childtypes.entry(ext).or_default()+=1;
|
||||
},
|
||||
None=>ratc_unparsed+=1,
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("=== RATC child-type census (big RATC paks) ===");
|
||||
let mut cv:Vec<_>=childtypes.into_iter().collect(); cv.sort_by_key(|x|std::cmp::Reverse(x.1));
|
||||
for (e,c) in &cv{ println!(" .{e:8} ×{c}"); }
|
||||
println!(" (RATC bundles that failed to parse: {ratc_unparsed})");
|
||||
|
||||
// 2. The 00000002 mystery format (GP_MAIN_GAME_E)
|
||||
let arc=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
for e in arc.entries(){
|
||||
let Ok(b)=arc.read(e) else{continue};
|
||||
if b.len()>=4 && b[0..4]==[0,0,0,2]{
|
||||
let hx:String=b[..48.min(b.len())].iter().map(|x|format!("{x:02x}")).collect::<Vec<_>>().join(" ");
|
||||
let asc:String=b[..64.min(b.len())].iter().map(|&x|if(0x20..0x7f).contains(&x){x as char}else{'.'}).collect();
|
||||
println!("\n=== 00000002 format sample ({}B) ===\n{hx}\n{asc}",b.len());
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Sample the top undecoded IDXD schemas: first tokens (guess semantics)
|
||||
println!("\n=== top undecoded IDXD schemas — sample tokens (semantic hints) ===");
|
||||
let targets:[u32;6]=[0xb412e6d8,0x026379ab,0x43faa517,0x3c5b0549,0x6ab4825a,0x0426e81d];
|
||||
for want in targets{
|
||||
let mut shown=false;
|
||||
for e in arc.entries(){
|
||||
if shown{break;}
|
||||
let Ok(b)=arc.read(e) else{continue};
|
||||
if b.len()<12 || &b[0..4]!=b"IDXD"{continue;}
|
||||
let s=u32::from_be_bytes([b[8],b[9],b[10],b[11]]);
|
||||
if s!=want{continue;}
|
||||
if let Ok(o)=IdxdObject::parse(&b){
|
||||
let t=o.tokens();
|
||||
let sample:Vec<String>=t.iter().take(14).map(|s|{let s=s.chars().take(18).collect::<String>();s}).collect();
|
||||
println!(" {want:08x}: {sample:?}");
|
||||
shown=true;
|
||||
}
|
||||
}
|
||||
if !shown{ println!(" {want:08x}: (parse failed / not found)"); }
|
||||
}
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
use sylpheed_formats::{game_data, localization::TextIndex, PakArchive};
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let pak=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let text=TextIndex::build(&pak);
|
||||
let msgs=game_data::load_demo_messages(&pak);
|
||||
println!("{} dialogue lines total\n", msgs.len());
|
||||
for m in msgs.iter().filter(|m|m.character.is_some()&&!m.page_keys.is_empty()).take(8){
|
||||
let who=m.character.as_deref().unwrap_or("?").trim_start_matches("Character");
|
||||
let line:String=m.page_keys.iter().filter_map(|k|text.get(k)).collect::<Vec<_>>().join(" ");
|
||||
println!(" {who:10} [{}] “{}”", m.voice_clip.as_deref().unwrap_or("-"), line.chars().take(64).collect::<String>());
|
||||
}
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
use sylpheed_formats::{idxd::IdxdObject, PakArchive};
|
||||
use std::collections::BTreeMap;
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let arc=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let tables:[(u32,&str);4]=[(0x0426e81d,"Player / physics+scoring"),(0x6ab4825a,"Weapon"),(0x43faa517,"Unit / craft"),(0x3c5b0549,"Vessel / capital ship")];
|
||||
for (want,label) in tables{
|
||||
// collect all records of this schema
|
||||
let mut recs:Vec<IdxdObject>=vec![];
|
||||
for e in arc.entries(){ let Ok(b)=arc.read(e) else{continue}; let Ok(o)=IdxdObject::parse(&b) else{continue}; if o.schema_hash==want{recs.push(o);} }
|
||||
// field-union (explicit-valued keys), with occurrence count
|
||||
let mut cols:BTreeMap<String,u32>=BTreeMap::new();
|
||||
for o in &recs{ for (k,_) in o.resolved_fields(){ *cols.entry(k.into()).or_default()+=1; } }
|
||||
println!("\n╔══ {label} [{want:08x}] {} records ══", recs.len());
|
||||
let mut cv:Vec<_>=cols.into_iter().collect(); cv.sort_by_key(|x|std::cmp::Reverse(x.1));
|
||||
let colstr:String=cv.iter().take(28).map(|(k,c)|format!("{k}({c})")).collect::<Vec<_>>().join(" ");
|
||||
println!("║ numeric/enum fields: {colstr}");
|
||||
// dump 2 sample records: identity + explicit fields
|
||||
for o in recs.iter().take(2){
|
||||
let id=o.get_raw("ID").unwrap_or("?");
|
||||
let name=o.get_raw("Name").unwrap_or("");
|
||||
print!("║ • {id}");
|
||||
if !name.is_empty(){print!(" «{name}»");}
|
||||
println!();
|
||||
let fields:Vec<String>=o.resolved_fields().iter().map(|(k,v)|format!("{k}={v}")).collect();
|
||||
for chunk in fields.chunks(5){ println!("║ {}", chunk.join(" ")); }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
use sylpheed_formats::{game_data, PakArchive};
|
||||
use std::collections::BTreeMap;
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let pak=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let chars=game_data::load_characters(&pak);
|
||||
let mut byfac:BTreeMap<String,Vec<String>>=Default::default();
|
||||
for c in &chars{ byfac.entry(c.faction.clone().unwrap_or("·".into())).or_default().push(format!("{}({})",c.id.clone().unwrap_or_default().trim_start_matches("Character"),c.faces.len())); }
|
||||
println!("{} characters across {} factions:",chars.len(),byfac.len());
|
||||
for (f,mut v) in byfac{ v.sort(); println!(" [{f}] {}", v.join(" ")); }
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
use sylpheed_formats::{idxd::IdxdObject, PakArchive};
|
||||
fn short(s:&str)->String{ s.trim_start_matches("Weapon_").trim_start_matches("UN_").trim_start_matches("UnitName_UN_").into() }
|
||||
fn g<'a>(o:&'a IdxdObject,k:&str)->String{ o.get_f32(k).map(|v|{if v==v.trunc(){format!("{}",v as i64)}else{format!("{v}")}}).or_else(||o.get_raw(k).filter(|x|x.chars().next().map(|c|c.is_ascii_digit()).unwrap_or(false)).map(|s|s.to_string())).unwrap_or("·".into()) }
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let arc=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let recs=|want:u32|->Vec<IdxdObject>{ arc.entries().iter().filter_map(|e|arc.read(e).ok()).filter_map(|b|IdxdObject::parse(&b).ok()).filter(|o|o.schema_hash==want).collect() };
|
||||
println!("### WEAPONS (name | target | load | int | power | vel | range | trig)");
|
||||
for o in recs(0x6ab4825a).iter().take(16){ println!("{:<34}\t{}\t{}\t{}\t{}\t{}\t{}\t{}", short(o.get_raw("ID").unwrap_or("?")), o.get_raw("TargetType").unwrap_or("·"), g(o,"LoadingCount"),g(o,"Interval"),g(o,"Power"),g(o,"Velocity"),g(o,"MaximumRange"),g(o,"TriggerShotCount")); }
|
||||
println!("\n### UNITS/CRAFT (name | HP | cruise | accel | radar | turrets | score)");
|
||||
for o in recs(0x43faa517).iter().take(16){ println!("{:<38}\t{}\t{}\t{}\t{}\t{}\t{}", short(o.get_raw("ID").unwrap_or("?")), g(o,"HP"),g(o,"CruisingVelocity"),g(o,"Acceleration"),g(o,"RadarRange"),g(o,"TurretCount"),g(o,"ScorePoint")); }
|
||||
println!("\n### VESSELS/CAPITAL SHIPS (name | HP | Sz_X | Sz_Z | radar | turrets | bridges | hatches | shieldgen | thrusters)");
|
||||
for o in recs(0x3c5b0549).iter(){ println!("{:<30}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}", short(o.get_raw("ID").unwrap_or("?")), g(o,"HP"),g(o,"Size_X"),g(o,"Size_Z"),g(o,"RadarRange"),g(o,"TurretCount"),g(o,"BridgeCount"),g(o,"HatchCount"),g(o,"ShieldGeneratorCount"),g(o,"ThrusterCount")); }
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
use sylpheed_formats::{game_data, localization::TextIndex, PakArchive};
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let pak=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let text=TextIndex::build(&pak);
|
||||
for n in 1..=16u32{
|
||||
let sid=format!("S{n:02}");
|
||||
// primary objective across phases (first that resolves)
|
||||
let obj:Vec<String>=(1..=3).flat_map(|p|text.objectives(&sid,p)).map(|s|s.to_string()).collect();
|
||||
let lose:Vec<String>=(1..=3).flat_map(|p|text.lose_conditions(&sid,p)).map(|s|s.to_string()).collect();
|
||||
let full_obj=obj.join(" ");
|
||||
let full_lose=lose.into_iter().take(2).collect::<Vec<_>>().join(" ");
|
||||
println!("{sid}\t{full_obj}\t{full_lose}");
|
||||
}
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
use sylpheed_formats::{game_data as gd, PakArchive};
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let pak=PakArchive::open(format!("{disc}/dat/GP_HANGAR_ARSENAL.pak")).unwrap();
|
||||
let rosters=gd::load_pilot_rosters(&pak);
|
||||
// distinct rosters by their pilot set
|
||||
let mut seen=std::collections::BTreeSet::new(); let mut shown=0;
|
||||
println!("{} pilot-roster configs; distinct line-ups:", rosters.len());
|
||||
for r in &rosters{
|
||||
let key:String=r.pilots.iter().map(|(c,p)|format!("{c}:{p}")).collect::<Vec<_>>().join(",");
|
||||
if seen.insert(key) && shown<8 {
|
||||
shown+=1;
|
||||
let flt:Vec<String>=r.pilots.iter().map(|(c,p)|format!("{c}={p}")).collect();
|
||||
println!(" {}", flt.join(" "));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
use sylpheed_formats::{hash::name_hash, movie_manifest, movie_subtitle as ms, movie_voice, slb, PakArchive};
|
||||
use std::fs;use std::io::{Read,Seek,SeekFrom};use std::process::Command;
|
||||
fn rg(disc:&str,g:u64,n:usize)->Vec<u8>{let mut segs=vec![];let mut cum=0u64;for i in 0..5{let p=format!("{disc}/dat/sound.p{i:02}");if let Ok(m)=fs::metadata(&p){segs.push((cum,m.len(),p));cum+=m.len();}}let mut out=vec![];let(mut need,mut pos)=(n,g);for(base,len,path)in &segs{if need==0||pos>=base+len||pos<*base{continue;}let local=pos-base;let take=need.min((len-local)as usize);let mut f=fs::File::open(path).unwrap();f.seek(SeekFrom::Start(local)).unwrap();let mut b=vec![0u8;take];f.read_exact(&mut b).unwrap();out.extend_from_slice(&b);need-=take;pos+=take as u64;}out}
|
||||
fn ct(h:&[u8],n:&[u8])->bool{h.windows(n.len()).any(|w|w==n)}
|
||||
fn dur(w:&str)->String{let o=Command::new("ffprobe").args(["-v","error","-show_entries","format=duration","-of","default=nw=1:nk=1",w]).output().unwrap();String::from_utf8_lossy(&o.stdout).trim().to_string()}
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let tpak=PakArchive::open(format!("{disc}/dat/tables.pak")).unwrap();
|
||||
let man=tpak.entries().iter().find_map(|e|tpak.read(e).ok().filter(|b|movie_manifest::is_manifest(b))).unwrap();
|
||||
let lpak=PakArchive::open(format!("{disc}/dat/movie/eng.pak")).unwrap();
|
||||
let reg=tpak.entries().iter().find_map(|e|tpak.read(e).ok().filter(|b|ct(b,b"eng\\Movie\\VOICE_ADV.slb"))).unwrap();
|
||||
let ids=movie_voice::registry_voice_ids(®);
|
||||
let stoc=fs::read(format!("{disc}/dat/sound.pak")).unwrap();
|
||||
let ents=PakArchive::parse_toc(&stoc).unwrap();
|
||||
// demo->token from bound hokyu
|
||||
let hok:Vec<_>=movie_manifest::parse(&man).into_iter().filter(|m|m.movie.starts_with("hokyu_")).collect();
|
||||
let resolve=|movie:&str|->Option<String>{
|
||||
movie_manifest::voice_token(&man,movie).or_else(||{
|
||||
let want=ms::track_voice_cues(&lpak,movie).first().map(|&(d,_)|d)?;
|
||||
hok.iter().find_map(|e|{let t=e.voice_token.clone().filter(|_|e.movie.starts_with("hokyu_"))?; ms::track_voice_cues(&lpak,&e.movie).iter().any(|&(d,_)|d==want).then_some(t)})
|
||||
})
|
||||
};
|
||||
for e in &hok{
|
||||
let mv=&e.movie;
|
||||
let bound=e.voice_token.is_some();
|
||||
let tok=resolve(mv);
|
||||
let demo=ms::track_voice_cues(&lpak,mv).first().map(|&(d,_)|d);
|
||||
let mut d="—".to_string();
|
||||
if let Some(tok)=&tok{
|
||||
if let Some(&id)=ids.get(tok){
|
||||
if let Some(anchor)=["Movie","etc","Voice"].iter().find_map(|dir|{let h=name_hash(&format!("eng\\{dir}\\{tok}.slb"));ents.binary_search_by_key(&h,|x|x.name_hash).ok().map(|i|ents[i].offset as u64)}){
|
||||
let ws=(anchor.saturating_sub(2*1024*1024))&!3; let win=rg(&disc,ws,8*1024*1024);
|
||||
if let Some(el)=movie_voice::find_descriptor(&win,id){let end=ws+el as u64;
|
||||
let start=movie_voice::find_descriptor(&win,id.wrapping_sub(1)).or_else(||movie_voice::find_descriptor_before(&win,el)).map(|o|ws+o as u64).filter(|&s|s<end&&end-s<1_500_000).unwrap_or(anchor);
|
||||
let region=rg(&disc,start,(end-start)as usize); let mut rf=slb::to_xma_riffs(®ion); if rf.is_empty(){rf=slb::to_xma_riff_best(®ion).into_iter().collect();}
|
||||
if let Some(r)=rf.first(){let xp=format!("/tmp/hd_{mv}.xma.wav");let wp=format!("/tmp/hd_{mv}.wav");fs::write(&xp,r).unwrap();let _=Command::new("ffmpeg").args(["-hide_banner","-v","error","-y","-i",&xp,&wp]).status();d=dur(&wp);}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("{mv:16} {:8} demo={:?} -> {:11} voice={d}s", if bound{"BOUND"}else{"unbound"}, demo, tok.unwrap_or("(silent)".into()));
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
use sylpheed_formats::{hash::name_hash, movie_manifest, movie_voice, slb, PakArchive};
|
||||
use std::fs;use std::io::{Read,Seek,SeekFrom};use std::process::Command;
|
||||
fn rg(disc:&str,g:u64,n:usize)->Vec<u8>{let mut segs=vec![];let mut cum=0u64;for i in 0..5{let p=format!("{disc}/dat/sound.p{i:02}");if let Ok(m)=fs::metadata(&p){segs.push((cum,m.len(),p));cum+=m.len();}}let mut out=vec![];let(mut need,mut pos)=(n,g);for(base,len,path)in &segs{if need==0||pos>=base+len||pos<*base{continue;}let local=pos-base;let take=need.min((len-local)as usize);let mut f=fs::File::open(path).unwrap();f.seek(SeekFrom::Start(local)).unwrap();let mut b=vec![0u8;take];f.read_exact(&mut b).unwrap();out.extend_from_slice(&b);need-=take;pos+=take as u64;}out}
|
||||
fn contains(h:&[u8],n:&[u8])->bool{h.windows(n.len()).any(|w|w==n)}
|
||||
fn dur(w:&str)->String{let o=Command::new("ffprobe").args(["-v","error","-show_entries","format=duration","-of","default=nw=1:nk=1",w]).output().unwrap();String::from_utf8_lossy(&o.stdout).trim().to_string()}
|
||||
fn hokyu_fallback(m:&str)->Option<String>{if !m.starts_with("hokyu_"){return None}let ls=m.contains("_LS_");let ds=m.contains("_DS_");let a=m.ends_with('A');let h=m.ends_with('H');Some(match(ls,ds,a,h){(true,_,true,_)=>"VOICE_D_450",(true,_,_,true)=>"VOICE_D_453",(_,true,true,_)=>"VOICE_D_452",(_,true,_,true)=>"VOICE_D_454",_=>return None}.into())}
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let tpak=PakArchive::open(format!("{disc}/dat/tables.pak")).unwrap();
|
||||
let manifest=tpak.entries().iter().find_map(|e|tpak.read(e).ok().filter(|b|movie_manifest::is_manifest(b))).unwrap();
|
||||
let code="eng";
|
||||
let registry=tpak.entries().iter().find_map(|e|tpak.read(e).ok().filter(|b|contains(b,format!("{code}\\Movie\\VOICE_ADV.slb").as_bytes()))).unwrap();
|
||||
let ids=movie_voice::registry_voice_ids(®istry);
|
||||
let stoc=fs::read(format!("{disc}/dat/sound.pak")).unwrap();
|
||||
let entries=PakArchive::parse_toc(&stoc).unwrap();
|
||||
let hokyu:Vec<String>=movie_manifest::parse(&manifest).into_iter().filter(|m|m.movie.starts_with("hokyu_")).map(|m|m.movie).collect();
|
||||
for movie in &hokyu{
|
||||
let bound=movie_manifest::voice_token(&manifest,movie);
|
||||
let token=bound.clone().or_else(||hokyu_fallback(movie));
|
||||
let Some(token)=token else{println!("{movie:16} NO TOKEN"); continue};
|
||||
let src = if bound.is_some(){"bound"}else{"fallback"};
|
||||
let Some(&id)=ids.get(&token) else{println!("{movie:16} {token} not in registry");continue};
|
||||
let Some(anchor)=["Movie","etc","Voice"].iter().find_map(|d|{let h=name_hash(&format!("{code}\\{d}\\{token}.slb"));entries.binary_search_by_key(&h,|e|e.name_hash).ok().map(|i|entries[i].offset as u64)}) else{println!("{movie:16} no anchor");continue};
|
||||
let win_start=(anchor.saturating_sub(2*1024*1024))&!3;
|
||||
let window=rg(&disc,win_start,8*1024*1024);
|
||||
let Some(el)=movie_voice::find_descriptor(&window,id) else{println!("{movie:16} desc not found");continue};
|
||||
let end=win_start+el as u64;
|
||||
let start=movie_voice::find_descriptor(&window,id.wrapping_sub(1)).or_else(||movie_voice::find_descriptor_before(&window,el)).map(|o|win_start+o as u64).filter(|&s|s<end&&end-s<1_500_000).unwrap_or(anchor);
|
||||
let region=rg(&disc,start,(end-start)as usize);
|
||||
let mut riffs=slb::to_xma_riffs(®ion); if riffs.is_empty(){riffs=slb::to_xma_riff_best(®ion).into_iter().collect();}
|
||||
let mut d="?".into();
|
||||
if let Some(r)=riffs.first(){let xp=format!("/tmp/hf_{movie}.xma.wav");let wp=format!("/tmp/hf_{movie}.wav");fs::write(&xp,r).unwrap();let _=Command::new("ffmpeg").args(["-hide_banner","-v","error","-y","-i",&xp,&wp]).status();d=dur(&wp);}
|
||||
let mv=dur(&format!("{disc}/dat/movie/{movie}.wmv"));
|
||||
println!("{movie:16} {src:8} {token:12} id={id} voice={d}s movie={mv}s");
|
||||
}
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
use sylpheed_formats::PakArchive;
|
||||
use std::collections::BTreeMap;
|
||||
fn be32(b:&[u8],o:usize)->u32{ if o+4<=b.len(){u32::from_be_bytes([b[o],b[o+1],b[o+2],b[o+3]])}else{0} }
|
||||
fn magic(b:&[u8])->String{
|
||||
if b.len()<4 {return "(<4B)".into();}
|
||||
let m=&b[0..4];
|
||||
if m.iter().all(|&c|(0x20..0x7f).contains(&c)){ String::from_utf8_lossy(m).into() }
|
||||
else if m==b"\x89PNG"{"PNG".into()} else if m==[0,1,0,0]{"ttf".into()}
|
||||
else { format!("{:02x}{:02x}{:02x}{:02x}",m[0],m[1],m[2],m[3]) }
|
||||
}
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
// Known/understood IDXD schemas (semantic parsers we have)
|
||||
let known_schema:BTreeMap<u32,&str>=[(0x067025b9,"ADVERTISE_MOVIE (movie_manifest)"),(0x13cb84ba,"sound registry / sounds.tbl")].into();
|
||||
let mut fmt_count:BTreeMap<String,(u64,u64)>=BTreeMap::new(); // fmt -> (count, bytes)
|
||||
let mut schema_census:BTreeMap<u32,(u64,u64,String)>=BTreeMap::new(); // schema -> (count,bytes,sample pak)
|
||||
let mut unknown_magics:BTreeMap<String,(u64,Vec<String>)>=BTreeMap::new();
|
||||
let paks:Vec<String>={let mut v=vec![]; for e in std::fs::read_dir(format!("{disc}/dat")).unwrap(){let p=e.unwrap().path(); if p.extension().map(|x|x=="pak").unwrap_or(false){v.push(p.file_stem().unwrap().to_string_lossy().into());}} v.sort(); v};
|
||||
println!("pak entries decompressed formats");
|
||||
for pk in &paks{
|
||||
let Ok(arc)=PakArchive::open(format!("{disc}/dat/{pk}.pak")) else{continue};
|
||||
let mut per:BTreeMap<String,u64>=BTreeMap::new();
|
||||
let mut tot=0u64; let n=arc.entries().len();
|
||||
for e in arc.entries(){
|
||||
let Ok(b)=arc.read(e) else{continue};
|
||||
tot+=b.len() as u64;
|
||||
let mut f=magic(&b);
|
||||
if f=="IDXD"{ let s=be32(&b,8); schema_census.entry(s).or_insert((0,0,pk.clone())).0+=1; schema_census.get_mut(&s).unwrap().1+=b.len() as u64; f=format!("IDXD:{s:08x}"); }
|
||||
else if !["XPR2","IXUD","LSTA","RATC","RIFF","XBG7","OTTO","PNG","ttf","DDS ","T8AD"].contains(&f.as_str()){
|
||||
let ent=unknown_magics.entry(f.clone()).or_insert((0,vec![])); ent.0+=1; if ent.1.len()<3 && !ent.1.contains(pk){ent.1.push(pk.clone());}
|
||||
}
|
||||
*per.entry(if f.starts_with("IDXD:"){"IDXD".into()}else{f.clone()}).or_default()+=1;
|
||||
let g=fmt_count.entry(if f.starts_with("IDXD:"){"IDXD".into()}else{f}).or_insert((0,0)); g.0+=1; g.1+=b.len() as u64;
|
||||
}
|
||||
let mut fs:Vec<_>=per.into_iter().collect(); fs.sort_by_key(|x|std::cmp::Reverse(x.1));
|
||||
let top:String=fs.iter().take(4).map(|(k,v)|format!("{k}×{v}")).collect::<Vec<_>>().join(" ");
|
||||
println!("{pk:26} {n:>7} {:>10}KB {top}", tot/1024);
|
||||
}
|
||||
println!("\n=== FORMAT TOTALS (across all paks) ===");
|
||||
let mut fv:Vec<_>=fmt_count.into_iter().collect(); fv.sort_by_key(|x|std::cmp::Reverse(x.1.1));
|
||||
for (f,(c,b)) in &fv{ println!(" {f:12} {c:>6} entries {:>8}KB", b/1024); }
|
||||
println!("\n=== IDXD SCHEMA CENSUS ({} distinct schemas) ===", schema_census.len());
|
||||
let mut sv:Vec<_>=schema_census.into_iter().collect(); sv.sort_by_key(|x|std::cmp::Reverse(x.1.1));
|
||||
for (s,(c,b,pk)) in &sv{
|
||||
let tag=known_schema.get(s).copied().unwrap_or("??? UNDECODED");
|
||||
println!(" {s:08x} {c:>5} ent {:>7}KB e.g. {pk:22} {tag}", b/1024);
|
||||
}
|
||||
println!("\n=== UNKNOWN / UNCLASSIFIED MAGICS ===");
|
||||
for (m,(c,pks)) in &unknown_magics{ println!(" {m:12} ×{c:<5} in {pks:?}"); }
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
//! Validation: dump the parsed mission/phase cutscene map from the real manifest.
|
||||
use sylpheed_formats::movie_manifest::{self, MovieKind};
|
||||
use sylpheed_formats::pak::PakArchive;
|
||||
|
||||
fn main() {
|
||||
let disc = std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC");
|
||||
let arc = PakArchive::open(format!("{disc}/dat/tables.pak")).unwrap();
|
||||
let man = arc
|
||||
.entries()
|
||||
.iter()
|
||||
.find_map(|e| arc.read(e).ok().filter(|b| movie_manifest::is_manifest(b)))
|
||||
.expect("manifest");
|
||||
let entries = movie_manifest::parse(&man);
|
||||
let mut counts = [0usize; 5];
|
||||
for e in &entries {
|
||||
counts[match e.kind {
|
||||
MovieKind::System => 0,
|
||||
MovieKind::Intro => 1,
|
||||
MovieKind::Phase => 2,
|
||||
MovieKind::PhaseEnd => 3,
|
||||
MovieKind::Supply => 4,
|
||||
}] += 1;
|
||||
let m = e.mission.map(|x| x.to_string()).unwrap_or_default();
|
||||
let p = e.phase.map(|x| x.to_string()).unwrap_or_default();
|
||||
println!(
|
||||
"{:<22} {:<9} m={:<2} p={:<1} {:<16} {:<14} tel={:<14} sub={}",
|
||||
e.slot,
|
||||
format!("{:?}", e.kind),
|
||||
m,
|
||||
p,
|
||||
e.movie,
|
||||
e.voice_token.as_deref().unwrap_or("-"),
|
||||
e.telop.as_deref().unwrap_or("-"),
|
||||
e.subtitle.as_deref().unwrap_or("-"),
|
||||
);
|
||||
}
|
||||
eprintln!(
|
||||
"TOTAL {} entries — System={} Intro={} Phase={} PhaseEnd={} Supply={}",
|
||||
entries.len(),
|
||||
counts[0],
|
||||
counts[1],
|
||||
counts[2],
|
||||
counts[3],
|
||||
counts[4]
|
||||
);
|
||||
}
|
||||
@@ -1,47 +0,0 @@
|
||||
use sylpheed_formats::{idxd::IdxdObject, PakArchive};
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let arc=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
// 1. All stages: BackGroundID + phases + stage tag (from EnumUnit_SNN)
|
||||
println!("=== STAGES (StageResource 3c9ae32e) ===");
|
||||
let mut rows=vec![];
|
||||
for e in arc.entries(){
|
||||
let Ok(b)=arc.read(e) else{continue}; let Ok(o)=IdxdObject::parse(&b) else{continue};
|
||||
if o.schema_hash!=0x3c9ae32e {continue;}
|
||||
let t=o.tokens();
|
||||
let bg=o.get_raw("BackGroundID").unwrap_or("?").to_string();
|
||||
let stage=t.iter().find_map(|s|s.strip_prefix("EnumUnit_").map(|x|x.trim_end_matches(".tbl").to_string())).unwrap_or("?".into());
|
||||
let phases=t.iter().filter(|s|s.starts_with("Phase_")).count();
|
||||
let unitgrp=t.iter().any(|s|s.starts_with("UnitGroup_"));
|
||||
let route=t.iter().any(|s|s.starts_with("Route_"));
|
||||
let formation=t.iter().any(|s|s.starts_with("FormationSet_"));
|
||||
rows.push((stage,bg,phases,unitgrp,route,formation));
|
||||
}
|
||||
rows.sort();
|
||||
for (s,bg,p,ug,rt,fm) in &rows{ println!(" {s:8} location={bg:14} phases={p} [squadrons:{} route:{} formations:{}]", if *ug{"Y"}else{"·"},if *rt{"Y"}else{"·"},if *fm{"Y"}else{"·"}); }
|
||||
|
||||
// 2. Parse objectives table into (stage,phase) -> key counts
|
||||
println!("\n=== OBJECTIVES (033b5b7e) — per stage/phase key groups ===");
|
||||
for e in arc.entries(){
|
||||
let Ok(b)=arc.read(e) else{continue}; let Ok(o)=IdxdObject::parse(&b) else{continue};
|
||||
if o.schema_hash!=0x033b5b7e {continue;}
|
||||
let t=o.tokens();
|
||||
let mut groups:std::collections::BTreeMap<String,u32>=Default::default();
|
||||
for tok in t{ if let Some(p)=tok.find("_Objective_").or_else(||tok.find("_Lose_")).or_else(||tok.find("_Hint_")){ let key=&tok[..p]; *groups.entry(key.trim_start_matches(|c:char|!c.is_ascii_alphabetic()).into()).or_default()+=1; } }
|
||||
let stages:std::collections::BTreeSet<String>=groups.keys().filter_map(|k|k.get(..3).map(|s|s.to_string())).collect();
|
||||
println!(" covers {} stages: {:?}", stages.len(), stages);
|
||||
println!(" sample S01_P1 group counts: {:?}", groups.iter().filter(|(k,_)|k.starts_with("S01_P1")).collect::<Vec<_>>());
|
||||
break;
|
||||
}
|
||||
|
||||
// 3. Resolve objective TEXT: search all pak entries for the key "S01_P1_Objective_00" as an ID with English text
|
||||
println!("\n=== OBJECTIVE TEXT resolution probe ===");
|
||||
for e in arc.entries(){
|
||||
let Ok(b)=arc.read(e) else{continue}; let Ok(o)=IdxdObject::parse(&b) else{continue};
|
||||
let t=o.tokens();
|
||||
if let Some(i)=t.iter().position(|s|s=="S01_P1_Objective_00"){
|
||||
let lo=i.saturating_sub(1); let hi=(i+3).min(t.len());
|
||||
println!(" schema {:08x}: ...{:?}...", o.schema_hash, &t[lo..hi]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
//! RE diagnostic: raw-dump a composite scene graph's node records — name, table
|
||||
//! pointers, and the FULL joint-table slot values (not just the 8 the decoder
|
||||
//! currently reads) — to derive the true TRS slot layout against captured
|
||||
//! ground truth.
|
||||
//! cargo run --release --example node_dump -- <Stage.xpr path> <composite name> [slots]
|
||||
use sylpheed_formats::mesh::xbg7_descriptor_range;
|
||||
|
||||
fn be32(d: &[u8], o: usize) -> u32 {
|
||||
if o + 4 > d.len() {
|
||||
return 0;
|
||||
}
|
||||
u32::from_be_bytes([d[o], d[o + 1], d[o + 2], d[o + 3]])
|
||||
}
|
||||
fn be_f64(d: &[u8], o: usize) -> f64 {
|
||||
if o + 8 > d.len() {
|
||||
return f64::NAN;
|
||||
}
|
||||
f64::from_be_bytes(d[o..o + 8].try_into().unwrap())
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).unwrap();
|
||||
let comp = &a[2];
|
||||
let nslots: usize = a.get(3).and_then(|s| s.parse().ok()).unwrap_or(12);
|
||||
let (desc, desc_end) = xbg7_descriptor_range(&bytes, comp).expect("composite found");
|
||||
let d = &bytes[desc..desc_end];
|
||||
println!("descriptor [{desc:#x}..{desc_end:#x}) len {:#x}", d.len());
|
||||
|
||||
let mut i = 0usize;
|
||||
while i + 3 <= d.len() {
|
||||
let starts = (i + 4 <= d.len() && &d[i..i + 4] == b"rou_")
|
||||
|| (i + 3 <= d.len() && &d[i..i + 3] == b"GN_");
|
||||
if !starts {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
let mut j = i;
|
||||
while j < d.len() && d[j] != 0 && d[j].is_ascii_graphic() {
|
||||
j += 1;
|
||||
}
|
||||
let name = std::str::from_utf8(&d[i..j]).unwrap_or("?").to_string();
|
||||
if name.ends_with("_col") || name.ends_with("_spc") || name.ends_with("_gls") || name.ends_with("_lum") {
|
||||
i = j.max(i + 1);
|
||||
continue;
|
||||
}
|
||||
// find the 0xFFFFFFFF end marker
|
||||
let mut ff = i;
|
||||
let scan_end = (i + 0x90).min(d.len().saturating_sub(4));
|
||||
while ff < scan_end && be32(d, ff) != 0xFFFF_FFFF {
|
||||
ff += 4;
|
||||
}
|
||||
if ff >= scan_end || ff < 0x10 {
|
||||
i = j.max(i + 1);
|
||||
continue;
|
||||
}
|
||||
let t44 = be32(d, ff - 0x10) as usize;
|
||||
let t48 = be32(d, ff - 0x0C) as usize;
|
||||
let child = be32(d, ff - 0x08) as usize;
|
||||
let sib = be32(d, ff - 0x04) as usize;
|
||||
// Dump the record's u32s between name end and marker for structure context.
|
||||
let rec_u32: Vec<String> = ((j + 1)..ff)
|
||||
.step_by(4)
|
||||
.map(|o| format!("{:08X}", be32(d, o)))
|
||||
.collect();
|
||||
println!("\nNODE {name} @{i:#x} ff@{ff:#x} t44={t44:#x} t48={t48:#x} child={child:#x} sib={sib:#x}");
|
||||
println!(" rec: {}", rec_u32.join(" "));
|
||||
if t44 != 0 && t44 < d.len() {
|
||||
// Joint table: nslots pointer slots. Each slot record appears to be a
|
||||
// keyframe track: a value ALSO sits 0x48 BEFORE the pointed address
|
||||
// (the rest-pose key A), while the decoder currently reads ptr+8 (B).
|
||||
for k in 0..nslots {
|
||||
let p = be32(d, t44 + k * 4) as usize;
|
||||
if p == 0 || p + 24 > d.len() {
|
||||
continue;
|
||||
}
|
||||
let a = if p >= 0x48 { be_f64(d, p - 0x48) } else { f64::NAN };
|
||||
let b = be_f64(d, p + 8);
|
||||
let head = if p >= 0x50 { be32(d, p - 0x50) } else { 0 };
|
||||
let t_a = if p >= 0x50 { be_f64(d, p - 0x50) } else { f64::NAN };
|
||||
let t_b = be_f64(d, p);
|
||||
println!(
|
||||
" slot{k:2} @{p:#x} head={head:08X}: A={a:12.5} (t={t_a:8.3}) B={b:12.5} (t={t_b:8.3})"
|
||||
);
|
||||
}
|
||||
}
|
||||
i = j.max(i + 1);
|
||||
}
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
//! Print a resource's first N decoded positions (buffer order), for matching a
|
||||
//! capture draw's `pos:` dump to a part:
|
||||
//! cargo run --release --example part_pos -- <xpr path> <resource> [n]
|
||||
use std::collections::HashSet;
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let bytes = std::fs::read(&a[1]).unwrap();
|
||||
let n: usize = a.get(3).and_then(|s| s.parse().ok()).unwrap_or(4);
|
||||
let want: HashSet<String> = [a[2].clone()].into();
|
||||
for m in Xbg7Model::models_named(&bytes, &want, &|| false) {
|
||||
let vc: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
print!("{} vtx={}:", m.name, vc);
|
||||
for p in m.meshes.iter().flat_map(|s| &s.positions).take(n) {
|
||||
print!(" ({:.4},{:.4},{:.4})", p[0], p[1], p[2]);
|
||||
}
|
||||
println!();
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
use sylpheed_formats::{hash::name_hash, movie_manifest, movie_voice, slb, PakArchive};
|
||||
use std::fs;use std::io::{Read,Seek,SeekFrom};use std::process::Command;
|
||||
fn rg(disc:&str,g:u64,n:usize)->Vec<u8>{let mut segs=vec![];let mut cum=0u64;for i in 0..5{let p=format!("{disc}/dat/sound.p{i:02}");if let Ok(m)=fs::metadata(&p){segs.push((cum,m.len(),p));cum+=m.len();}}let mut out=vec![];let(mut need,mut pos)=(n,g);for(base,len,path)in &segs{if need==0||pos>=base+len||pos<*base{continue;}let local=pos-base;let take=need.min((len-local)as usize);let mut f=fs::File::open(path).unwrap();f.seek(SeekFrom::Start(local)).unwrap();let mut b=vec![0u8;take];f.read_exact(&mut b).unwrap();out.extend_from_slice(&b);need-=take;pos+=take as u64;}out}
|
||||
fn contains(h:&[u8],n:&[u8])->bool{h.windows(n.len()).any(|w|w==n)}
|
||||
fn dur(w:&str)->String{let o=Command::new("ffprobe").args(["-v","error","-show_entries","format=duration","-of","default=nw=1:nk=1",w]).output().unwrap();String::from_utf8_lossy(&o.stdout).trim().to_string()}
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let tpak=PakArchive::open(format!("{disc}/dat/tables.pak")).unwrap();
|
||||
let manifest=tpak.entries().iter().find_map(|e|tpak.read(e).ok().filter(|b|movie_manifest::is_manifest(b))).unwrap();
|
||||
let code="eng";
|
||||
let registry=tpak.entries().iter().find_map(|e|tpak.read(e).ok().filter(|b|contains(b,format!("{code}\\Movie\\VOICE_ADV.slb").as_bytes()))).unwrap();
|
||||
let ids=movie_voice::registry_voice_ids(®istry);
|
||||
let stoc=fs::read(format!("{disc}/dat/sound.pak")).unwrap();
|
||||
let entries=PakArchive::parse_toc(&stoc).unwrap();
|
||||
for movie in ["ADV","RT01A","RT01B","RT01C_1","S00A","S01A","hokyu_LS_s02A","hokyu_LS_s09A","hokyu_LS_s02H","hokyu_DS_s07H"]{
|
||||
let Some(token)=movie_manifest::voice_token(&manifest,movie) else { println!("{movie:16} no token"); continue };
|
||||
let Some(&id)=ids.get(&token) else { println!("{movie:16} token {token} not in registry"); continue };
|
||||
let Some(anchor)=["Movie","etc","Voice"].iter().find_map(|d|{let h=name_hash(&format!("{code}\\{d}\\{token}.slb"));entries.binary_search_by_key(&h,|e|e.name_hash).ok().map(|i|entries[i].offset as u64)}) else { println!("{movie:16} no anchor for {token}"); continue };
|
||||
let win_start=(anchor.saturating_sub(2*1024*1024))&!3;
|
||||
let window=rg(&disc,win_start,8*1024*1024);
|
||||
let Some(end_local)=movie_voice::find_descriptor(&window,id) else { println!("{movie:16} id {id}: desc NOT FOUND"); continue };
|
||||
let end=win_start+end_local as u64;
|
||||
let start=movie_voice::find_descriptor(&window,id.wrapping_sub(1))
|
||||
.or_else(||movie_voice::find_descriptor_before(&window,end_local))
|
||||
.map(|o|win_start+o as u64)
|
||||
.filter(|&s|s<end && end-s<1_500_000)
|
||||
.unwrap_or(anchor);
|
||||
let region=rg(&disc,start,(end-start) as usize);
|
||||
let mut riffs=slb::to_xma_riffs(®ion);
|
||||
if riffs.is_empty(){ riffs=slb::to_xma_riff_best(®ion).into_iter().collect(); }
|
||||
let mut d="?".into();
|
||||
if let Some(r)=riffs.first(){ let xp=format!("/tmp/ra2_{movie}.xma.wav");let wp=format!("/tmp/ra2_{movie}.wav");fs::write(&xp,r).unwrap();let _=Command::new("ffmpeg").args(["-hide_banner","-v","error","-y","-i",&xp,&wp]).status();d=dur(&wp);}
|
||||
let mv=dur(&format!("{disc}/dat/movie/{movie}.wmv"));
|
||||
println!("{movie:16} id={id:5} region={}KB riffs={} voice={d}s movie={mv}s", (end-start)/1024, riffs.len());
|
||||
}
|
||||
}
|
||||
@@ -1,141 +0,0 @@
|
||||
//! Audit static ship assembly across ALL stages: flag parts placed far outside
|
||||
//! their ship's cluster (placement bugs) and joint tracks with more than one
|
||||
//! keyframe (which the single-key TRS read does not model).
|
||||
//! cargo run --release --example ship_audit -- <resource3d dir>
|
||||
use std::collections::HashSet;
|
||||
use sylpheed_formats::mesh::{xbg7_descriptor_range, xbg7_resource_names, Xbg7Model};
|
||||
use sylpheed_formats::ship::{assemble_ship, ships_in_container};
|
||||
|
||||
fn be32(d: &[u8], o: usize) -> u32 {
|
||||
if o + 4 > d.len() {
|
||||
return 0;
|
||||
}
|
||||
u32::from_be_bytes([d[o], d[o + 1], d[o + 2], d[o + 3]])
|
||||
}
|
||||
|
||||
/// Count joint-track records whose key count != 1 in a composite's descriptor.
|
||||
fn multikey_tracks(bytes: &[u8], comp: &str) -> usize {
|
||||
let Some((desc, desc_end)) = xbg7_descriptor_range(bytes, comp) else { return 0 };
|
||||
let d = &bytes[desc..desc_end];
|
||||
let mut n = 0usize;
|
||||
let mut i = 0usize;
|
||||
while i + 4 <= d.len() {
|
||||
let starts = &d[i..i.min(d.len() - 4) + 4] == b"rou_"
|
||||
|| (i + 3 <= d.len() && &d[i..i + 3] == b"GN_");
|
||||
if !starts {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
let mut j = i;
|
||||
while j < d.len() && d[j] != 0 && d[j].is_ascii_graphic() {
|
||||
j += 1;
|
||||
}
|
||||
let mut ff = i;
|
||||
let scan_end = (i + 0x90).min(d.len().saturating_sub(4));
|
||||
while ff < scan_end && be32(d, ff) != 0xFFFF_FFFF {
|
||||
ff += 4;
|
||||
}
|
||||
if ff < scan_end && ff >= 0x10 {
|
||||
let t44 = be32(d, ff - 0x10) as usize;
|
||||
if t44 != 0 && t44 + 32 <= d.len() {
|
||||
for k in 0..8 {
|
||||
let p = be32(d, t44 + k * 4) as usize;
|
||||
if p >= 0x50 && p + 16 <= d.len() {
|
||||
let head = be32(d, p - 0x50);
|
||||
if head != 1 && head != 0 {
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
i = j.max(i + 1);
|
||||
}
|
||||
n
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let dir = std::env::args().nth(1).unwrap();
|
||||
let mut entries: Vec<_> = std::fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.path())
|
||||
.filter(|p| {
|
||||
let n = p.file_name().unwrap_or_default().to_string_lossy().to_string();
|
||||
n.starts_with("Stage_") && n.ends_with(".xpr")
|
||||
})
|
||||
.collect();
|
||||
entries.sort();
|
||||
|
||||
for path in entries {
|
||||
let stage = path.file_name().unwrap().to_string_lossy().to_string();
|
||||
let bytes = std::fs::read(&path).unwrap();
|
||||
let names = xbg7_resource_names(&bytes);
|
||||
|
||||
// Multi-key animation tracks per composite (breaks the single-key read).
|
||||
for n in names.iter().filter(|n| n.contains("rou_") && !n.contains("break")) {
|
||||
let mk = multikey_tracks(&bytes, n);
|
||||
if mk > 0 {
|
||||
println!("MULTIKEY {stage} {n}: {mk} tracks");
|
||||
}
|
||||
}
|
||||
|
||||
for ship in ships_in_container(&bytes) {
|
||||
if ship.parts.len() < 2 {
|
||||
continue;
|
||||
}
|
||||
let placed = assemble_ship(&bytes, &ship.id, true);
|
||||
if placed.len() < 2 {
|
||||
continue;
|
||||
}
|
||||
let want: HashSet<String> = placed.iter().map(|p| p.resource.clone()).collect();
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
// Per-placement world centroid.
|
||||
let mut cents: Vec<(String, [f32; 3])> = Vec::new();
|
||||
for p in &placed {
|
||||
let Some(m) = models.iter().find(|m| m.name == p.resource) else { continue };
|
||||
let (mut c, mut n) = ([0.0f32; 3], 0f32);
|
||||
for sub in &m.meshes {
|
||||
for v in &sub.positions {
|
||||
let w = p.apply(*v);
|
||||
c[0] += w[0];
|
||||
c[1] += w[1];
|
||||
c[2] += w[2];
|
||||
n += 1.0;
|
||||
}
|
||||
}
|
||||
if n > 0.0 {
|
||||
cents.push((p.resource.clone(), [c[0] / n, c[1] / n, c[2] / n]));
|
||||
}
|
||||
}
|
||||
if cents.len() < 2 {
|
||||
continue;
|
||||
}
|
||||
// Ship cluster = median centroid; flag parts > 3× the median spread.
|
||||
let med = |k: usize| -> f32 {
|
||||
let mut v: Vec<f32> = cents.iter().map(|(_, c)| c[k]).collect();
|
||||
v.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
v[v.len() / 2]
|
||||
};
|
||||
let m = [med(0), med(1), med(2)];
|
||||
let dists: Vec<f32> = cents
|
||||
.iter()
|
||||
.map(|(_, c)| {
|
||||
((c[0] - m[0]).powi(2) + (c[1] - m[1]).powi(2) + (c[2] - m[2]).powi(2)).sqrt()
|
||||
})
|
||||
.collect();
|
||||
let mut sd: Vec<f32> = dists.clone();
|
||||
sd.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
let spread = sd[sd.len() / 2].max(50.0);
|
||||
for ((res, c), dist) in cents.iter().zip(&dists) {
|
||||
if *dist > 6.0 * spread && *dist > 800.0 {
|
||||
println!(
|
||||
"OUTLIER {stage} {}: {res} centroid=[{:.0} {:.0} {:.0}] dist={:.0} (spread {:.0})",
|
||||
ship.id, c[0], c[1], c[2], dist, spread
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("audit done");
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
//! Dump a ship's static placement + scene-graph nodes for a stage container FILE
|
||||
//! (works offline from an extracted disc, no ISO needed).
|
||||
//! cargo run --release --example ship_dump -- <Stage_SNN.xpr path> <ship_id>
|
||||
use sylpheed_formats::mesh::{scene_world_nodes, xbg7_resource_names, Xbg7Model};
|
||||
use sylpheed_formats::ship::{assemble_ship, is_base_part, ship_id_of};
|
||||
use std::collections::HashSet;
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let (path, id) = (&a[1], &a[2]);
|
||||
let bytes = std::fs::read(path).unwrap();
|
||||
let names = xbg7_resource_names(&bytes);
|
||||
|
||||
// Base parts + their vertex counts.
|
||||
let want: HashSet<String> = names.iter().filter(|n| is_base_part(n) && ship_id_of(n)==Some(id.as_str())).cloned().collect();
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
println!("== base parts ({}) ==", want.len());
|
||||
for m in &models {
|
||||
let vc: usize = m.meshes.iter().map(|s| s.positions.len()).sum();
|
||||
println!(" {:20} vtx={}", m.name, vc);
|
||||
}
|
||||
|
||||
// Composites present for this id.
|
||||
println!("== composites ==");
|
||||
for n in &names {
|
||||
if n.contains(&format!("rou_{id}")) && ship_id_of(n).is_none() {
|
||||
let nodes = scene_world_nodes(&bytes, n);
|
||||
println!(" {:24} {} nodes", n, nodes.len());
|
||||
}
|
||||
}
|
||||
|
||||
// assemble_ship result: centroids + extent.
|
||||
for ext in [false, true] {
|
||||
let placed = assemble_ship(&bytes, id, ext);
|
||||
println!("== assemble_ship(external={ext}) -> {} parts ==", placed.len());
|
||||
let mut lo=[f32::MAX;3]; let mut hi=[f32::MIN;3];
|
||||
for p in &placed {
|
||||
let src = models.iter().find(|m| m.name==p.resource);
|
||||
let (mut c, mut n) = ([0.0f32;3], 0f32);
|
||||
if let Some(src)=src { for sub in &src.meshes { for v in &sub.positions {
|
||||
let w=p.apply(*v); for k in 0..3 { c[k]+=w[k]; lo[k]=lo[k].min(w[k]); hi[k]=hi[k].max(w[k]); } n+=1.0; }}}
|
||||
let n=n.max(1.0);
|
||||
println!(" {:20} T=[{:8.1}{:8.1}{:8.1}] centroid=[{:8.1}{:8.1}{:8.1}]",
|
||||
p.resource, p.t[0],p.t[1],p.t[2], c[0]/n,c[1]/n,c[2]/n);
|
||||
}
|
||||
if placed.iter().any(|p| models.iter().any(|m| m.name==p.resource)) {
|
||||
println!(" EXTENT=[{:.0} {:.0} {:.0}]", hi[0]-lo[0], hi[1]-lo[1], hi[2]-lo[2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,141 +0,0 @@
|
||||
//! Diagnostic: assemble a ship from the BAKED capture table (or the static
|
||||
//! scene graph with --static) and render orthographic PNGs + print per-part
|
||||
//! world bounds, to see exactly what the viewer shows.
|
||||
//! cargo run --release --example ship_render -- <Stage_SNN.xpr path> <ship_id> <out_prefix> [--static]
|
||||
use std::collections::HashSet;
|
||||
use sylpheed_formats::mesh::{ScenePart, Xbg7Model};
|
||||
use sylpheed_formats::ship::assemble_ship;
|
||||
use sylpheed_formats::ship_capture::{embedded_placement, to_scene_parts};
|
||||
|
||||
fn main() {
|
||||
let a: Vec<String> = std::env::args().collect();
|
||||
let use_static = a.iter().any(|s| s == "--static");
|
||||
let (path, id, out) = (&a[1], &a[2], &a[3]);
|
||||
let bytes = std::fs::read(path).unwrap();
|
||||
|
||||
let placed: Vec<ScenePart> = if use_static {
|
||||
assemble_ship(&bytes, id, true)
|
||||
} else {
|
||||
let cap = embedded_placement(id).expect("ship not in baked table");
|
||||
to_scene_parts(&cap)
|
||||
};
|
||||
let want: HashSet<String> = placed.iter().map(|p| p.resource.clone()).collect();
|
||||
let models = Xbg7Model::models_named(&bytes, &want, &|| false);
|
||||
|
||||
// World triangles + per-part bounds.
|
||||
let mut tris: Vec<[[f32; 3]; 3]> = Vec::new();
|
||||
for p in &placed {
|
||||
let Some(m) = models.iter().find(|m| m.name == p.resource) else { continue };
|
||||
let mut lo = [f32::MAX; 3];
|
||||
let mut hi = [f32::MIN; 3];
|
||||
for sub in &m.meshes {
|
||||
let w: Vec<[f32; 3]> = sub.positions.iter().map(|v| p.apply(*v)).collect();
|
||||
for v in &w {
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(v[k]);
|
||||
hi[k] = hi[k].max(v[k]);
|
||||
}
|
||||
}
|
||||
for t in sub.indices.chunks_exact(3) {
|
||||
tris.push([w[t[0] as usize], w[t[1] as usize], w[t[2] as usize]]);
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"{:20} X[{:8.1},{:8.1}] Y[{:8.1},{:8.1}] Z[{:8.1},{:8.1}]",
|
||||
p.resource, lo[0], hi[0], lo[1], hi[1], lo[2], hi[2]
|
||||
);
|
||||
}
|
||||
// Exhaust cones at the GN_Jet/GN_SJet frames (the game's visible thrusters).
|
||||
for f in sylpheed_formats::ship::exhaust_frames(&bytes, id) {
|
||||
const SEG: usize = 12;
|
||||
let (r, len) = (22.0f32, 140.0f32);
|
||||
let ring: Vec<[f32; 3]> = (0..SEG)
|
||||
.map(|s| {
|
||||
let a = s as f32 / SEG as f32 * std::f32::consts::TAU;
|
||||
f.apply([a.cos() * r, a.sin() * r, 0.0])
|
||||
})
|
||||
.collect();
|
||||
let apex = f.apply([0.0, 0.0, len]);
|
||||
for s in 0..SEG {
|
||||
tris.push([apex, ring[(s + 1) % SEG], ring[s]]);
|
||||
}
|
||||
println!(" exhaust frame {:16} T=[{:8.1}{:8.1}{:8.1}]", f.resource, f.t[0], f.t[1], f.t[2]);
|
||||
}
|
||||
println!("total {} tris from {} placements", tris.len(), placed.len());
|
||||
|
||||
// Orthographic z-buffered flat renders: top (X/Z, look down −Y) and side (Z/Y, look down −X).
|
||||
for (name, ax, ay, az) in [("top", 0usize, 2usize, 1usize), ("side", 2usize, 1usize, 0usize)] {
|
||||
let size = 900usize;
|
||||
let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
|
||||
for t in &tris {
|
||||
for v in t {
|
||||
for k in 0..3 {
|
||||
lo[k] = lo[k].min(v[k]);
|
||||
hi[k] = hi[k].max(v[k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
let cx = (lo[ax] + hi[ax]) * 0.5;
|
||||
let cy = (lo[ay] + hi[ay]) * 0.5;
|
||||
let ext = (hi[ax] - lo[ax]).max(hi[ay] - lo[ay]) * 0.55;
|
||||
let scale = (size as f32 * 0.5) / ext;
|
||||
let mut img = vec![0u8; size * size * 3];
|
||||
let mut zbuf = vec![f32::MIN; size * size];
|
||||
for t in &tris {
|
||||
// screen coords
|
||||
let p: Vec<[f32; 3]> = t
|
||||
.iter()
|
||||
.map(|v| {
|
||||
[
|
||||
(v[ax] - cx) * scale + size as f32 * 0.5,
|
||||
(cy - v[ay]) * scale + size as f32 * 0.5,
|
||||
v[az],
|
||||
]
|
||||
})
|
||||
.collect();
|
||||
// flat shade by triangle normal Z-ish
|
||||
let e1 = [t[1][0] - t[0][0], t[1][1] - t[0][1], t[1][2] - t[0][2]];
|
||||
let e2 = [t[2][0] - t[0][0], t[2][1] - t[0][1], t[2][2] - t[0][2]];
|
||||
let n = [
|
||||
e1[1] * e2[2] - e1[2] * e2[1],
|
||||
e1[2] * e2[0] - e1[0] * e2[2],
|
||||
e1[0] * e2[1] - e1[1] * e2[0],
|
||||
];
|
||||
let nl = (n[0] * n[0] + n[1] * n[1] + n[2] * n[2]).sqrt().max(1e-6);
|
||||
let lum = (n[az].abs() / nl * 200.0 + 40.0) as u8;
|
||||
// bbox raster
|
||||
let minx = p.iter().map(|v| v[0]).fold(f32::MAX, f32::min).max(0.0) as usize;
|
||||
let maxx = (p.iter().map(|v| v[0]).fold(f32::MIN, f32::max).min(size as f32 - 1.0)) as usize;
|
||||
let miny = p.iter().map(|v| v[1]).fold(f32::MAX, f32::min).max(0.0) as usize;
|
||||
let maxy = (p.iter().map(|v| v[1]).fold(f32::MIN, f32::max).min(size as f32 - 1.0)) as usize;
|
||||
let det = (p[1][0] - p[0][0]) * (p[2][1] - p[0][1]) - (p[2][0] - p[0][0]) * (p[1][1] - p[0][1]);
|
||||
if det.abs() < 1e-6 {
|
||||
continue;
|
||||
}
|
||||
for y in miny..=maxy {
|
||||
for x in minx..=maxx {
|
||||
let (fx, fy) = (x as f32 + 0.5, y as f32 + 0.5);
|
||||
let w0 = ((p[1][0] - fx) * (p[2][1] - fy) - (p[2][0] - fx) * (p[1][1] - fy)) / det;
|
||||
let w1 = ((p[2][0] - fx) * (p[0][1] - fy) - (p[0][0] - fx) * (p[2][1] - fy)) / det;
|
||||
let w2 = 1.0 - w0 - w1;
|
||||
if w0 < 0.0 || w1 < 0.0 || w2 < 0.0 {
|
||||
continue;
|
||||
}
|
||||
let z = w0 * p[0][2] + w1 * p[1][2] + w2 * p[2][2];
|
||||
let idx = y * size + x;
|
||||
if z > zbuf[idx] {
|
||||
zbuf[idx] = z;
|
||||
img[idx * 3] = lum;
|
||||
img[idx * 3 + 1] = lum;
|
||||
img[idx * 3 + 2] = lum;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let file = format!("{out}_{name}.ppm");
|
||||
let mut ppm = format!("P6\n{size} {size}\n255\n").into_bytes();
|
||||
ppm.extend_from_slice(&img);
|
||||
std::fs::write(&file, ppm).unwrap();
|
||||
println!("wrote {file}");
|
||||
}
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
use sylpheed_formats::{idxd::IdxdObject, PakArchive};
|
||||
use std::collections::BTreeMap;
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let arc=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
// schemas whose type0/content is squadron/formation/route/group/position
|
||||
let mut hit:BTreeMap<u32,(u32,String,String)>=BTreeMap::new();
|
||||
for e in arc.entries(){
|
||||
let Ok(b)=arc.read(e) else{continue}; let Ok(o)=IdxdObject::parse(&b) else{continue};
|
||||
let t=o.tokens(); let t0=t.first().cloned().unwrap_or_default();
|
||||
let joined:String=t.iter().take(20).map(|s|s.as_str()).collect::<Vec<_>>().join(" ");
|
||||
if ["Squadron","Formation","Route","UnitGroup","Position","Spawn","Wave","Frame","NullFrame"].iter().any(|k|t0.contains(k)||joined.contains(k)){
|
||||
let ent=hit.entry(o.schema_hash).or_insert((0,t0.clone(),joined.chars().take(90).collect()));
|
||||
ent.0+=1;
|
||||
}
|
||||
}
|
||||
let mut v:Vec<_>=hit.into_iter().collect(); v.sort_by_key(|x|std::cmp::Reverse(x.1.0));
|
||||
for (s,(c,t0,sample)) in &v{ println!("[{s:08x}] ×{c:<4} type0={t0:<18.18} :: {sample}"); }
|
||||
// dump a Squadron/UnitGroup blob fully to see if it has positions (binary floats) or refs
|
||||
println!("\n─── sample squadron/formation blob (first matching) ───");
|
||||
for e in arc.entries(){
|
||||
let Ok(b)=arc.read(e) else{continue}; let Ok(o)=IdxdObject::parse(&b) else{continue};
|
||||
let t=o.tokens(); let t0=t.first().cloned().unwrap_or_default();
|
||||
if t0.contains("Squadron")||t0.contains("Formation")||t0.contains("UnitGroup"){
|
||||
println!("schema {:08x} type0={t0} count={} tokens={}, blob {}B", o.schema_hash,o.count,t.len(),b.len());
|
||||
for (i,tk) in t.iter().take(30).enumerate(){ print!("{i:>2}:{tk:<20.20}"); if i%4==3{println!();} } println!();
|
||||
// scan blob for float-like values (reasonable coords) in the binary region
|
||||
let nfloats=(0..b.len().saturating_sub(4)).step_by(4).filter(|&i|{let f=f32::from_be_bytes([b[i],b[i+1],b[i+2],b[i+3]]); f.is_finite()&&f.abs()>1.0&&f.abs()<1e6}).count();
|
||||
println!(" ~{nfloats} plausible BE-float words in blob (positions live in binary region if high)");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
use sylpheed_formats::{game_data, PakArchive};
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
let pak=PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).unwrap();
|
||||
let sq=game_data::load_squadrons(&pak);
|
||||
println!("{} squadron definitions", sq.len());
|
||||
for s in sq.iter().filter(|s|s.side.as_deref()==Some("TCAF")).take(6){
|
||||
let mem:Vec<String>=s.members.iter().map(|m|m.trim_start_matches("UN_").chars().take(18).collect()).collect();
|
||||
println!(" {:8} {:22} {:24} x{} {:?}", s.id.clone().unwrap_or("?".into()), s.formation_id.clone().unwrap_or_default(), s.ai_id.clone().unwrap_or_default(), s.count.unwrap_or(0), mem);
|
||||
}
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
use sylpheed_formats::slb;
|
||||
use std::fs;use std::io::{Read,Seek,SeekFrom};use std::process::Command;
|
||||
fn rg(disc:&str,g:u64,n:usize)->Vec<u8>{let mut segs=vec![];let mut cum=0u64;for i in 0..5{let p=format!("{disc}/dat/sound.p{i:02}");if let Ok(m)=fs::metadata(&p){segs.push((cum,m.len(),p));cum+=m.len();}}let mut out=vec![];let(mut need,mut pos)=(n,g);for(base,len,path)in &segs{if need==0||pos>=base+len||pos<*base{continue;}let local=pos-base;let take=need.min((len-local)as usize);let mut f=fs::File::open(path).unwrap();f.seek(SeekFrom::Start(local)).unwrap();let mut b=vec![0u8;take];f.read_exact(&mut b).unwrap();out.extend_from_slice(&b);need-=take;pos+=take as u64;}out}
|
||||
fn dur(w:&str)->String{let o=Command::new("ffprobe").args(["-v","error","-show_entries","format=duration:stream=channels","-of","default=nw=1:nk=1",w]).output().unwrap();String::from_utf8_lossy(&o.stdout).replace('\n'," ")}
|
||||
fn movdur(disc:&str,m:&str)->String{ dur(&format!("{disc}/dat/movie/{m}")) }
|
||||
fn main(){
|
||||
let disc=std::env::var("SYLPHEED_DISC").unwrap();
|
||||
// descriptor trailer global offsets (from scan) => cue N data = [desc(N-1)..desc(N)]
|
||||
// (id, end_off, movie)
|
||||
let cues=[(1600u32,437044592u64,"ADV.wmv"),(1601,437345648,"RT01A.wmv"),(1602,437712240,"RT01B.wmv"),
|
||||
(1603,438080880,"RT01C_1.wmv"),(1604,438451568,"RT01C_2.wmv"),(1605,438789488,"RT02A.wmv")];
|
||||
for k in 1..cues.len(){
|
||||
let (id,end,mov)=cues[k];
|
||||
let start=cues[k-1].1;
|
||||
let region=rg(&disc,start,(end-start) as usize + 12000); // +tail to include full data before next trailer
|
||||
let riffs=slb::to_xma_riffs(®ion);
|
||||
let mut total=0.0f32; let mut parts=vec![];
|
||||
for (j,r) in riffs.iter().enumerate(){
|
||||
let xp=format!("/tmp/cue{id}_{j}.xma.wav"); let wp=format!("/tmp/cue{id}_{j}.wav");
|
||||
fs::write(&xp,r).unwrap();
|
||||
let _=Command::new("ffmpeg").args(["-hide_banner","-v","error","-y","-i",&xp,&wp]).status();
|
||||
let d=dur(&wp); parts.push(d.clone());
|
||||
total+=d.split_whitespace().next().unwrap_or("0").parse::<f32>().unwrap_or(0.0);
|
||||
}
|
||||
// spanning?
|
||||
let span_adv_end=437547264u64;
|
||||
let spans = start < span_adv_end && end > span_adv_end || (start/1_000 != end/1_000);
|
||||
println!("cue {id} ({mov}): region[{start}..{end}] {} bytes, {} riff(s), Σ={:.1}s | movie={} parts={:?}",
|
||||
end-start, riffs.len(), total, movdur(&disc,mov), parts);
|
||||
}
|
||||
println!("\nWAVs at /tmp/cue16XX_*.wav (listen: RT01B=1602, RT01C_1=1603, RT01C_2=1604)");
|
||||
}
|
||||
@@ -1,85 +1,405 @@
|
||||
//! Audio format parsing — XMA and XWB handling.
|
||||
//! Audio format parsing — WAV/PCM decode + Xbox 360 XMA/XMA2 recognition.
|
||||
//!
|
||||
//! Xbox 360 games use **XMA** (Xbox Media Audio) as their primary audio codec.
|
||||
//! XMA is a proprietary Microsoft codec derived from WMA Pro.
|
||||
//! ## What the game actually ships
|
||||
//! Project Sylpheed's in-game audio lives in `dat/sound.pak` (IPFB): ~9500
|
||||
//! entries of **raw, header-less XMA2** stream data — no per-entry `RIFF`/`fmt `
|
||||
//! header, no compression wrapper (identical sound effects are byte-for-byte
|
||||
//! duplicate entries). The per-stream format (channel count, sample rate, loop
|
||||
//! points) is therefore **not** in the stream data; it lives in a separate
|
||||
//! sound-bank descriptor that has not been reverse engineered yet. So this
|
||||
//! module can *identify* those streams (and count their XMA packets) but cannot
|
||||
//! yet decode them to PCM — that needs (a) the bank descriptor and (b) an XMA2
|
||||
//! decoder.
|
||||
//!
|
||||
//! ## The Challenge
|
||||
//! XMA decoding requires Microsoft's proprietary XMA decoder, which is only
|
||||
//! available in the Windows DirectX runtime. There are two approaches:
|
||||
//! ## What this module does today
|
||||
//! - Fully parses **RIFF/WAVE PCM** (8/16/24-bit int, 32-bit float) → `GameAudio`
|
||||
//! (interleaved `f32`), ready for playback/export of any converted audio.
|
||||
//! - Reads metadata from **RIFF/WAVE XMA (`0x0165`) / XMA2 (`0x0166`)** headers
|
||||
//! (channels, sample rate) — decode still unsupported.
|
||||
//! - Recognizes **raw XMA2** stream blobs by entropy + packet alignment and
|
||||
//! reports the 2048-byte packet count.
|
||||
//!
|
||||
//! ### Option A: Convert on extraction (recommended for Milestone 1)
|
||||
//! Use `xma2encode.exe` (from Xbox 360 SDK) or `ffmpeg` (has partial XMA support)
|
||||
//! to pre-convert all audio to OGG/WAV during the extraction step.
|
||||
//!
|
||||
//! ```bash
|
||||
//! # Convert a single XMA file to WAV using ffmpeg
|
||||
//! ffmpeg -i audio.xma output.wav
|
||||
//!
|
||||
//! # Or use VGMStream's test.exe for more accurate XMA decoding
|
||||
//! ```
|
||||
//!
|
||||
//! ### Option B: XMA2 software decoder
|
||||
//! The `xma2dec` project provides an open-source XMA2 decoder.
|
||||
//! GitHub: https://github.com/koolkdev/xmalib (research-quality)
|
||||
//!
|
||||
//! ### XWB Wave Bank format
|
||||
//! Xbox 360 games typically bundle audio into XWB (Xbox Wave Bank) files.
|
||||
//! These are containers that hold multiple XMA streams.
|
||||
//! Reference: https://github.com/microsoft/DirectXTK/tree/main/Audio
|
||||
//! XMA framing constants are from xenia-canary `src/xenia/apu/xma_context.h`
|
||||
//! (`kBytesPerPacket = 2048`, `kSamplesPerFrame = 512`, `kBytesPerSample = 2`).
|
||||
|
||||
use thiserror::Error;
|
||||
|
||||
// XMA framing (xenia-canary xma_context.h).
|
||||
/// One XMA2 packet is 2048 bytes (4-byte header + 2044 bytes of frame data).
|
||||
pub const XMA_BYTES_PER_PACKET: usize = 2048;
|
||||
/// Decoded PCM samples produced per XMA frame, per channel.
|
||||
pub const XMA_SAMPLES_PER_FRAME: u32 = 512;
|
||||
|
||||
// WAVE format tags.
|
||||
const WAVE_FORMAT_PCM: u16 = 0x0001;
|
||||
const WAVE_FORMAT_IEEE_FLOAT: u16 = 0x0003;
|
||||
const WAVE_FORMAT_EXTENSIBLE: u16 = 0xFFFE;
|
||||
const WAVE_FORMAT_XMA: u16 = 0x0165;
|
||||
const WAVE_FORMAT_XMA2: u16 = 0x0166;
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum AudioError {
|
||||
#[error("Unknown audio format magic: {0:?}")]
|
||||
UnknownMagic([u8; 4]),
|
||||
#[error("XMA decoding requires pre-conversion. See audio.rs for instructions.")]
|
||||
XmaNotSupported,
|
||||
#[error("Parse error: {0}")]
|
||||
Parse(String),
|
||||
#[error("not a recognized audio container")]
|
||||
Unrecognized,
|
||||
#[error("malformed audio: {0}")]
|
||||
Malformed(&'static str),
|
||||
#[error("codec needs a decoder this crate does not provide: {0:?}")]
|
||||
NeedsDecoder(AudioCodec),
|
||||
#[error("unsupported PCM sample format: tag {tag:#06x}, {bits} bits")]
|
||||
UnsupportedPcm { tag: u16, bits: u16 },
|
||||
}
|
||||
|
||||
/// An audio clip decoded to raw PCM, ready for Bevy's audio system.
|
||||
/// Recognized audio container / codec.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum AudioCodec {
|
||||
/// RIFF/WAVE integer PCM (`WAVE_FORMAT_PCM`).
|
||||
Pcm,
|
||||
/// RIFF/WAVE IEEE-float PCM (`WAVE_FORMAT_IEEE_FLOAT`).
|
||||
PcmFloat,
|
||||
/// RIFF/WAVE XMA (`0x0165`).
|
||||
Xma,
|
||||
/// RIFF/WAVE XMA2 (`0x0166`).
|
||||
Xma2,
|
||||
/// Header-less XMA2 stream (the game's `sound.pak` entries), identified
|
||||
/// heuristically — no embedded channel/rate metadata.
|
||||
RawXma2,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
impl AudioCodec {
|
||||
/// Does decoding this codec require support this crate does not (yet) have?
|
||||
pub fn needs_decoder(&self) -> bool {
|
||||
matches!(self, Self::Xma | Self::Xma2 | Self::RawXma2)
|
||||
}
|
||||
|
||||
pub fn label(&self) -> &'static str {
|
||||
match self {
|
||||
Self::Pcm => "PCM",
|
||||
Self::PcmFloat => "PCM float",
|
||||
Self::Xma => "XMA (RIFF)",
|
||||
Self::Xma2 => "XMA2 (RIFF)",
|
||||
Self::RawXma2 => "XMA2 (raw stream)",
|
||||
Self::Unknown => "unknown",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Non-decoding metadata describing an audio blob.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct AudioInfo {
|
||||
pub codec: AudioCodec,
|
||||
pub channels: Option<u16>,
|
||||
pub sample_rate: Option<u32>,
|
||||
pub bits_per_sample: Option<u16>,
|
||||
/// PCM samples per channel, when derivable (WAV only).
|
||||
pub samples_per_channel: Option<u64>,
|
||||
pub duration_secs: Option<f32>,
|
||||
pub size_bytes: usize,
|
||||
/// 2048-byte XMA packet count, for XMA/raw-XMA streams.
|
||||
pub xma_packets: Option<u32>,
|
||||
}
|
||||
|
||||
impl AudioInfo {
|
||||
fn empty(codec: AudioCodec, size: usize) -> Self {
|
||||
Self {
|
||||
codec,
|
||||
channels: None,
|
||||
sample_rate: None,
|
||||
bits_per_sample: None,
|
||||
samples_per_channel: None,
|
||||
duration_secs: None,
|
||||
size_bytes: size,
|
||||
xma_packets: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Best-effort classification of an audio blob. Never fails: unrecognized
|
||||
/// input yields [`AudioCodec::Unknown`].
|
||||
///
|
||||
/// Order matters: a `RIFF/WAVE` header is authoritative; only header-less,
|
||||
/// high-entropy, packet-sized blobs fall through to the raw-XMA2 heuristic.
|
||||
pub fn probe(bytes: &[u8]) -> Self {
|
||||
if let Some(info) = parse_riff_wave(bytes) {
|
||||
return info;
|
||||
}
|
||||
if looks_like_raw_xma2(bytes) {
|
||||
let mut info = Self::empty(AudioCodec::RawXma2, bytes.len());
|
||||
info.xma_packets = Some(bytes.len().div_ceil(XMA_BYTES_PER_PACKET) as u32);
|
||||
return info;
|
||||
}
|
||||
Self::empty(AudioCodec::Unknown, bytes.len())
|
||||
}
|
||||
}
|
||||
|
||||
/// True when `bytes` is likely a raw, header-less XMA2 stream: no known audio
|
||||
/// magic, but a large, near-incompressible (high-entropy) payload — the shape
|
||||
/// of the game's `sound.pak` audio entries. Heuristic: not conclusive, but the
|
||||
/// probe runs only after every structured format has been ruled out.
|
||||
pub fn looks_like_raw_xma2(bytes: &[u8]) -> bool {
|
||||
// XMA streams are always at least a couple of packets long.
|
||||
if bytes.len() < XMA_BYTES_PER_PACKET * 2 {
|
||||
return false;
|
||||
}
|
||||
if bytes.starts_with(b"RIFF") || bytes.starts_with(b"XMA2") {
|
||||
return false; // handled by the RIFF path
|
||||
}
|
||||
shannon_entropy_bits(&bytes[..bytes.len().min(64 * 1024)]) >= 7.8
|
||||
}
|
||||
|
||||
/// Shannon entropy in bits/byte over `data` (0.0..=8.0). Compressed audio sits
|
||||
/// very close to 8; structured/text data is much lower.
|
||||
fn shannon_entropy_bits(data: &[u8]) -> f64 {
|
||||
if data.is_empty() {
|
||||
return 0.0;
|
||||
}
|
||||
let mut counts = [0u32; 256];
|
||||
for &b in data {
|
||||
counts[b as usize] += 1;
|
||||
}
|
||||
let n = data.len() as f64;
|
||||
counts
|
||||
.iter()
|
||||
.filter(|&&c| c > 0)
|
||||
.map(|&c| {
|
||||
let p = c as f64 / n;
|
||||
-p * p.log2()
|
||||
})
|
||||
.sum()
|
||||
}
|
||||
|
||||
// ── RIFF/WAVE ──────────────────────────────────────────────────────────────────
|
||||
|
||||
/// Parse a RIFF/WAVE header for metadata. Returns `None` if `bytes` is not a
|
||||
/// `RIFF....WAVE` container. All RIFF fields are little-endian.
|
||||
fn parse_riff_wave(bytes: &[u8]) -> Option<AudioInfo> {
|
||||
if bytes.len() < 12 || &bytes[..4] != b"RIFF" || &bytes[8..12] != b"WAVE" {
|
||||
return None;
|
||||
}
|
||||
let le16 = |o: usize| u16::from_le_bytes([bytes[o], bytes[o + 1]]);
|
||||
let le32 =
|
||||
|o: usize| u32::from_le_bytes([bytes[o], bytes[o + 1], bytes[o + 2], bytes[o + 3]]);
|
||||
|
||||
let mut pos = 12;
|
||||
let (mut tag, mut channels, mut rate, mut bits) = (0u16, 0u16, 0u32, 0u16);
|
||||
let mut data_bytes: Option<u64> = None;
|
||||
let mut have_fmt = false;
|
||||
|
||||
while pos + 8 <= bytes.len() {
|
||||
let id = &bytes[pos..pos + 4];
|
||||
let size = le32(pos + 4) as usize;
|
||||
let body = pos + 8;
|
||||
match id {
|
||||
b"fmt " if body + 16 <= bytes.len() => {
|
||||
tag = le16(body);
|
||||
channels = le16(body + 2);
|
||||
rate = le32(body + 4);
|
||||
bits = le16(body + 14);
|
||||
// WAVE_FORMAT_EXTENSIBLE stores the real tag in the GUID's first
|
||||
// two bytes, right after cbSize (+2) → +24 from the fmt body.
|
||||
if tag == WAVE_FORMAT_EXTENSIBLE && body + 26 <= bytes.len() {
|
||||
tag = le16(body + 24);
|
||||
}
|
||||
have_fmt = true;
|
||||
}
|
||||
b"data" => data_bytes = Some(size as u64),
|
||||
_ => {}
|
||||
}
|
||||
// Chunks are word-aligned (pad byte when size is odd).
|
||||
pos = body + size + (size & 1);
|
||||
}
|
||||
if !have_fmt {
|
||||
return None;
|
||||
}
|
||||
|
||||
let codec = match tag {
|
||||
WAVE_FORMAT_PCM => AudioCodec::Pcm,
|
||||
WAVE_FORMAT_IEEE_FLOAT => AudioCodec::PcmFloat,
|
||||
WAVE_FORMAT_XMA => AudioCodec::Xma,
|
||||
WAVE_FORMAT_XMA2 => AudioCodec::Xma2,
|
||||
_ => AudioCodec::Unknown,
|
||||
};
|
||||
let mut info = AudioInfo::empty(codec, bytes.len());
|
||||
info.channels = Some(channels).filter(|&c| c > 0);
|
||||
info.sample_rate = Some(rate).filter(|&r| r > 0);
|
||||
info.bits_per_sample = Some(bits).filter(|&b| b > 0);
|
||||
|
||||
match codec {
|
||||
AudioCodec::Pcm | AudioCodec::PcmFloat => {
|
||||
if let (Some(d), true) = (data_bytes, channels > 0 && bits > 0) {
|
||||
let frame = channels as u64 * (bits as u64 / 8);
|
||||
if frame > 0 {
|
||||
let spc = d / frame;
|
||||
info.samples_per_channel = Some(spc);
|
||||
if rate > 0 {
|
||||
info.duration_secs = Some(spc as f32 / rate as f32);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
AudioCodec::Xma | AudioCodec::Xma2 => {
|
||||
if let Some(d) = data_bytes {
|
||||
info.xma_packets = Some((d / XMA_BYTES_PER_PACKET as u64) as u32);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
Some(info)
|
||||
}
|
||||
|
||||
// ── PCM decode → GameAudio ─────────────────────────────────────────────────────
|
||||
|
||||
/// An audio clip decoded to raw interleaved `f32` PCM (`L R L R …`).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct GameAudio {
|
||||
/// Raw PCM samples (interleaved for stereo: L R L R ...)
|
||||
pub samples: Vec<f32>,
|
||||
pub channels: u16,
|
||||
pub sample_rate: u32,
|
||||
}
|
||||
|
||||
impl GameAudio {
|
||||
/// Parse audio from raw bytes.
|
||||
///
|
||||
/// Currently only WAV/PCM is supported. For XMA files, pre-convert using:
|
||||
/// `ffmpeg -i file.xma file.wav`
|
||||
pub fn from_bytes(bytes: &[u8]) -> Result<Self, AudioError> {
|
||||
// Check for WAV magic
|
||||
if bytes.len() >= 4 && &bytes[..4] == b"RIFF" {
|
||||
return Self::from_wav(bytes);
|
||||
/// Decode a RIFF/WAVE **PCM** file (int 8/16/24-bit or 32-bit float) to
|
||||
/// interleaved `f32`. XMA/XMA2 return [`AudioError::NeedsDecoder`].
|
||||
pub fn from_wav(bytes: &[u8]) -> Result<Self, AudioError> {
|
||||
let info = parse_riff_wave(bytes).ok_or(AudioError::Unrecognized)?;
|
||||
if info.codec.needs_decoder() {
|
||||
return Err(AudioError::NeedsDecoder(info.codec));
|
||||
}
|
||||
let channels = info.channels.ok_or(AudioError::Malformed("no channels"))?;
|
||||
let rate = info.sample_rate.ok_or(AudioError::Malformed("no sample rate"))?;
|
||||
let bits = info.bits_per_sample.ok_or(AudioError::Malformed("no bit depth"))?;
|
||||
|
||||
// XMA magic bytes
|
||||
if bytes.len() >= 4 && (
|
||||
&bytes[..4] == b"XWB\0" || // Wave bank
|
||||
&bytes[..4] == b"XMA2" // Raw XMA2
|
||||
) {
|
||||
return Err(AudioError::XmaNotSupported);
|
||||
}
|
||||
// Locate the `data` chunk body.
|
||||
let (off, len) = riff_data_span(bytes).ok_or(AudioError::Malformed("no data chunk"))?;
|
||||
let data = &bytes[off..off + len];
|
||||
|
||||
Err(AudioError::UnknownMagic(
|
||||
bytes[..4.min(bytes.len())].try_into().unwrap_or([0u8; 4])
|
||||
))
|
||||
}
|
||||
|
||||
fn from_wav(bytes: &[u8]) -> Result<Self, AudioError> {
|
||||
// Minimal WAV parser for PCM files
|
||||
// A proper implementation should use the `hound` crate:
|
||||
// https://crates.io/crates/hound
|
||||
//
|
||||
// TODO: Add `hound = "3"` to Cargo.toml and implement properly
|
||||
Err(AudioError::Parse(
|
||||
"WAV parsing TODO: add `hound` crate and implement".to_string()
|
||||
))
|
||||
let samples: Vec<f32> = match (info.codec, bits) {
|
||||
(AudioCodec::Pcm, 8) => data.iter().map(|&b| (b as f32 - 128.0) / 128.0).collect(),
|
||||
(AudioCodec::Pcm, 16) => data
|
||||
.chunks_exact(2)
|
||||
.map(|c| i16::from_le_bytes([c[0], c[1]]) as f32 / 32768.0)
|
||||
.collect(),
|
||||
(AudioCodec::Pcm, 24) => data
|
||||
.chunks_exact(3)
|
||||
.map(|c| {
|
||||
let v = ((c[2] as i32) << 16) | ((c[1] as i32) << 8) | c[0] as i32;
|
||||
let v = (v << 8) >> 8; // sign-extend 24→32
|
||||
v as f32 / 8_388_608.0
|
||||
})
|
||||
.collect(),
|
||||
(AudioCodec::PcmFloat, 32) => data
|
||||
.chunks_exact(4)
|
||||
.map(|c| f32::from_le_bytes([c[0], c[1], c[2], c[3]]))
|
||||
.collect(),
|
||||
_ => return Err(AudioError::UnsupportedPcm { tag: 0, bits }),
|
||||
};
|
||||
Ok(Self { samples, channels, sample_rate: rate })
|
||||
}
|
||||
}
|
||||
|
||||
/// Byte span (offset, length) of the WAVE `data` chunk body, if present.
|
||||
fn riff_data_span(bytes: &[u8]) -> Option<(usize, usize)> {
|
||||
if bytes.len() < 12 || &bytes[..4] != b"RIFF" || &bytes[8..12] != b"WAVE" {
|
||||
return None;
|
||||
}
|
||||
let le32 =
|
||||
|o: usize| u32::from_le_bytes([bytes[o], bytes[o + 1], bytes[o + 2], bytes[o + 3]]) as usize;
|
||||
let mut pos = 12;
|
||||
while pos + 8 <= bytes.len() {
|
||||
let size = le32(pos + 4);
|
||||
let body = pos + 8;
|
||||
if &bytes[pos..pos + 4] == b"data" {
|
||||
let len = size.min(bytes.len().saturating_sub(body));
|
||||
return Some((body, len));
|
||||
}
|
||||
pos = body + size + (size & 1);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Build a minimal 16-bit PCM WAV in memory (stereo, 2 frames).
|
||||
fn tiny_wav() -> Vec<u8> {
|
||||
let mut v = Vec::new();
|
||||
let data: [i16; 4] = [1000, -1000, 32767, -32768]; // L R L R
|
||||
let data_bytes: Vec<u8> = data.iter().flat_map(|s| s.to_le_bytes()).collect();
|
||||
v.extend_from_slice(b"RIFF");
|
||||
v.extend_from_slice(&(36 + data_bytes.len() as u32).to_le_bytes());
|
||||
v.extend_from_slice(b"WAVE");
|
||||
v.extend_from_slice(b"fmt ");
|
||||
v.extend_from_slice(&16u32.to_le_bytes());
|
||||
v.extend_from_slice(&WAVE_FORMAT_PCM.to_le_bytes());
|
||||
v.extend_from_slice(&2u16.to_le_bytes()); // channels
|
||||
v.extend_from_slice(&48000u32.to_le_bytes());
|
||||
v.extend_from_slice(&(48000u32 * 2 * 2).to_le_bytes());
|
||||
v.extend_from_slice(&4u16.to_le_bytes()); // block align
|
||||
v.extend_from_slice(&16u16.to_le_bytes()); // bits
|
||||
v.extend_from_slice(b"data");
|
||||
v.extend_from_slice(&(data_bytes.len() as u32).to_le_bytes());
|
||||
v.extend_from_slice(&data_bytes);
|
||||
v
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn probe_and_decode_pcm_wav() {
|
||||
let wav = tiny_wav();
|
||||
let info = AudioInfo::probe(&wav);
|
||||
assert_eq!(info.codec, AudioCodec::Pcm);
|
||||
assert_eq!(info.channels, Some(2));
|
||||
assert_eq!(info.sample_rate, Some(48000));
|
||||
assert_eq!(info.samples_per_channel, Some(2));
|
||||
let audio = GameAudio::from_wav(&wav).unwrap();
|
||||
assert_eq!(audio.channels, 2);
|
||||
assert_eq!(audio.samples.len(), 4);
|
||||
assert!((audio.samples[2] - 0.99997).abs() < 1e-3); // 32767/32768
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn probe_xma2_riff_reports_metadata_not_decode() {
|
||||
// Minimal RIFF/WAVE with an XMA2 fmt tag.
|
||||
let mut v = Vec::new();
|
||||
v.extend_from_slice(b"RIFF");
|
||||
v.extend_from_slice(&200u32.to_le_bytes());
|
||||
v.extend_from_slice(b"WAVE");
|
||||
v.extend_from_slice(b"fmt ");
|
||||
v.extend_from_slice(&16u32.to_le_bytes());
|
||||
v.extend_from_slice(&WAVE_FORMAT_XMA2.to_le_bytes());
|
||||
v.extend_from_slice(&2u16.to_le_bytes());
|
||||
v.extend_from_slice(&44100u32.to_le_bytes());
|
||||
v.extend_from_slice(&0u32.to_le_bytes());
|
||||
v.extend_from_slice(&0u16.to_le_bytes());
|
||||
v.extend_from_slice(&0u16.to_le_bytes());
|
||||
let info = AudioInfo::probe(&v);
|
||||
assert_eq!(info.codec, AudioCodec::Xma2);
|
||||
assert_eq!(info.channels, Some(2));
|
||||
assert!(info.codec.needs_decoder());
|
||||
assert!(matches!(
|
||||
GameAudio::from_wav(&v),
|
||||
Err(AudioError::NeedsDecoder(AudioCodec::Xma2))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn raw_high_entropy_blob_reads_as_raw_xma2() {
|
||||
// A pseudo-random 8 KB blob (no magic) → RawXma2 with a packet count.
|
||||
let mut b = vec![0u8; 8192];
|
||||
let mut x = 0x2545_F491u32;
|
||||
for v in b.iter_mut() {
|
||||
x ^= x << 13;
|
||||
x ^= x >> 17;
|
||||
x ^= x << 5;
|
||||
*v = (x & 0xFF) as u8;
|
||||
}
|
||||
let info = AudioInfo::probe(&b);
|
||||
assert_eq!(info.codec, AudioCodec::RawXma2);
|
||||
assert_eq!(info.xma_packets, Some(4)); // 8192 / 2048
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structured_low_entropy_blob_is_unknown_not_audio() {
|
||||
let b = b"IDXD............a bunch of readable ASCII text fields....".repeat(40);
|
||||
assert_eq!(AudioInfo::probe(&b).codec, AudioCodec::Unknown);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,980 +0,0 @@
|
||||
//! Typed loaders for Project Sylpheed's combat data tables.
|
||||
//!
|
||||
//! The game keeps its balance data in reflective [`crate::idxd`] tables — one
|
||||
//! blob per entity, `token[0]` naming the table, fields laid out value-before-key.
|
||||
//! This module maps the four combat schemas to plain, cloneable structs: the
|
||||
//! common stats as named `Option<…>` fields, and **every** explicitly-set field in
|
||||
//! a [`fields`](Weapon::fields) map so nothing is lost.
|
||||
//!
|
||||
//! Reverse-engineered 2026-07-23 from `GP_MAIN_GAME_E.pak` (English; the D/F/I/J/S
|
||||
//! paks are localized duplicates). Fields left at their default value omit their
|
||||
//! value on disc — those live in title code, not here — so a `None` means "not set
|
||||
//! on disc", never a guess.
|
||||
//!
|
||||
//! ```no_run
|
||||
//! use sylpheed_formats::{game_data, PakArchive};
|
||||
//! let pak = PakArchive::open("dat/GP_MAIN_GAME_E.pak").unwrap();
|
||||
//! for w in game_data::load_weapons(&pak) {
|
||||
//! println!("{} — power {:?}, range {:?}", w.id.unwrap_or_default(), w.power, w.max_range);
|
||||
//! }
|
||||
//! ```
|
||||
|
||||
use crate::idxd::IdxdObject;
|
||||
use crate::pak::PakArchive;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// IDXD schema ids of the combat tables (the `schema_hash` field of each blob).
|
||||
pub mod schema {
|
||||
/// Player craft config: physics, cameras, scoring, difficulty, render pipeline.
|
||||
pub const PLAYER: u32 = 0x0426_e81d;
|
||||
/// Weapon definitions (guns, missiles, beams, bombs).
|
||||
pub const WEAPON: u32 = 0x6ab4_825a;
|
||||
/// Craft / units — fighters, bombers, turrets, with their AI flight model.
|
||||
pub const UNIT: u32 = 0x43fa_a517;
|
||||
/// Vessels — capital ships, with structural component counts.
|
||||
pub const VESSEL: u32 = 0x3c5b_0549;
|
||||
/// Characters — pilots / crew / comms, with faction and portrait set.
|
||||
pub const CHARACTER: u32 = 0xbd86_d41c;
|
||||
/// Stage resource manifest — per mission: location, phases, resource tables.
|
||||
pub const STAGE: u32 = 0x3c9a_e32e;
|
||||
/// Message / demo dialogue — per line: speaker, portrait, voice clip, pages.
|
||||
pub const MESSAGE: u32 = 0xb412_e6d8;
|
||||
}
|
||||
|
||||
/// Parse a numeric field value, tolerating a trailing `f`/`F` (e.g. `"3.0f"`).
|
||||
fn as_f32(v: Option<&String>) -> Option<f32> {
|
||||
let v = v?;
|
||||
let v = v.strip_suffix(['f', 'F']).unwrap_or(v);
|
||||
v.parse().ok()
|
||||
}
|
||||
|
||||
fn as_i64(v: Option<&String>) -> Option<i64> {
|
||||
v?.parse().ok()
|
||||
}
|
||||
|
||||
/// Collect every explicitly-set field of an IDXD blob into a `key → value` map,
|
||||
/// plus the identity strings. Identifier-valued fields (`Model`, `ShotType`, …)
|
||||
/// that carry a bare name rather than a value are not in the map — read those from
|
||||
/// [`IdxdObject::get_raw`] if needed.
|
||||
fn field_map(o: &IdxdObject) -> BTreeMap<String, String> {
|
||||
o.resolved_fields()
|
||||
.into_iter()
|
||||
.map(|(k, v)| (k.to_string(), v.to_string()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Read every record of `schema` from a pak, mapping each with `build`.
|
||||
fn load_table<T>(pak: &PakArchive, schema: u32, build: impl Fn(&IdxdObject) -> Option<T>) -> Vec<T> {
|
||||
pak.entries()
|
||||
.iter()
|
||||
.filter_map(|e| pak.read(e).ok())
|
||||
.filter_map(|b| IdxdObject::parse(&b).ok())
|
||||
.filter(|o| o.schema_hash == schema)
|
||||
.filter_map(|o| build(&o))
|
||||
.collect()
|
||||
}
|
||||
|
||||
// ── Weapon ────────────────────────────────────────────────────────────────────
|
||||
|
||||
/// A weapon definition (schema [`schema::WEAPON`]).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Weapon {
|
||||
pub id: Option<String>,
|
||||
pub name: Option<String>,
|
||||
/// Target mask, e.g. `"Vessel,Craft,Structure"`.
|
||||
pub target_type: Option<String>,
|
||||
pub power: Option<f32>,
|
||||
pub velocity: Option<f32>,
|
||||
pub min_velocity: Option<f32>,
|
||||
pub max_velocity: Option<f32>,
|
||||
pub min_range: Option<f32>,
|
||||
pub max_range: Option<f32>,
|
||||
/// Ammo / reload budget (`LoadingCount`).
|
||||
pub loading_count: Option<i64>,
|
||||
/// Seconds between shots.
|
||||
pub interval: Option<f32>,
|
||||
/// Shots per trigger pull (volley / lock count).
|
||||
pub trigger_shot_count: Option<i64>,
|
||||
pub mass: Option<f32>,
|
||||
pub heating: Option<f32>,
|
||||
pub cooling: Option<f32>,
|
||||
pub life_time: Option<f32>,
|
||||
/// All explicitly-set fields (a superset of the named ones above).
|
||||
pub fields: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl Weapon {
|
||||
fn from_idxd(o: &IdxdObject) -> Option<Self> {
|
||||
let f = field_map(o);
|
||||
Some(Weapon {
|
||||
id: o.get_raw("ID").map(str::to_string),
|
||||
name: o.get_raw("Name").map(str::to_string),
|
||||
target_type: o.get_raw("TargetType").map(str::to_string),
|
||||
power: as_f32(f.get("Power")),
|
||||
velocity: as_f32(f.get("Velocity")),
|
||||
min_velocity: as_f32(f.get("MinimumVelocity")),
|
||||
max_velocity: as_f32(f.get("MaximumVelocity")),
|
||||
min_range: as_f32(f.get("MinimumRange")),
|
||||
max_range: as_f32(f.get("MaximumRange")),
|
||||
loading_count: as_i64(f.get("LoadingCount")),
|
||||
interval: as_f32(f.get("Interval")),
|
||||
trigger_shot_count: as_i64(f.get("TriggerShotCount")),
|
||||
mass: as_f32(f.get("Mass")),
|
||||
heating: as_f32(f.get("Heating")),
|
||||
cooling: as_f32(f.get("Cooling")),
|
||||
life_time: as_f32(f.get("LifeTime")),
|
||||
fields: f,
|
||||
})
|
||||
}
|
||||
/// Any explicit field parsed as `f32` (for the long-tail stats not named above).
|
||||
pub fn field_f32(&self, key: &str) -> Option<f32> {
|
||||
as_f32(self.fields.get(key))
|
||||
}
|
||||
}
|
||||
|
||||
/// Load every weapon from a pak. Catches all `Weapon`-shaped records, not just the
|
||||
/// main [`schema::WEAPON`] — player special/missile weapons live in variant schemas
|
||||
/// (e.g. `Weapon_DSaber_P_wep_*` in `GP_HANGAR_ARSENAL.pak`). Deduplicated by id.
|
||||
pub fn load_weapons(pak: &PakArchive) -> Vec<Weapon> {
|
||||
let mut seen = std::collections::BTreeSet::new();
|
||||
let mut out = Vec::new();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
// `Weapon`/`QWeapon`/… but not the `EnumWeapon` name lists.
|
||||
let t0 = o.tokens().first().map(String::as_str).unwrap_or("");
|
||||
if !t0.ends_with("Weapon") || t0.contains("Enum") {
|
||||
continue;
|
||||
}
|
||||
if let Some(w) = Weapon::from_idxd(&o) {
|
||||
if w.id.as_deref().is_some_and(|id| seen.insert(id.to_string())) {
|
||||
out.push(w);
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ── Craft / unit ────────────────────────────────────────────────────────────────
|
||||
|
||||
/// A craft / unit — fighter, bomber, turret (schema [`schema::UNIT`]). Carries the
|
||||
/// AI flight model in [`fields`](CraftUnit::fields) (`AV_Pitch*`, `BarrelRoll_*`,
|
||||
/// `TurnAttack_*`, …).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct CraftUnit {
|
||||
pub id: Option<String>,
|
||||
pub name: Option<String>,
|
||||
pub hp: Option<f32>,
|
||||
pub is_destructible: Option<bool>,
|
||||
pub size_x: Option<f32>,
|
||||
pub size_y: Option<f32>,
|
||||
pub size_z: Option<f32>,
|
||||
pub size_radius: Option<f32>,
|
||||
pub radar_range: Option<f32>,
|
||||
pub fcs_range: Option<f32>,
|
||||
pub cruising_velocity: Option<f32>,
|
||||
pub maximum_velocity: Option<f32>,
|
||||
pub acceleration: Option<f32>,
|
||||
pub deceleration: Option<f32>,
|
||||
pub shield_ratio: Option<f32>,
|
||||
pub turret_count: Option<i64>,
|
||||
pub score_point: Option<i64>,
|
||||
pub fields: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl CraftUnit {
|
||||
fn from_idxd(o: &IdxdObject) -> Option<Self> {
|
||||
let f = field_map(o);
|
||||
Some(CraftUnit {
|
||||
id: o.get_raw("ID").map(str::to_string),
|
||||
name: o.get_raw("Name").map(str::to_string),
|
||||
hp: as_f32(f.get("HP")),
|
||||
is_destructible: o.get_bool("IsDestructible"),
|
||||
size_x: as_f32(f.get("Size_X")),
|
||||
size_y: as_f32(f.get("Size_Y")),
|
||||
size_z: as_f32(f.get("Size_Z")),
|
||||
size_radius: as_f32(f.get("Size_Radius")),
|
||||
radar_range: as_f32(f.get("RadarRange")),
|
||||
fcs_range: as_f32(f.get("FCSRange")),
|
||||
cruising_velocity: as_f32(f.get("CruisingVelocity")),
|
||||
maximum_velocity: as_f32(f.get("MaximumVelocity")),
|
||||
acceleration: as_f32(f.get("Acceleration")),
|
||||
deceleration: as_f32(f.get("Deceleration")),
|
||||
shield_ratio: as_f32(f.get("ShieldRatio")),
|
||||
turret_count: as_i64(f.get("TurretCount")),
|
||||
score_point: as_i64(f.get("ScorePoint")),
|
||||
fields: f,
|
||||
})
|
||||
}
|
||||
pub fn field_f32(&self, key: &str) -> Option<f32> {
|
||||
as_f32(self.fields.get(key))
|
||||
}
|
||||
}
|
||||
|
||||
/// Load every craft / unit from a pak.
|
||||
pub fn load_units(pak: &PakArchive) -> Vec<CraftUnit> {
|
||||
load_table(pak, schema::UNIT, CraftUnit::from_idxd)
|
||||
}
|
||||
|
||||
// ── Vessel / capital ship ───────────────────────────────────────────────────────
|
||||
|
||||
/// A capital ship (schema [`schema::VESSEL`]). Component counts drive the
|
||||
/// destructible hardpoints.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Vessel {
|
||||
pub id: Option<String>,
|
||||
pub name: Option<String>,
|
||||
/// The 3D hull resource stem, e.g. `rou_e105` — the `eNNN`/`fNNN` id links to
|
||||
/// the XBG7 part family (`e105_bdy_*`, `e105_brg_*`, …) inside a `Stage_SNN.xpr`.
|
||||
pub model: Option<String>,
|
||||
pub hp: Option<f32>,
|
||||
pub size_x: Option<f32>,
|
||||
pub size_y: Option<f32>,
|
||||
pub size_z: Option<f32>,
|
||||
pub radar_range: Option<f32>,
|
||||
pub fcs_range: Option<f32>,
|
||||
pub maximum_velocity: Option<f32>,
|
||||
pub shield_ratio: Option<f32>,
|
||||
pub score_point: Option<i64>,
|
||||
pub turret_count: Option<i64>,
|
||||
pub bridge_count: Option<i64>,
|
||||
pub hatch_count: Option<i64>,
|
||||
pub shield_generator_count: Option<i64>,
|
||||
pub thruster_count: Option<i64>,
|
||||
pub fields: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl Vessel {
|
||||
fn from_idxd(o: &IdxdObject) -> Option<Self> {
|
||||
let f = field_map(o);
|
||||
Some(Vessel {
|
||||
id: o.get_raw("ID").map(str::to_string),
|
||||
name: o.get_raw("Name").map(str::to_string),
|
||||
model: o.get_raw("Model").map(str::to_string),
|
||||
hp: as_f32(f.get("HP")),
|
||||
size_x: as_f32(f.get("Size_X")),
|
||||
size_y: as_f32(f.get("Size_Y")),
|
||||
size_z: as_f32(f.get("Size_Z")),
|
||||
radar_range: as_f32(f.get("RadarRange")),
|
||||
fcs_range: as_f32(f.get("FCSRange")),
|
||||
maximum_velocity: as_f32(f.get("MaximumVelocity")),
|
||||
shield_ratio: as_f32(f.get("ShieldRatio")),
|
||||
score_point: as_i64(f.get("ScorePoint")),
|
||||
turret_count: as_i64(f.get("TurretCount")),
|
||||
bridge_count: as_i64(f.get("BridgeCount")),
|
||||
hatch_count: as_i64(f.get("HatchCount")),
|
||||
shield_generator_count: as_i64(f.get("ShieldGeneratorCount")),
|
||||
thruster_count: as_i64(f.get("ThrusterCount")),
|
||||
fields: f,
|
||||
})
|
||||
}
|
||||
pub fn field_f32(&self, key: &str) -> Option<f32> {
|
||||
as_f32(self.fields.get(key))
|
||||
}
|
||||
}
|
||||
|
||||
/// Load every capital ship from a pak.
|
||||
pub fn load_vessels(pak: &PakArchive) -> Vec<Vessel> {
|
||||
load_table(pak, schema::VESSEL, Vessel::from_idxd)
|
||||
}
|
||||
|
||||
// ── Player config ───────────────────────────────────────────────────────────────
|
||||
|
||||
/// Player craft config (schema [`schema::PLAYER`]) — one per mission. Physics,
|
||||
/// projectile caps and scoring here; cameras, difficulty and the render pipeline
|
||||
/// live in [`fields`](PlayerConfig::fields).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct PlayerConfig {
|
||||
pub air_drag_factor: Option<f32>,
|
||||
pub gravity_factor: Option<f32>,
|
||||
pub bullet_limit: Option<i64>,
|
||||
pub laser_limit: Option<i64>,
|
||||
pub homing_limit: Option<i64>,
|
||||
pub space_size: Option<f32>,
|
||||
pub supply_range: Option<f32>,
|
||||
pub main_mission_bonus: Option<i64>,
|
||||
pub rank_score_s: Option<i64>,
|
||||
pub rank_score_a: Option<i64>,
|
||||
pub rank_score_b: Option<i64>,
|
||||
pub rank_score_c: Option<i64>,
|
||||
pub rank_score_d: Option<i64>,
|
||||
pub fields: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl PlayerConfig {
|
||||
fn from_idxd(o: &IdxdObject) -> Option<Self> {
|
||||
let f = field_map(o);
|
||||
Some(PlayerConfig {
|
||||
air_drag_factor: as_f32(f.get("AirDragFactor")),
|
||||
gravity_factor: as_f32(f.get("GravityFactor")),
|
||||
bullet_limit: as_i64(f.get("BulletLimit")),
|
||||
laser_limit: as_i64(f.get("LaserLimit")),
|
||||
homing_limit: as_i64(f.get("HomingLimit")),
|
||||
space_size: as_f32(f.get("SpaceSize")),
|
||||
supply_range: as_f32(f.get("SupplyRange")),
|
||||
main_mission_bonus: as_i64(f.get("MainMissionBonus")),
|
||||
rank_score_s: as_i64(f.get("RankScore_S")),
|
||||
rank_score_a: as_i64(f.get("RankScore_A")),
|
||||
rank_score_b: as_i64(f.get("RankScore_B")),
|
||||
rank_score_c: as_i64(f.get("RankScore_C")),
|
||||
rank_score_d: as_i64(f.get("RankScore_D")),
|
||||
fields: f,
|
||||
})
|
||||
}
|
||||
pub fn field_f32(&self, key: &str) -> Option<f32> {
|
||||
as_f32(self.fields.get(key))
|
||||
}
|
||||
}
|
||||
|
||||
/// Load every player config (one per mission) from a pak.
|
||||
pub fn load_player_configs(pak: &PakArchive) -> Vec<PlayerConfig> {
|
||||
load_table(pak, schema::PLAYER, PlayerConfig::from_idxd)
|
||||
}
|
||||
|
||||
// ── Character ───────────────────────────────────────────────────────────────────
|
||||
|
||||
/// A pilot / crew portrait: an emotion id (`FaceRAYMOND_07`) and its texture
|
||||
/// (`pjf003_C02.t32`, a T8aD tile inside a RATC bundle).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Face {
|
||||
pub id: String,
|
||||
pub texture: String,
|
||||
}
|
||||
|
||||
/// A character (schema [`CHARACTER`](schema::CHARACTER)) — pilots, crew, comms.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Character {
|
||||
pub id: Option<String>,
|
||||
/// Localized display-name key (resolve against the game's string tables).
|
||||
pub name_key: Option<String>,
|
||||
/// Faction / side, e.g. `TCAF` (player) or `ADAN` (enemy).
|
||||
pub faction: Option<String>,
|
||||
pub unique: Option<bool>,
|
||||
/// Portrait set: each emotion face and the texture that draws it.
|
||||
pub faces: Vec<Face>,
|
||||
pub fields: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl Character {
|
||||
fn from_idxd(o: &IdxdObject) -> Option<Self> {
|
||||
let t = o.tokens();
|
||||
// Faces are `(texture, FaceID)` pairs after the `Faces` marker (value-
|
||||
// before-key: the FaceID names the emotion, the `.t32` before it is its art).
|
||||
let mut faces = Vec::new();
|
||||
if let Some(start) = t.iter().position(|s| s == "Faces") {
|
||||
for i in (start + 1)..t.len() {
|
||||
if t[i].starts_with("Face") && i > 0 {
|
||||
faces.push(Face {
|
||||
id: t[i].clone(),
|
||||
texture: t[i - 1].clone(),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(Character {
|
||||
id: o.get_raw("ID").map(str::to_string),
|
||||
name_key: o.get_raw("Name").map(str::to_string),
|
||||
faction: o.get_raw("SideID").map(str::to_string),
|
||||
unique: o.get_bool("Unique"),
|
||||
faces,
|
||||
fields: field_map(o),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Load every character from a pak.
|
||||
pub fn load_characters(pak: &PakArchive) -> Vec<Character> {
|
||||
load_table(pak, schema::CHARACTER, Character::from_idxd)
|
||||
}
|
||||
|
||||
// ── Stage / mission ─────────────────────────────────────────────────────────────
|
||||
|
||||
/// The raw token immediately before `key` in `tokens` (value-before-key), for
|
||||
/// identifier-valued fields the generic resolver skips (filenames, locations).
|
||||
fn raw_before<'a>(tokens: &'a [String], key: &str) -> Option<&'a str> {
|
||||
let i = tokens.iter().position(|t| t == key)?;
|
||||
(i > 0).then(|| tokens[i - 1].as_str())
|
||||
}
|
||||
|
||||
/// A mission / stage (schema [`STAGE`](schema::STAGE)). The manifest that wires a
|
||||
/// mission together: its location, phase count, and the per-stage tables that
|
||||
/// populate it (unit roster, squadrons, formations, flight routes, AI, objectives).
|
||||
/// Resolve the referenced `*_S<NN>.tbl` tables with [`load_records`] for the
|
||||
/// spawn/formation detail.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Stage {
|
||||
/// Stage tag derived from the unit-table name, e.g. `"S01"`.
|
||||
pub id: String,
|
||||
/// In-world location (`BackGroundID`), e.g. `Lebendorf`, `Acheron`, `Earth`.
|
||||
pub location: Option<String>,
|
||||
/// Number of `Phase_N` sections.
|
||||
pub phases: u32,
|
||||
pub unit_table: Option<String>,
|
||||
pub character_table: Option<String>,
|
||||
pub squadron_table: Option<String>,
|
||||
pub formation_table: Option<String>,
|
||||
pub route_table: Option<String>,
|
||||
pub ai_params_table: Option<String>,
|
||||
pub subobjective_table: Option<String>,
|
||||
pub message_table: Option<String>,
|
||||
/// Every `resource-kind → table` reference in the manifest.
|
||||
pub resources: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl Stage {
|
||||
fn from_idxd(o: &IdxdObject) -> Option<Self> {
|
||||
let t = o.tokens();
|
||||
// Each resource is `table-name → Enumerate<Kind>` (value-before-key).
|
||||
let mut resources = BTreeMap::new();
|
||||
for i in 1..t.len() {
|
||||
let key = t[i].as_str();
|
||||
if key.starts_with("Enumerate") || key == "MessageSet" || key == "NamePlate" {
|
||||
resources.insert(key.to_string(), t[i - 1].clone());
|
||||
}
|
||||
}
|
||||
let unit_table = raw_before(t, "EnumerateUnit").map(str::to_string);
|
||||
let id = unit_table
|
||||
.as_deref()
|
||||
.and_then(|s| s.strip_prefix("EnumUnit_"))
|
||||
.map(|s| s.trim_end_matches(".tbl").to_string())
|
||||
.unwrap_or_default();
|
||||
Some(Stage {
|
||||
id,
|
||||
location: o.get_raw("BackGroundID").map(str::to_string),
|
||||
phases: t.iter().filter(|s| s.starts_with("Phase_")).count() as u32,
|
||||
unit_table,
|
||||
character_table: raw_before(t, "EnumerateCharacter").map(str::to_string),
|
||||
squadron_table: raw_before(t, "EnumerateSquadron").map(str::to_string),
|
||||
formation_table: raw_before(t, "EnumerateFormation").map(str::to_string),
|
||||
route_table: raw_before(t, "EnumerateNullFrame").map(str::to_string),
|
||||
ai_params_table: raw_before(t, "EnumerateAIParams").map(str::to_string),
|
||||
subobjective_table: raw_before(t, "EnumerateSubobjective").map(str::to_string),
|
||||
message_table: raw_before(t, "MessageSet").map(str::to_string),
|
||||
resources,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Load every stage / mission manifest from a pak.
|
||||
pub fn load_stages(pak: &PakArchive) -> Vec<Stage> {
|
||||
load_table(pak, schema::STAGE, Stage::from_idxd)
|
||||
}
|
||||
|
||||
// ── Squadron / flight group ─────────────────────────────────────────────────────
|
||||
|
||||
/// A squadron — a flight group that spawns together: its formation shape, AI
|
||||
/// behaviour, side, and member craft (with their pilots). Parsed from the
|
||||
/// per-stage `Enumerate_Squadrons` tables (`UnitGroup_S<NN>.tbl`). The player's
|
||||
/// Rhino flight, for instance, is a 2-craft TCAF squadron flying `Formation_2_Rhino`.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Squadron {
|
||||
/// Squadron tag (`TCN001`, `ADT101`, …), matched positionally to its
|
||||
/// definition; `None` if the id list and definitions don't line up.
|
||||
pub id: Option<String>,
|
||||
pub formation_id: Option<String>,
|
||||
pub ai_id: Option<String>,
|
||||
/// Faction — `TCAF` (allied) or `ADAN` (enemy).
|
||||
pub side: Option<String>,
|
||||
pub count: Option<i64>,
|
||||
/// Member craft (`UN_*` unit ids).
|
||||
pub members: Vec<String>,
|
||||
}
|
||||
|
||||
/// Load every squadron from a pak. Scans all `Enumerate_Squadrons` tables (their
|
||||
/// schema hash varies per stage, but the table name is stable).
|
||||
pub fn load_squadrons(pak: &PakArchive) -> Vec<Squadron> {
|
||||
let mut out = Vec::new();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
let t = o.tokens();
|
||||
if !t.first().is_some_and(|s| s.contains("Enumerate_Squadron")) {
|
||||
continue;
|
||||
}
|
||||
// Definitions are delimited by the `FormationID` key (its value, the
|
||||
// formation, sits just before it). The id list precedes the first one.
|
||||
let fpos: Vec<usize> = t
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, s)| *s == "FormationID")
|
||||
.map(|(i, _)| i)
|
||||
.collect();
|
||||
let Some(&first) = fpos.first() else { continue };
|
||||
// The squadron id list: tokens after the header up to the first formation.
|
||||
let ids: Vec<&String> = t[1..first.saturating_sub(1)].iter().collect();
|
||||
for (k, &fi) in fpos.iter().enumerate() {
|
||||
let start = fi.saturating_sub(1);
|
||||
let end = fpos.get(k + 1).map(|&n| n.saturating_sub(1)).unwrap_or(t.len());
|
||||
let span = &t[start..end];
|
||||
let before = |key: &str| -> Option<String> {
|
||||
span.iter().position(|s| s == key).and_then(|i| (i > 0).then(|| span[i - 1].clone()))
|
||||
};
|
||||
let count = before("Count").and_then(|v| v.parse::<i64>().ok());
|
||||
// Members are the first `count` `UN_` craft after the header block
|
||||
// (which ends at DisableInterval, else Count); anything past them
|
||||
// belongs to the next squadron or the stage roster.
|
||||
let member_start = span
|
||||
.iter()
|
||||
.position(|s| s == "DisableInterval")
|
||||
.or_else(|| span.iter().position(|s| s == "Count"))
|
||||
.map(|i| i + 1)
|
||||
.unwrap_or(0);
|
||||
let take = count.unwrap_or(0).max(0) as usize;
|
||||
out.push(Squadron {
|
||||
id: (ids.len() == fpos.len()).then(|| ids[k].clone()),
|
||||
formation_id: Some(t[fi - 1].clone()),
|
||||
ai_id: before("AIID"),
|
||||
side: before("SideID"),
|
||||
count,
|
||||
members: span[member_start..]
|
||||
.iter()
|
||||
.filter(|s| s.starts_with("UN_"))
|
||||
.take(take)
|
||||
.cloned()
|
||||
.collect(),
|
||||
});
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ── Demo message / dialogue line ────────────────────────────────────────────────
|
||||
|
||||
/// One dialogue line (schema [`MESSAGE`](schema::MESSAGE)): who speaks, with which
|
||||
/// portrait and voice clip, and the text-key(s) of its caption pages. Resolve the
|
||||
/// page keys against a [`crate::localization::TextIndex`] for the words, and the
|
||||
/// voice clip against the movie-voice banks for the audio.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct DemoMessage {
|
||||
/// Line id, e.g. `MSG_VOICE_A_007`.
|
||||
pub id: String,
|
||||
/// Speaker (`CharacterRAYMOND`) when the line names one; many system /
|
||||
/// continuation lines are unattributed (`None`).
|
||||
pub character: Option<String>,
|
||||
/// Portrait / emotion (`FaceRAYMOND_07`).
|
||||
pub face: Option<String>,
|
||||
/// Voice clip token (`VOICE_A_007`).
|
||||
pub voice_clip: Option<String>,
|
||||
/// Caption page text keys (`MSG_VOICE_A_007_000_00`, …) — resolve for the text.
|
||||
pub page_keys: Vec<String>,
|
||||
}
|
||||
|
||||
/// Load every dialogue line from a pak. Each `Message_NNN` sub-record within the
|
||||
/// message blobs becomes one [`DemoMessage`]; fields are found by prefix, so the
|
||||
/// positional/defaulted layout doesn't matter.
|
||||
pub fn load_demo_messages(pak: &PakArchive) -> Vec<DemoMessage> {
|
||||
let is_marker = |s: &str| {
|
||||
s.strip_prefix("Message_").is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit()))
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
if o.schema_hash != schema::MESSAGE {
|
||||
continue;
|
||||
}
|
||||
let t = o.tokens();
|
||||
let marks: Vec<usize> = t.iter().enumerate().filter(|(_, s)| is_marker(s)).map(|(i, _)| i).collect();
|
||||
for (k, &m) in marks.iter().enumerate() {
|
||||
let end = marks.get(k + 1).copied().unwrap_or(t.len());
|
||||
let slice = &t[m + 1..end];
|
||||
let Some(id) = slice.first().cloned() else { continue };
|
||||
out.push(DemoMessage {
|
||||
character: slice.iter().find(|s| s.starts_with("Character")).cloned(),
|
||||
face: slice.iter().find(|s| s.starts_with("Face")).cloned(),
|
||||
voice_clip: slice.iter().find(|s| s.starts_with("VOICE_")).cloned(),
|
||||
page_keys: slice
|
||||
.iter()
|
||||
.filter(|s| s.len() > id.len() && s.starts_with(&id) && s[id.len()..].starts_with('_'))
|
||||
.cloned()
|
||||
.collect(),
|
||||
id,
|
||||
});
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ── Unit roster (per-mission combatants) ────────────────────────────────────────
|
||||
|
||||
/// Schema of the per-stage `EnumUnit` roster tables.
|
||||
const ENUM_UNIT_SCHEMA: u32 = 0x35b8_dc67;
|
||||
|
||||
/// A mission's unit roster — the craft, vessels and props that can appear in one
|
||||
/// battle (an `EnumUnit_S<NN>` table). Join the ids against [`load_units`] /
|
||||
/// [`load_vessels`] for stats. The table isn't tagged with its stage on disc, so
|
||||
/// [`stage`](UnitRoster::stage) is inferred from any `S<NN>_`-prefixed prop id in
|
||||
/// the roster (asteroid collision meshes etc.) and is `None` when none is present.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct UnitRoster {
|
||||
pub stage: Option<String>,
|
||||
/// Distinct combatant unit ids (`UN_*`), excluding stage props (asteroids,
|
||||
/// collision meshes).
|
||||
pub units: Vec<String>,
|
||||
}
|
||||
|
||||
/// Load every mission unit roster from a pak.
|
||||
pub fn load_unit_rosters(pak: &PakArchive) -> Vec<UnitRoster> {
|
||||
let mut out = Vec::new();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
if o.schema_hash != ENUM_UNIT_SCHEMA {
|
||||
continue;
|
||||
}
|
||||
let ids: Vec<&str> = o.tokens().iter().filter(|s| s.starts_with("UN_")).map(String::as_str).collect();
|
||||
// Stage tag from an `UN_S<NN>_…` prop id (e.g. UN_S01_Asteroid_cmesh_…).
|
||||
let stage = ids.iter().find_map(|s| {
|
||||
let r = s.trim_start_matches("UN_");
|
||||
let bytes = r.as_bytes();
|
||||
(r.len() >= 3 && bytes[0] == b'S' && bytes[1].is_ascii_digit() && bytes[2].is_ascii_digit())
|
||||
.then(|| r[..3].to_string())
|
||||
});
|
||||
// Combatants: drop the stage props, dedup preserving order.
|
||||
let mut units = Vec::new();
|
||||
for id in ids {
|
||||
let prop = id.contains("Asteroid") || id.contains("cmesh") || id.contains("_Box");
|
||||
if !prop && !units.iter().any(|u| u == id) {
|
||||
units.push(id.to_string());
|
||||
}
|
||||
}
|
||||
if !units.is_empty() {
|
||||
out.push(UnitRoster { stage, units });
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ── Pilot roster (player squadron assignments) ──────────────────────────────────
|
||||
|
||||
/// The player squadron's flight assignments for a mission — which pilot flies each
|
||||
/// callsign (`Rhino1` → `Katana`, `Bird1` → `Sandra`, …). Parsed from the
|
||||
/// `UNITS`/`ZUNITS` player-unit tables (in `GP_HANGAR_ARSENAL.pak`); assignments
|
||||
/// vary per mission (different missions field different wingmen).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct PilotRoster {
|
||||
/// `(callsign, pilot)` pairs in flight order, e.g. `("Rhino1", "Katana")`.
|
||||
pub pilots: Vec<(String, String)>,
|
||||
/// The player craft unit id (`UN_f002_TCAF_DeltaSaber…`).
|
||||
pub player_unit: Option<String>,
|
||||
}
|
||||
|
||||
/// True for a `Callsign<N>-Pilot` token (a single hyphen, digit-suffixed callsign,
|
||||
/// alphabetic pilot) — the flight-assignment shape.
|
||||
fn is_assignment(s: &str) -> bool {
|
||||
let Some((cs, pilot)) = s.split_once('-') else { return false };
|
||||
!pilot.is_empty()
|
||||
&& pilot.chars().all(|c| c.is_ascii_alphabetic())
|
||||
&& cs.len() >= 2
|
||||
&& cs.as_bytes()[cs.len() - 1].is_ascii_digit()
|
||||
&& cs.chars().all(|c| c.is_ascii_alphanumeric())
|
||||
}
|
||||
|
||||
/// Load every player pilot roster from a pak (scan `GP_HANGAR_ARSENAL.pak`). One
|
||||
/// per player-unit config; rosters with no assignment tokens are skipped.
|
||||
pub fn load_pilot_rosters(pak: &PakArchive) -> Vec<PilotRoster> {
|
||||
let mut out = Vec::new();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
let t = o.tokens();
|
||||
let pilots: Vec<(String, String)> = t
|
||||
.iter()
|
||||
.filter(|s| is_assignment(s))
|
||||
.filter_map(|s| s.split_once('-').map(|(c, p)| (c.to_string(), p.to_string())))
|
||||
.collect();
|
||||
if pilots.len() >= 2 {
|
||||
out.push(PilotRoster {
|
||||
pilots,
|
||||
player_unit: t.iter().find(|s| s.starts_with("UN_")).cloned(),
|
||||
});
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ── Arsenal (player weapon options per hardpoint) ───────────────────────────────
|
||||
|
||||
/// The player's selectable weapons, by hardpoint (from the `UNITS` player-unit
|
||||
/// tables in `GP_HANGAR_ARSENAL.pak`). These are the arsenal display ids — the
|
||||
/// Delta Saber's nose guns (`Stiletto_BG1`, `Broad_Sword_SG1`, …) and arm missiles
|
||||
/// (`Falcon_9AM`, `White_Shark_T53R`, …) the player equips in the hangar.
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct Arsenal {
|
||||
/// Nose slot — the fixed forward gun options.
|
||||
pub nose: Vec<String>,
|
||||
/// The three arm hardpoints — missile / bomb / special options.
|
||||
pub arm1: Vec<String>,
|
||||
pub arm2: Vec<String>,
|
||||
pub arm3: Vec<String>,
|
||||
}
|
||||
|
||||
/// The weapon ids listed under a `STANDARD_<hp>` header (skipping its `Type` key),
|
||||
/// up to the next `STANDARD_`/`PlayerSET_` header.
|
||||
fn hardpoint_options(tokens: &[String], header: &str) -> Vec<String> {
|
||||
let Some(start) = tokens.iter().position(|s| s == header) else { return Vec::new() };
|
||||
tokens[start + 1..]
|
||||
.iter()
|
||||
.skip_while(|s| *s == "Type")
|
||||
.take_while(|s| !s.starts_with("STANDARD_") && !s.starts_with("PlayerSET"))
|
||||
.filter(|s| *s != "Type")
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Load the player arsenal from a pak (`GP_HANGAR_ARSENAL.pak`). Unions the weapon
|
||||
/// options across every player-unit config, deduped in first-seen order.
|
||||
pub fn load_arsenal(pak: &PakArchive) -> Arsenal {
|
||||
let mut a = Arsenal::default();
|
||||
let mut seen = [(); 4].map(|_| std::collections::BTreeSet::new());
|
||||
let slots: [(&str, usize); 4] = [
|
||||
("STANDARD_NOSE", 0),
|
||||
("STANDARD_ARM1", 1),
|
||||
("STANDARD_ARM2", 2),
|
||||
("STANDARD_ARM3", 3),
|
||||
];
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
let Ok(o) = IdxdObject::parse(&b) else { continue };
|
||||
if !o.tokens().first().is_some_and(|s| s.ends_with("UNITS")) {
|
||||
continue;
|
||||
}
|
||||
for (header, idx) in slots {
|
||||
let dst = match idx {
|
||||
0 => &mut a.nose,
|
||||
1 => &mut a.arm1,
|
||||
2 => &mut a.arm2,
|
||||
_ => &mut a.arm3,
|
||||
};
|
||||
for w in hardpoint_options(o.tokens(), header) {
|
||||
if seen[idx].insert(w.clone()) {
|
||||
dst.push(w);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
a
|
||||
}
|
||||
|
||||
// ── Generic record access (any of the ~105 schemas) ─────────────────────────────
|
||||
|
||||
/// A generically-decoded IDXD record: its table name, schema id, identity, and
|
||||
/// every explicitly-set field. Use this to read the ~99 schemas without a bespoke
|
||||
/// struct (missions, UI layouts, effects, enums, …).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Record {
|
||||
/// The table name — `token[0]` (e.g. `Weapon`, `StageResource`, `Sperkers`).
|
||||
/// May carry a stray leading byte from the string-pool boundary on some
|
||||
/// records; group by [`schema`](Self::schema), not this, for reliability.
|
||||
pub table: String,
|
||||
pub schema: u32,
|
||||
pub id: Option<String>,
|
||||
pub name: Option<String>,
|
||||
/// Every explicitly-set field (`key → value`).
|
||||
pub fields: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl Record {
|
||||
fn from_idxd(o: &IdxdObject) -> Option<Self> {
|
||||
Some(Record {
|
||||
table: o.tokens().first().cloned().unwrap_or_default(),
|
||||
schema: o.schema_hash,
|
||||
id: o.get_raw("ID").map(str::to_string),
|
||||
name: o.get_raw("Name").map(str::to_string),
|
||||
fields: field_map(o),
|
||||
})
|
||||
}
|
||||
pub fn f32(&self, key: &str) -> Option<f32> {
|
||||
as_f32(self.fields.get(key))
|
||||
}
|
||||
pub fn i64(&self, key: &str) -> Option<i64> {
|
||||
as_i64(self.fields.get(key))
|
||||
}
|
||||
}
|
||||
|
||||
/// Load every record of an arbitrary `schema` from a pak, generically. Pair with
|
||||
/// the [`schema`] constants or a hash from the IDXD census.
|
||||
pub fn load_records(pak: &PakArchive, schema: u32) -> Vec<Record> {
|
||||
load_table(pak, schema, Record::from_idxd)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn as_f32_tolerates_trailing_f() {
|
||||
assert_eq!(as_f32(Some(&"3.0f".to_string())), Some(3.0));
|
||||
assert_eq!(as_f32(Some(&"-0.5".to_string())), Some(-0.5));
|
||||
assert_eq!(as_f32(Some(&"Vessel,Craft".to_string())), None);
|
||||
}
|
||||
|
||||
// Integration tests against a real disc — skipped unless SYLPHEED_DISC is set.
|
||||
fn pak() -> Option<PakArchive> {
|
||||
let disc = std::env::var("SYLPHEED_DISC").ok()?;
|
||||
PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")).ok()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_weapons() {
|
||||
let Some(pak) = pak() else { return };
|
||||
let ws = load_weapons(&pak);
|
||||
assert!(ws.len() >= 100, "expected ≥100 weapons, got {}", ws.len());
|
||||
let rocket = ws
|
||||
.iter()
|
||||
.find(|w| w.id.as_deref().is_some_and(|s| s.contains("DeltaSaber_Rocket")))
|
||||
.expect("Delta Saber rocket present");
|
||||
assert_eq!(rocket.velocity, Some(3000.0));
|
||||
assert_eq!(rocket.max_range, Some(6000.0));
|
||||
assert_eq!(rocket.loading_count, Some(1000));
|
||||
assert_eq!(rocket.target_type.as_deref(), Some("Vessel,Craft,Structure"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_units_and_vessels() {
|
||||
let Some(pak) = pak() else { return };
|
||||
let units = load_units(&pak);
|
||||
assert!(units.len() >= 80);
|
||||
// Player craft: HP 1000, radar 500000.
|
||||
let player = units
|
||||
.iter()
|
||||
.find(|u| u.id.as_deref().is_some_and(|s| s.contains("DeltaSaber_T")))
|
||||
.expect("player craft present");
|
||||
assert_eq!(player.hp, Some(1000.0));
|
||||
assert_eq!(player.radar_range, Some(500000.0));
|
||||
|
||||
let vessels = load_vessels(&pak);
|
||||
let flagship = vessels
|
||||
.iter()
|
||||
.find(|v| v.id.as_deref().is_some_and(|s| s.contains("SDBattleship")))
|
||||
.expect("SD-Battleship present");
|
||||
assert_eq!(flagship.hp, Some(100000.0));
|
||||
assert_eq!(flagship.turret_count, Some(25));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_player_configs() {
|
||||
let Some(pak) = pak() else { return };
|
||||
let cfgs = load_player_configs(&pak);
|
||||
assert!(!cfgs.is_empty());
|
||||
let c = &cfgs[0];
|
||||
assert_eq!(c.bullet_limit, Some(512));
|
||||
assert_eq!(c.laser_limit, Some(32));
|
||||
assert_eq!(c.rank_score_s, Some(10000));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_characters() {
|
||||
let Some(pak) = pak() else { return };
|
||||
let chars = load_characters(&pak);
|
||||
assert!(chars.len() >= 20, "expected many characters, got {}", chars.len());
|
||||
let raymond = chars
|
||||
.iter()
|
||||
.find(|c| c.id.as_deref() == Some("CharacterRAYMOND"))
|
||||
.expect("Raymond present");
|
||||
assert_eq!(raymond.faction.as_deref(), Some("TCAF"));
|
||||
assert!(!raymond.faces.is_empty());
|
||||
assert!(raymond.faces.iter().all(|f| f.texture.ends_with(".t32")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_stages() {
|
||||
let Some(pak) = pak() else { return };
|
||||
let stages = load_stages(&pak);
|
||||
let s01 = stages.iter().find(|s| s.id == "S01").expect("stage S01 present");
|
||||
assert_eq!(s01.location.as_deref(), Some("Lebendorf"));
|
||||
assert_eq!(s01.phases, 3);
|
||||
assert_eq!(s01.unit_table.as_deref(), Some("EnumUnit_S01.tbl"));
|
||||
assert_eq!(s01.squadron_table.as_deref(), Some("UnitGroup_S01.tbl"));
|
||||
// 16-mission main campaign is present.
|
||||
for n in 1..=16 {
|
||||
assert!(stages.iter().any(|s| s.id == format!("S{n:02}")), "missing S{n:02}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_squadrons() {
|
||||
let Some(pak) = pak() else { return };
|
||||
let sq = load_squadrons(&pak);
|
||||
assert!(sq.len() >= 20, "expected many squadrons, got {}", sq.len());
|
||||
// A TCAF Rhino flight of Delta Sabers, membership matching its count.
|
||||
let rhino = sq
|
||||
.iter()
|
||||
.find(|s| {
|
||||
s.side.as_deref() == Some("TCAF")
|
||||
&& s.formation_id.as_deref().is_some_and(|f| f.contains("Rhino"))
|
||||
&& s.members.iter().any(|m| m.contains("DeltaSaber"))
|
||||
})
|
||||
.expect("a TCAF Rhino Delta Saber squadron");
|
||||
assert_eq!(rhino.members.len() as i64, rhino.count.unwrap_or(-1));
|
||||
assert!(rhino.members.iter().all(|m| m.contains("DeltaSaber")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_demo_messages() {
|
||||
let Some(pak) = pak() else { return };
|
||||
let msgs = load_demo_messages(&pak);
|
||||
assert!(msgs.len() > 200, "expected many dialogue lines, got {}", msgs.len());
|
||||
// Most lines are `MSG_*` ids with a speaker; page keys extend the id.
|
||||
let msg_ids = msgs.iter().filter(|m| m.id.starts_with("MSG_")).count();
|
||||
assert!(msg_ids > msgs.len() * 9 / 10, "{msg_ids}/{}", msgs.len());
|
||||
// Attributed dialogue (an explicit speaker) is a minority — most lines are
|
||||
// unattributed system/continuation messages — but there are hundreds.
|
||||
let attributed = msgs.iter().filter(|m| m.character.is_some()).count();
|
||||
assert!(attributed > 500, "attributed lines: {attributed}");
|
||||
let m = msgs.iter().find(|m| m.character.is_some() && !m.page_keys.is_empty()).unwrap();
|
||||
assert!(m.page_keys.iter().all(|k| k.starts_with(&m.id)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_unit_rosters() {
|
||||
let Some(pak) = pak() else { return };
|
||||
let rosters = load_unit_rosters(&pak);
|
||||
assert!(rosters.len() > 20, "expected many rosters, got {}", rosters.len());
|
||||
// At least a few tag their stage; all rosters carry combatants, no props.
|
||||
assert!(rosters.iter().filter(|r| r.stage.is_some()).count() >= 4);
|
||||
assert!(rosters.iter().all(|r| {
|
||||
!r.units.is_empty() && r.units.iter().all(|u| !u.contains("Asteroid"))
|
||||
}));
|
||||
// A roster tagged S01 exists and names the player's Delta Saber.
|
||||
let s01 = rosters.iter().find(|r| r.stage.as_deref() == Some("S01"));
|
||||
assert!(s01.is_some_and(|r| r.units.iter().any(|u| u.contains("DeltaSaber"))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_pilot_rosters() {
|
||||
let Ok(disc) = std::env::var("SYLPHEED_DISC") else { return };
|
||||
let Ok(pak) = PakArchive::open(format!("{disc}/dat/GP_HANGAR_ARSENAL.pak")) else { return };
|
||||
let rosters = load_pilot_rosters(&pak);
|
||||
assert!(!rosters.is_empty(), "expected player pilot rosters");
|
||||
// Some config assigns Katana to a Rhino callsign (she leads Rhino flight).
|
||||
assert!(rosters.iter().any(|r| {
|
||||
r.pilots.iter().any(|(cs, p)| cs.starts_with("Rhino") && p == "Katana")
|
||||
}));
|
||||
// Bird flight exists too.
|
||||
assert!(rosters.iter().any(|r| r.pilots.iter().any(|(cs, _)| cs.starts_with("Bird"))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loads_arsenal() {
|
||||
let Ok(disc) = std::env::var("SYLPHEED_DISC") else { return };
|
||||
let Ok(pak) = PakArchive::open(format!("{disc}/dat/GP_HANGAR_ARSENAL.pak")) else { return };
|
||||
let a = load_arsenal(&pak);
|
||||
assert!(a.nose.len() >= 5 && a.arm1.len() >= 5, "nose {} arm1 {}", a.nose.len(), a.arm1.len());
|
||||
assert!(a.nose.iter().any(|w| w.starts_with("Stiletto")));
|
||||
assert!(a.arm1.iter().any(|w| w.starts_with("Falcon")));
|
||||
// Headers never leak into the option lists.
|
||||
assert!([&a.nose, &a.arm1, &a.arm2, &a.arm3]
|
||||
.iter()
|
||||
.all(|v| v.iter().all(|w| !w.starts_with("STANDARD_") && *w != "Type")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generic_records_read_any_schema() {
|
||||
let Some(pak) = pak() else { return };
|
||||
// Stage-resource table via the generic reader (no bespoke struct).
|
||||
let stages = load_records(&pak, 0x3c9a_e32e);
|
||||
assert!(!stages.is_empty());
|
||||
assert!(stages.iter().all(|r| r.table.ends_with("StageResource")));
|
||||
}
|
||||
}
|
||||
@@ -183,6 +183,27 @@ impl IdxdObject {
|
||||
}
|
||||
format!("schema {:08x}", self.schema_hash)
|
||||
}
|
||||
|
||||
/// Recover this entry's original TOC path (e.g. `unit\rou_f001.tbl`) from its
|
||||
/// identity/pool tokens by re-hashing candidates against `name_hash` with the
|
||||
/// known path schemes. Returns `None` when no scheme reproduces the hash.
|
||||
///
|
||||
/// Shared by the CLI `pak list` and the GUI pack browser so both surface the
|
||||
/// same recovered names. See [`crate::hash::recover_toc_name`].
|
||||
pub fn recover_toc_path(&self, name_hash: u32) -> Option<String> {
|
||||
let mut cands: Vec<&str> = Vec::new();
|
||||
for key in ["ID", "Name", "Model"] {
|
||||
if let Some(v) = self.get_raw(key) {
|
||||
cands.push(v);
|
||||
}
|
||||
}
|
||||
for t in self.tokens() {
|
||||
if t.contains('_') || t.len() >= 5 {
|
||||
cands.push(t.as_str());
|
||||
}
|
||||
}
|
||||
crate::hash::recover_toc_name(name_hash, &cands)
|
||||
}
|
||||
}
|
||||
|
||||
/// Extract the trailing string pool. Finds the smallest offset whose suffix is
|
||||
|
||||
@@ -50,32 +50,11 @@ pub mod mesh;
|
||||
// Audio parsing — scaffold for XMA handling
|
||||
pub mod audio;
|
||||
|
||||
// Movie cutscene subtitles — the movie → track → text chain.
|
||||
pub mod movie_subtitle;
|
||||
|
||||
// XACT `.slb` sound banks (voice / music) → decodable XMA1 RIFF.
|
||||
pub mod slb;
|
||||
|
||||
// The movie manifest: authoritative movie → subtitle → voice index.
|
||||
pub mod movie_manifest;
|
||||
|
||||
pub mod movie_voice;
|
||||
|
||||
pub mod game_data;
|
||||
|
||||
pub mod localization;
|
||||
|
||||
// Whole-ship assembly from XBG7 part families (capital ships as split parts).
|
||||
pub mod ship;
|
||||
|
||||
// Exact capital-ship placement from a runtime F10 ship-capture (ground truth).
|
||||
pub mod ship_capture;
|
||||
|
||||
/// Re-export the most commonly used types at the crate root.
|
||||
pub use audio::{AudioCodec, AudioInfo, GameAudio};
|
||||
pub use font::FontInfo;
|
||||
pub use idxd::{IdxdError, IdxdObject};
|
||||
pub use ixud::{Cue, Subtitle};
|
||||
pub use movie_subtitle::{SubCue, SubLang};
|
||||
pub use mesh::{GameMesh, Xbg7Model};
|
||||
pub use ratc::RatcChild;
|
||||
pub use t8ad::T8adImage;
|
||||
|
||||
@@ -1,179 +0,0 @@
|
||||
//! Localization — resolve the game's text keys to display strings.
|
||||
//!
|
||||
//! Project Sylpheed stores its UI/story text in `IXUD` entries as **UTF-16LE**,
|
||||
//! interleaved `text, key, text, key, …`: a prose string immediately followed by
|
||||
//! the identifier that names it. Objectives (`S01_P1_Objective_00`), hints, lose
|
||||
//! conditions, character names (`CharacterName_CharacterRAYMOND`) and cutscene
|
||||
//! dialogue (`MSG_*`) all resolve this way. One pak per language — pass
|
||||
//! `GP_MAIN_GAME_E.pak` for English, `GP_MAIN_GAME_J.pak` for Japanese, etc.
|
||||
//!
|
||||
//! ```no_run
|
||||
//! use sylpheed_formats::{localization::TextIndex, PakArchive};
|
||||
//! let pak = PakArchive::open("dat/GP_MAIN_GAME_E.pak").unwrap();
|
||||
//! let text = TextIndex::build(&pak);
|
||||
//! assert_eq!(text.character_name("CharacterRAYMOND"), Some("Raymond"));
|
||||
//! for line in text.objectives("S01", 1) { println!("• {line}"); }
|
||||
//! ```
|
||||
|
||||
use crate::pak::PakArchive;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// A UTF-16 unit that belongs to a printable text run (ASCII + Latin-1 + Latin
|
||||
/// Extended-A). Control codes and the CJK planes split tokens.
|
||||
fn is_text_unit(u: u16) -> bool {
|
||||
matches!(u, 0x20..=0x7e | 0xa0..=0xff | 0x100..=0x17f)
|
||||
}
|
||||
|
||||
/// Split a UTF-16LE blob into printable tokens (mirrors the subtitle tokenizer:
|
||||
/// step 2 inside a run, 1 on a break to resync odd alignment).
|
||||
fn utf16_tokens(bytes: &[u8]) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
let mut cur = String::new();
|
||||
let mut i = 0;
|
||||
while i + 1 < bytes.len() {
|
||||
let u = u16::from_le_bytes([bytes[i], bytes[i + 1]]);
|
||||
if is_text_unit(u) {
|
||||
if let Some(c) = char::from_u32(u as u32) {
|
||||
cur.push(c);
|
||||
}
|
||||
i += 2;
|
||||
} else {
|
||||
if cur.chars().count() >= 2 {
|
||||
out.push(std::mem::take(&mut cur));
|
||||
} else {
|
||||
cur.clear();
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
if cur.chars().count() >= 2 {
|
||||
out.push(cur);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// An identifier token — the key half of a `text, key` pair.
|
||||
fn is_key(s: &str) -> bool {
|
||||
s.len() >= 5
|
||||
&& s.contains('_')
|
||||
&& s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
|
||||
&& s.chars().any(|c| c.is_ascii_uppercase())
|
||||
}
|
||||
|
||||
/// A display-text token — anything with a lowercase letter that isn't itself a key.
|
||||
fn is_prose(s: &str) -> bool {
|
||||
!is_key(s) && s.chars().any(|c| c.is_ascii_lowercase())
|
||||
}
|
||||
|
||||
/// Text-key → display-string index for one language, built from a `GP_MAIN_GAME_*`
|
||||
/// pak.
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct TextIndex {
|
||||
entries: BTreeMap<String, String>,
|
||||
}
|
||||
|
||||
impl TextIndex {
|
||||
/// Scan a language pak's `IXUD` entries and index every `text → key` pair.
|
||||
pub fn build(pak: &PakArchive) -> Self {
|
||||
let mut entries = BTreeMap::new();
|
||||
for e in pak.entries() {
|
||||
let Ok(b) = pak.read(e) else { continue };
|
||||
if b.len() < 4 || &b[0..4] != b"IXUD" {
|
||||
continue;
|
||||
}
|
||||
let toks = utf16_tokens(&b);
|
||||
for w in toks.windows(2) {
|
||||
if is_key(&w[1]) && is_prose(&w[0]) {
|
||||
entries.entry(w[1].clone()).or_insert_with(|| w[0].clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
TextIndex { entries }
|
||||
}
|
||||
|
||||
/// The display string for a text key, if present.
|
||||
pub fn get(&self, key: &str) -> Option<&str> {
|
||||
self.entries.get(key).map(String::as_str)
|
||||
}
|
||||
|
||||
/// Number of indexed keys.
|
||||
pub fn len(&self) -> usize {
|
||||
self.entries.len()
|
||||
}
|
||||
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.entries.is_empty()
|
||||
}
|
||||
|
||||
/// The objective lines for a stage/phase, e.g. `("S01", 1)`. Empty if none
|
||||
/// resolve (unused objective slots are simply absent on disc).
|
||||
pub fn objectives(&self, stage: &str, phase: u32) -> Vec<&str> {
|
||||
self.numbered(&format!("{stage}_P{phase}_Objective"))
|
||||
}
|
||||
|
||||
/// The lose-condition lines for a stage/phase.
|
||||
pub fn lose_conditions(&self, stage: &str, phase: u32) -> Vec<&str> {
|
||||
self.numbered(&format!("{stage}_P{phase}_Lose"))
|
||||
}
|
||||
|
||||
/// The hint lines for a stage/phase.
|
||||
pub fn hints(&self, stage: &str, phase: u32) -> Vec<&str> {
|
||||
self.numbered(&format!("{stage}_P{phase}_Hint"))
|
||||
}
|
||||
|
||||
/// A character's display name from its id (`CharacterRAYMOND` → `Raymond`).
|
||||
pub fn character_name(&self, character_id: &str) -> Option<&str> {
|
||||
self.get(&format!("CharacterName_{character_id}"))
|
||||
}
|
||||
|
||||
/// Collect a `<base>_NN` run of lines while they resolve.
|
||||
fn numbered(&self, base: &str) -> Vec<&str> {
|
||||
(0..16)
|
||||
.filter_map(|i| self.get(&format!("{base}_{i:02}")))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn tokenizes_mixed_runs() {
|
||||
// "Hi" NUL "K_1" as UTF-16LE → two tokens.
|
||||
let mut b = Vec::new();
|
||||
for s in ["Hi", "\0", "K_1x"] {
|
||||
for c in s.chars() {
|
||||
b.extend_from_slice(&(c as u16).to_le_bytes());
|
||||
}
|
||||
}
|
||||
let t = utf16_tokens(&b);
|
||||
assert!(t.contains(&"Hi".to_string()));
|
||||
assert!(t.contains(&"K_1x".to_string()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn key_and_prose_classify() {
|
||||
assert!(is_key("S01_P1_Objective_00"));
|
||||
assert!(is_key("CharacterName_CharacterRAYMOND"));
|
||||
assert!(!is_key("Repel the attack."));
|
||||
assert!(is_prose("Repel the attack."));
|
||||
assert!(is_prose("Raymond"));
|
||||
assert!(!is_prose("S01_P1_Objective_00"));
|
||||
}
|
||||
|
||||
// Disc-backed — skipped unless SYLPHEED_DISC is set.
|
||||
#[test]
|
||||
fn resolves_real_text() {
|
||||
let Ok(disc) = std::env::var("SYLPHEED_DISC") else { return };
|
||||
let Ok(pak) = PakArchive::open(format!("{disc}/dat/GP_MAIN_GAME_E.pak")) else { return };
|
||||
let t = TextIndex::build(&pak);
|
||||
assert!(t.len() > 5000, "expected a large index, got {}", t.len());
|
||||
assert_eq!(t.character_name("CharacterRAYMOND"), Some("Raymond"));
|
||||
assert_eq!(
|
||||
t.get("S01_P1_Objective_00"),
|
||||
Some("Repel the enemy's surprise attack.")
|
||||
);
|
||||
assert!(!t.objectives("S01", 1).is_empty());
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,428 +0,0 @@
|
||||
//! The movie manifest: the game's authoritative **mission → phase → cutscene**
|
||||
//! table (statically reversed). Beyond the movie→voice binding, it defines the
|
||||
//! whole cutscene *structure*: which video (+ subtitle, + on-screen text overlay,
|
||||
//! + voice) plays at each mission phase, and of what kind (story intro, in-mission
|
||||
//! phase cutscene, resupply, …).
|
||||
//!
|
||||
//! ## On-disc structure (`dat/tables.pak`, entry hash `0x5b983a08`)
|
||||
//!
|
||||
//! One `IDXD` table (`Z1`+zlib block), schema `0x067025b9`. Unlike a flat IDXD
|
||||
//! object, this one is an **array of records**, and its string pool is laid out
|
||||
//! as **two consecutive arrays**:
|
||||
//! 1. the **slot KEYS** — `LOGO1`, `ADVERTISE_MOVIE`, `STAFF_ROLL`, then one
|
||||
//! per cutscene: `MS<NN><X>`, `STAGE<NN>_PHASE0<N>`, `STAGE<NN>_PHASE_END…`,
|
||||
//! `S<NN>_SUPPLY_<ACROPOLIS|TANKER>`, in play order;
|
||||
//! 2. the **value RECORDS**, in the same order — each a run led by `<movie>.wmv`
|
||||
//! and (optionally) a `<pak>+….prt` overlay (field `TELOP`), a
|
||||
//! `<pak>+SUBTITLE_<movie>.tbl` (field `SUBTITLE`), and a `VOICE_<token>`
|
||||
//! (field `VOICETRACK`). A few slot keys are **valueless** (e.g. stages 5 and
|
||||
//! 12 have no resupply video) — those slots have no record and are skipped.
|
||||
//!
|
||||
//! The **slot key is the semantic role** — this is how the game separates a
|
||||
//! cutscene voice from in-mission radio chatter (structurally, by which slot/bank,
|
||||
//! not one boolean): `MS*` = story intro (`VOICE_S*`), `STAGE*_PHASE*` = radio-box
|
||||
//! cutscene (`VOICE_RT*`), `S*_SUPPLY_*` = resupply (`VOICE_D_45x` or none).
|
||||
//! Resupply videos are **reused across stages** (`S04_SUPPLY_ACROPOLIS` →
|
||||
//! `hokyu_DS_s02A`), so the mapping is genuinely a table, not derivable from names.
|
||||
//!
|
||||
//! The voice token is likewise **not** always `VOICE_<movie>`: most movies use
|
||||
//! `VOICE_<movie>` (in `<lang>\Movie\`), but the resupply cutscenes bind to
|
||||
//! in-mission radio clips like `VOICE_D_450` (in `<lang>\etc\`), and some have no
|
||||
//! voice at all. This manifest is the ground truth.
|
||||
//!
|
||||
//! ## Alignment
|
||||
//!
|
||||
//! Slot keys and value records would be a 1:1 positional zip but for the valueless
|
||||
//! slots. We recover the gaps without decoding the binary node/index region by
|
||||
//! using the fully-derivable **`MS<NN><X>` → `S<NN><X>` anchors**: a non-`MS` slot
|
||||
//! whose record would be an `MS` target actually belongs to the upcoming `MS`
|
||||
//! slot, so the non-`MS` slot is a gap. (Decoding the node region would make this
|
||||
//! exact and also unlock the defaulted numeric fields in other IDXD tables.)
|
||||
|
||||
use crate::slb::VoiceLang;
|
||||
|
||||
/// The role a cutscene slot plays in the mission flow, from its slot key.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum MovieKind {
|
||||
/// `LOGO*`, `ADVERTISE_MOVIE`, `STAFF_ROLL` — boot/system movies.
|
||||
System,
|
||||
/// `MS<NN><X>` — story intro movie (camera on the speaker; stereo `VOICE_S*`).
|
||||
Intro,
|
||||
/// `STAGE<NN>_PHASE0<N>` — in-mission phase cutscene (radio box; `VOICE_RT*`).
|
||||
Phase,
|
||||
/// `STAGE<NN>_PHASE_END[_0N]` — phase-end cutscene.
|
||||
PhaseEnd,
|
||||
/// `S<NN>_SUPPLY_<ACROPOLIS|TANKER>` — resupply (hokyu) cutscene.
|
||||
Supply,
|
||||
}
|
||||
|
||||
/// One cutscene slot's manifest row: its semantic slot plus the bound assets.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct MovieEntry {
|
||||
/// The slot key, e.g. `STAGE01_PHASE01`, `MS00A`, `S02_SUPPLY_ACROPOLIS`.
|
||||
/// Empty when parsed from a blob without the slot-key array (fallback).
|
||||
pub slot: String,
|
||||
/// The slot's role in the mission flow (intro vs. phase cutscene vs. supply …).
|
||||
pub kind: MovieKind,
|
||||
/// Mission/stage number (`STAGE<NN>` / `MS<NN>` / `S<NN>_SUPPLY`), if any.
|
||||
pub mission: Option<u8>,
|
||||
/// Phase number for [`MovieKind::Phase`]/[`MovieKind::PhaseEnd`], if any.
|
||||
pub phase: Option<u8>,
|
||||
/// Movie basename without extension, e.g. `S13A`, `RT01A`, `hokyu_DS_s13A`.
|
||||
pub movie: String,
|
||||
/// Voice bank basename (`VOICE_S13A`, `VOICE_D_450`), or `None` for no voice.
|
||||
pub voice_token: Option<String>,
|
||||
/// Subtitle table basename (`SUBTITLE_S13A.tbl`), pak prefix stripped, if any.
|
||||
pub subtitle: Option<String>,
|
||||
/// On-screen text-overlay (`TELOP`) basename (`pwrt01.prt`), if any.
|
||||
pub telop: Option<String>,
|
||||
}
|
||||
|
||||
/// Does this blob look like the movie manifest? (`IDXD` whose string pool
|
||||
/// carries movie + subtitle + voice references.) Used to locate it in
|
||||
/// `tables.pak` without hardcoding a hash.
|
||||
pub fn is_manifest(bytes: &[u8]) -> bool {
|
||||
bytes.len() >= 4
|
||||
&& &bytes[0..4] == b"IDXD"
|
||||
&& contains(bytes, b".wmv")
|
||||
&& contains(bytes, b"VOICE_")
|
||||
&& contains(bytes, b"SUBTITLE_")
|
||||
}
|
||||
|
||||
/// The field-type keys that appear once in the value region as a schema template.
|
||||
const FIELD_KEYS: [&str; 4] = ["MOVIE", "VOICETRACK", "SUBTITLE", "TELOP"];
|
||||
|
||||
/// Parse the manifest into per-slot cutscene rows, in play order.
|
||||
///
|
||||
/// Each returned [`MovieEntry`] carries a movie; valueless slots (e.g. stage 5's
|
||||
/// absent resupply) are omitted. When the two-array slot/record layout is present
|
||||
/// (the real manifest) every row is tagged with its authoritative slot/kind/
|
||||
/// mission/phase; otherwise (a blob without the key array) the kind is inferred
|
||||
/// from the movie name and `slot` is empty.
|
||||
pub fn parse(bytes: &[u8]) -> Vec<MovieEntry> {
|
||||
let toks = ascii_runs(bytes, 3);
|
||||
|
||||
// Locate the slot-key array (`LOGO1` … first `<movie>.wmv`) and the value
|
||||
// region (from the first `.wmv` onward). Fall back to a keyless scrape.
|
||||
let first_wmv = toks.iter().position(|t| t.ends_with(".wmv"));
|
||||
let key_start = toks.iter().position(|t| t == "LOGO1");
|
||||
let (slot_keys, value_toks): (Vec<&str>, &[String]) = match (key_start, first_wmv) {
|
||||
(Some(k), Some(w)) if k < w => (
|
||||
toks[k..w].iter().map(String::as_str).collect(),
|
||||
&toks[w..],
|
||||
),
|
||||
_ => (Vec::new(), toks.as_slice()),
|
||||
};
|
||||
|
||||
// Build the value records (drop the schema-template field keys).
|
||||
let mut records: Vec<MovieEntry> = Vec::new();
|
||||
for t in value_toks.iter().filter(|t| !FIELD_KEYS.contains(&t.as_str())) {
|
||||
if let Some(name) = t.strip_suffix(".wmv") {
|
||||
records.push(MovieEntry {
|
||||
slot: String::new(),
|
||||
kind: kind_from_movie(name),
|
||||
mission: None,
|
||||
phase: None,
|
||||
movie: name.to_string(),
|
||||
voice_token: None,
|
||||
subtitle: None,
|
||||
telop: None,
|
||||
});
|
||||
} else if let Some(rec) = records.last_mut() {
|
||||
if let Some(v) = t.strip_prefix("VOICE_") {
|
||||
if rec.voice_token.is_none() {
|
||||
rec.voice_token = Some(format!("VOICE_{v}"));
|
||||
}
|
||||
} else if t.ends_with(".tbl") {
|
||||
rec.subtitle.get_or_insert_with(|| after_plus(t));
|
||||
} else if t.ends_with(".prt") {
|
||||
rec.telop.get_or_insert_with(|| after_plus(t));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Attach slot keys to records, recovering valueless-slot gaps via MS anchors.
|
||||
if !slot_keys.is_empty() {
|
||||
let ms_targets: std::collections::HashSet<String> = slot_keys
|
||||
.iter()
|
||||
.filter_map(|k| ms_target(k))
|
||||
.collect();
|
||||
let mut j = 0usize;
|
||||
for slot in &slot_keys {
|
||||
if j >= records.len() {
|
||||
break;
|
||||
}
|
||||
// A gap: this slot's "record" is actually the next MS slot's movie.
|
||||
let would_be = &records[j].movie;
|
||||
let is_gap = match ms_target(slot) {
|
||||
// MS slot: only binds if its record is the expected `S<NN><X>`.
|
||||
Some(expected) => *would_be != expected,
|
||||
// Non-MS slot: a gap iff the record belongs to an upcoming MS slot.
|
||||
None => ms_targets.contains(would_be),
|
||||
};
|
||||
if is_gap {
|
||||
continue;
|
||||
}
|
||||
let (kind, mission, phase) = classify_slot(slot);
|
||||
let rec = &mut records[j];
|
||||
rec.slot = (*slot).to_string();
|
||||
rec.kind = kind;
|
||||
rec.mission = mission;
|
||||
rec.phase = phase;
|
||||
j += 1;
|
||||
}
|
||||
}
|
||||
|
||||
records
|
||||
}
|
||||
|
||||
/// If `slot` is an `MS<NN><X>` intro slot, the movie it must bind to (`S<NN><X>`).
|
||||
fn ms_target(slot: &str) -> Option<String> {
|
||||
let rest = slot.strip_prefix("MS")?;
|
||||
// `<NN><X>`: two digits then a letter suffix.
|
||||
if rest.len() >= 3 && rest[..2].bytes().all(|b| b.is_ascii_digit()) {
|
||||
Some(format!("S{rest}"))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Semantic role + mission/phase from a slot key.
|
||||
fn classify_slot(slot: &str) -> (MovieKind, Option<u8>, Option<u8>) {
|
||||
if let Some(rest) = slot.strip_prefix("MS") {
|
||||
if rest.len() >= 2 {
|
||||
return (MovieKind::Intro, rest[..2].parse().ok(), None);
|
||||
}
|
||||
}
|
||||
if let Some(rest) = slot.strip_prefix("STAGE") {
|
||||
let nn: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect();
|
||||
if let Ok(m) = nn.parse::<u8>() {
|
||||
if slot.contains("PHASE_END") {
|
||||
// trailing `_NN` if present (`STAGE12_PHASE_END_02`)
|
||||
let phase = slot.rsplit('_').next().and_then(|x| x.parse().ok());
|
||||
return (MovieKind::PhaseEnd, Some(m), phase);
|
||||
}
|
||||
// `STAGE<NN>_PHASE0<N>`
|
||||
let phase = rest[nn.len()..]
|
||||
.strip_prefix("_PHASE")
|
||||
.and_then(|p| p.parse().ok());
|
||||
return (MovieKind::Phase, Some(m), phase);
|
||||
}
|
||||
}
|
||||
if slot.contains("_SUPPLY") {
|
||||
if let Some(rest) = slot.strip_prefix('S') {
|
||||
let nn: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect();
|
||||
return (MovieKind::Supply, nn.parse().ok(), None);
|
||||
}
|
||||
}
|
||||
(MovieKind::System, None, None)
|
||||
}
|
||||
|
||||
/// Fallback kind from a movie basename (used when no slot-key array is present).
|
||||
fn kind_from_movie(movie: &str) -> MovieKind {
|
||||
if movie.starts_with("hokyu_") {
|
||||
MovieKind::Supply
|
||||
} else if movie.starts_with("RT") {
|
||||
MovieKind::Phase
|
||||
} else if movie.len() >= 3
|
||||
&& movie.starts_with('S')
|
||||
&& movie[1..3].bytes().all(|b| b.is_ascii_digit())
|
||||
{
|
||||
MovieKind::Intro
|
||||
} else {
|
||||
MovieKind::System
|
||||
}
|
||||
}
|
||||
|
||||
/// The part of a `<pak>+<name>` reference after the `+` (or the whole string).
|
||||
fn after_plus(s: &str) -> String {
|
||||
s.rsplit('+').next().unwrap_or(s).to_string()
|
||||
}
|
||||
|
||||
/// The voice bank basename bound to `movie`, if the manifest lists one.
|
||||
///
|
||||
/// Returns `None` both when the movie is absent and when it is present with no
|
||||
/// voice — callers that need to distinguish should use [`parse`].
|
||||
pub fn voice_token(bytes: &[u8], movie: &str) -> Option<String> {
|
||||
parse(bytes)
|
||||
.into_iter()
|
||||
.find(|e| e.movie == movie)
|
||||
.and_then(|e| e.voice_token)
|
||||
}
|
||||
|
||||
/// Resolve a movie to its full `sound.pak` voice-entry name for `lang`, using the
|
||||
/// manifest for the *token* and `sounds.tbl` for the token's *directory* (Movie /
|
||||
/// etc / Voice differ per token). `None` = the movie has no voice-over.
|
||||
pub fn resolve_voice_entry(
|
||||
manifest: &[u8],
|
||||
sounds_tbl: &[u8],
|
||||
movie: &str,
|
||||
lang: VoiceLang,
|
||||
) -> Option<String> {
|
||||
let token = voice_token(manifest, movie)?;
|
||||
resolve_token_path(sounds_tbl, &token, lang)
|
||||
}
|
||||
|
||||
/// Find the full `<lang>\…\<token>.slb` path for a voice `token` in a decompressed
|
||||
/// `sounds.tbl` (the token's subdir — `Movie`, `etc`, `Voice` — is not fixed).
|
||||
pub fn resolve_token_path(sounds_tbl: &[u8], token: &str, lang: VoiceLang) -> Option<String> {
|
||||
let prefix = format!("{}\\", lang.code_pub());
|
||||
let suffix = format!("\\{token}.slb");
|
||||
ascii_runs(sounds_tbl, 6)
|
||||
.into_iter()
|
||||
.find(|r| r.starts_with(&prefix) && r.ends_with(&suffix))
|
||||
}
|
||||
|
||||
fn contains(hay: &[u8], needle: &[u8]) -> bool {
|
||||
hay.windows(needle.len()).any(|w| w == needle)
|
||||
}
|
||||
|
||||
/// Collect printable-ASCII runs of at least `min` chars.
|
||||
fn ascii_runs(bytes: &[u8], min: usize) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
let mut cur = String::new();
|
||||
for &b in bytes {
|
||||
if (0x20..=0x7e).contains(&b) {
|
||||
cur.push(b as char);
|
||||
} else {
|
||||
if cur.len() >= min {
|
||||
out.push(std::mem::take(&mut cur));
|
||||
} else {
|
||||
cur.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
if cur.len() >= min {
|
||||
out.push(cur);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn synth() -> Vec<u8> {
|
||||
// Minimal IDXD string pool: three movies — a standard one, a hokyu bound
|
||||
// to a VOICE_D radio clip, and a hokyu with no voice.
|
||||
let mut b = b"IDXD".to_vec();
|
||||
b.extend_from_slice(&[0, 0, 0, 0x69, 0, 0]); // binary header (as on disc)
|
||||
for s in [
|
||||
"S13A.wmv",
|
||||
"eng.pak+SUBTITLE_S13A.tbl",
|
||||
"VOICE_S13A",
|
||||
"hokyu_LS_s02A.wmv",
|
||||
"eng.pak+SUBTITLE_hokyu_LS_s02A.tbl",
|
||||
"VOICE_D_450",
|
||||
"hokyu_DS_s13A.wmv",
|
||||
"eng.pak+SUBTITLE_hokyu_DS_s13A.tbl",
|
||||
] {
|
||||
b.extend_from_slice(s.as_bytes());
|
||||
b.push(0);
|
||||
}
|
||||
b
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn groups_movies_and_binds_voice() {
|
||||
// Keyless fallback path: movie + voice + subtitle + inferred kind.
|
||||
let m = parse(&synth());
|
||||
assert_eq!(m.len(), 3);
|
||||
assert_eq!(m[0].movie, "S13A");
|
||||
assert_eq!(m[0].voice_token.as_deref(), Some("VOICE_S13A"));
|
||||
assert_eq!(m[0].kind, MovieKind::Intro);
|
||||
assert_eq!(m[0].subtitle.as_deref(), Some("SUBTITLE_S13A.tbl"));
|
||||
assert_eq!(m[1].voice_token.as_deref(), Some("VOICE_D_450"));
|
||||
assert_eq!(m[1].kind, MovieKind::Supply);
|
||||
assert_eq!(m[2].voice_token, None, "hokyu_DS_s13A has no voice-over");
|
||||
assert_eq!(m[2].kind, MovieKind::Supply);
|
||||
}
|
||||
|
||||
/// Build a two-array (keys-then-records) manifest like the real one.
|
||||
fn synth_two_array(keys: &[&str], records: &[&[&str]]) -> Vec<u8> {
|
||||
let mut b = b"IDXD".to_vec();
|
||||
b.extend_from_slice(&[0, 0, 0, 0x05, 0, 0]);
|
||||
for k in keys {
|
||||
b.extend_from_slice(k.as_bytes());
|
||||
b.push(0);
|
||||
}
|
||||
for rec in records {
|
||||
for s in *rec {
|
||||
b.extend_from_slice(s.as_bytes());
|
||||
b.push(0);
|
||||
}
|
||||
}
|
||||
b
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn two_array_slots_kind_mission_phase() {
|
||||
let blob = synth_two_array(
|
||||
&["LOGO1", "MS01A", "STAGE01_PHASE01", "STAGE01_PHASE_END_02"],
|
||||
&[
|
||||
&["logo1.wmv", "MOVIE"],
|
||||
&["S01A.wmv", "eng.pak+SUBTITLE_S01A.tbl", "VOICE_S01A"],
|
||||
&["RT01A.wmv", "eng.pak+pwrt01.prt", "VOICE_RT01A", "VOICETRACK"],
|
||||
&["RT01C_2.wmv", "VOICE_RT01C_2"],
|
||||
],
|
||||
);
|
||||
let m = parse(&blob);
|
||||
assert_eq!(m.len(), 4);
|
||||
assert_eq!((m[0].slot.as_str(), m[0].kind), ("LOGO1", MovieKind::System));
|
||||
assert_eq!(
|
||||
(m[1].slot.as_str(), m[1].kind, m[1].mission),
|
||||
("MS01A", MovieKind::Intro, Some(1))
|
||||
);
|
||||
assert_eq!(
|
||||
(m[2].slot.as_str(), m[2].kind, m[2].mission, m[2].phase),
|
||||
("STAGE01_PHASE01", MovieKind::Phase, Some(1), Some(1))
|
||||
);
|
||||
assert_eq!(m[2].telop.as_deref(), Some("pwrt01.prt"));
|
||||
assert_eq!(
|
||||
(m[3].slot.as_str(), m[3].kind, m[3].phase),
|
||||
("STAGE01_PHASE_END_02", MovieKind::PhaseEnd, Some(2))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn valueless_supply_slot_is_skipped_via_ms_anchor() {
|
||||
// S05_SUPPLY has no record; its "record" (S06A) belongs to the next MS slot.
|
||||
let blob = synth_two_array(
|
||||
&["LOGO1", "MS05A", "S05_SUPPLY_ACROPOLIS", "MS06A"],
|
||||
&[
|
||||
&["logo1.wmv"],
|
||||
&["S05A.wmv", "VOICE_S05A"],
|
||||
&["S06A.wmv", "VOICE_S06A"],
|
||||
],
|
||||
);
|
||||
let m = parse(&blob);
|
||||
assert_eq!(m.len(), 3, "the valueless supply slot yields no entry");
|
||||
assert_eq!((m[1].slot.as_str(), m[1].movie.as_str()), ("MS05A", "S05A"));
|
||||
// S06A binds to MS06A, NOT to the intervening valueless supply slot.
|
||||
assert_eq!((m[2].slot.as_str(), m[2].movie.as_str()), ("MS06A", "S06A"));
|
||||
assert!(m.iter().all(|e| e.slot != "S05_SUPPLY_ACROPOLIS"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolves_token_directory_from_sounds_tbl() {
|
||||
// sounds.tbl places the two tokens in different subdirs.
|
||||
let mut tbl = Vec::new();
|
||||
for s in ["eng\\Movie\\VOICE_S13A.slb", "eng\\etc\\VOICE_D_450.slb"] {
|
||||
tbl.extend_from_slice(s.as_bytes());
|
||||
tbl.push(0);
|
||||
}
|
||||
let man = synth();
|
||||
assert_eq!(
|
||||
resolve_voice_entry(&man, &tbl, "S13A", VoiceLang::English).as_deref(),
|
||||
Some("eng\\Movie\\VOICE_S13A.slb")
|
||||
);
|
||||
assert_eq!(
|
||||
resolve_voice_entry(&man, &tbl, "hokyu_LS_s02A", VoiceLang::English).as_deref(),
|
||||
Some("eng\\etc\\VOICE_D_450.slb")
|
||||
);
|
||||
assert_eq!(
|
||||
resolve_voice_entry(&man, &tbl, "hokyu_DS_s13A", VoiceLang::English),
|
||||
None
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,454 +0,0 @@
|
||||
//! Movie cutscene subtitles: the movie → track → text chain.
|
||||
//!
|
||||
//! Reverse-engineered statically (see `docs/re/structures/movie-subtitles.md`).
|
||||
//! A cutscene's on-screen captions are assembled from three places on the disc:
|
||||
//!
|
||||
//! 1. `dat/movie/<lang>.pak` holds one **timing track** per movie, keyed by
|
||||
//! [`track_key`] = `name_hash("subtitle_<movie>.tbl")`. Each track is a
|
||||
//! `Z1`+zlib block that decompresses to an **IXUD** container whose UTF-16**LE**
|
||||
//! payload is `SUBTITLE MSG_DEMO_<demo> <mm:ss.cc> …` — i.e. *which*
|
||||
//! demo-message shows *when* (radio / resupply movies), or inline text.
|
||||
//! 2. `dat/GP_MAIN_GAME_<L>.pak` holds the **caption text**: more `Z1`+zlib IXUD
|
||||
//! blocks where each line is stored as `text` immediately followed by its key
|
||||
//! `MSG_DEMO_<demo>_<page>_<line>` (multi-line captions split across lines).
|
||||
//!
|
||||
//! [`load`] joins the two into timed [`SubCue`]s.
|
||||
//!
|
||||
//! Note: the IXUD payload here is UTF-16 **little-endian** (verified on the real
|
||||
//! disc); this is deliberately separate from the older big-endian [`crate::ixud`]
|
||||
//! presenter, which targets a different (uncompressed) variant.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use crate::hash::name_hash;
|
||||
use crate::pak::PakArchive;
|
||||
|
||||
/// Subtitle language. `pak_code` selects `dat/movie/<code>.pak`; `game_code`
|
||||
/// selects `dat/GP_MAIN_GAME_<code>.pak` (the caption text).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum SubLang {
|
||||
English,
|
||||
Japanese,
|
||||
German,
|
||||
French,
|
||||
Spanish,
|
||||
Italian,
|
||||
}
|
||||
|
||||
impl SubLang {
|
||||
/// All languages, in menu order.
|
||||
pub const ALL: [SubLang; 6] = [
|
||||
SubLang::English,
|
||||
SubLang::Japanese,
|
||||
SubLang::German,
|
||||
SubLang::French,
|
||||
SubLang::Spanish,
|
||||
SubLang::Italian,
|
||||
];
|
||||
|
||||
/// `dat/movie/<code>.pak` stem (the timing tracks + caption font).
|
||||
pub fn pak_code(self) -> &'static str {
|
||||
match self {
|
||||
SubLang::English => "eng",
|
||||
SubLang::Japanese => "jpn",
|
||||
SubLang::German => "deu",
|
||||
SubLang::French => "fra",
|
||||
SubLang::Spanish => "esp",
|
||||
SubLang::Italian => "ita",
|
||||
}
|
||||
}
|
||||
|
||||
/// `dat/GP_MAIN_GAME_<code>.pak` suffix (the caption text pack).
|
||||
pub fn game_code(self) -> &'static str {
|
||||
match self {
|
||||
SubLang::English => "E",
|
||||
SubLang::Japanese => "J",
|
||||
SubLang::German => "D",
|
||||
SubLang::French => "F",
|
||||
SubLang::Spanish => "S",
|
||||
SubLang::Italian => "I",
|
||||
}
|
||||
}
|
||||
|
||||
/// Human label for a UI selector. Kept to Latin script so it renders in a
|
||||
/// default (non-CJK) UI font; Japanese is romanized for the same reason.
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
SubLang::English => "English",
|
||||
SubLang::Japanese => "Japanese",
|
||||
SubLang::German => "Deutsch",
|
||||
SubLang::French => "Français",
|
||||
SubLang::Spanish => "Español",
|
||||
SubLang::Italian => "Italiano",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One timed caption line.
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct SubCue {
|
||||
pub start: f32,
|
||||
pub end: Option<f32>,
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
/// The `<lang>.pak` TOC key for a movie's subtitle timing track.
|
||||
pub fn track_key(movie_basename: &str) -> u32 {
|
||||
name_hash(&format!("subtitle_{movie_basename}.tbl"))
|
||||
}
|
||||
|
||||
/// Load and resolve a movie's timed captions in `lang`.
|
||||
///
|
||||
/// `lang_pak` is `dat/movie/<lang>.pak` (+segments); `text_pak` is
|
||||
/// `dat/GP_MAIN_GAME_<L>.pak` (+segments). Returns the cues in start order, or an
|
||||
/// empty vec if the movie has no timed track (e.g. story movies whose text is a
|
||||
/// pre-rendered title card).
|
||||
pub fn load(movie_basename: &str, lang_pak: &PakArchive, text_pak: &PakArchive) -> Vec<SubCue> {
|
||||
let Some(Ok(track)) = lang_pak.read_by_hash(track_key(movie_basename)) else {
|
||||
return Vec::new();
|
||||
};
|
||||
if !is_ixud(&track) {
|
||||
return Vec::new();
|
||||
}
|
||||
let raw = parse_track(&track);
|
||||
if raw.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
// Only build the (large) text table if the track actually references demos.
|
||||
let needs_text = raw.iter().any(|(t, _, _)| demo_ref(t).is_some());
|
||||
let text = if needs_text {
|
||||
build_demo_text(text_pak)
|
||||
} else {
|
||||
BTreeMap::new()
|
||||
};
|
||||
|
||||
let mut cues = Vec::new();
|
||||
for (token, start, end) in raw {
|
||||
let resolved = match demo_ref(&token) {
|
||||
Some(demo) => match text.get(&demo) {
|
||||
Some(lines) => lines.join("\n"),
|
||||
None => continue, // demo id with no text on disc → skip
|
||||
},
|
||||
None => clean(&token), // already inline text
|
||||
};
|
||||
if resolved.trim().is_empty() {
|
||||
continue;
|
||||
}
|
||||
cues.push(SubCue {
|
||||
start,
|
||||
end,
|
||||
text: resolved,
|
||||
});
|
||||
}
|
||||
cues.sort_by(|a, b| a.start.partial_cmp(&b.start).unwrap_or(std::cmp::Ordering::Equal));
|
||||
cues
|
||||
}
|
||||
|
||||
/// The `MSG_DEMO_<id>` ids a movie's timing track references, in track order
|
||||
/// (empty for inline-text or absent tracks). Language-independent — the same
|
||||
/// demo ids appear in every `<lang>.pak`. Used to share a voice clip between
|
||||
/// movies that play the same demo line (the resupply cutscenes reuse one clip
|
||||
/// per line while only the video differs).
|
||||
pub fn track_demo_ids(lang_pak: &PakArchive, movie_basename: &str) -> Vec<u32> {
|
||||
let Some(Ok(track)) = lang_pak.read_by_hash(track_key(movie_basename)) else {
|
||||
return Vec::new();
|
||||
};
|
||||
if !is_ixud(&track) {
|
||||
return Vec::new();
|
||||
}
|
||||
parse_track(&track)
|
||||
.iter()
|
||||
.filter_map(|(t, _, _)| demo_ref(t))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Per-line `(demo id, start seconds)` for a movie's timing track — the radio-box
|
||||
/// voice schedule. Each `MSG_DEMO_<id>` reference takes the start time of the
|
||||
/// timing that follows it (a caption may list two demo lines under one timing;
|
||||
/// both then share that start). Empty for inline-text / absent tracks (those are
|
||||
/// story movies whose voice is the single manifest `VOICETRACK`, not per-line).
|
||||
pub fn track_voice_cues(lang_pak: &PakArchive, movie_basename: &str) -> Vec<(u32, f32)> {
|
||||
let Some(Ok(track)) = lang_pak.read_by_hash(track_key(movie_basename)) else {
|
||||
return Vec::new();
|
||||
};
|
||||
if !is_ixud(&track) {
|
||||
return Vec::new();
|
||||
}
|
||||
let toks = utf16le_tokens(&track);
|
||||
let start = toks
|
||||
.iter()
|
||||
.position(|t| t.ends_with("SUBTITLE"))
|
||||
.map(|i| i + 1)
|
||||
.unwrap_or(0);
|
||||
let mut out = Vec::new();
|
||||
let mut pending: Vec<u32> = Vec::new();
|
||||
for tok in &toks[start..] {
|
||||
match parse_timing(tok) {
|
||||
Some((s, _)) => {
|
||||
for d in pending.drain(..) {
|
||||
out.push((d, s));
|
||||
}
|
||||
}
|
||||
None => {
|
||||
if let Some(d) = demo_ref(tok) {
|
||||
pending.push(d);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Build `demo id → ordered caption lines` from a `GP_MAIN_GAME_<L>` pack.
|
||||
///
|
||||
/// Scans every IXUD block, pairing each text token with the immediately
|
||||
/// following `MSG_DEMO_<demo>_<page>_<line>` key, and groups the lines per demo
|
||||
/// ordered by (page, line).
|
||||
pub fn build_demo_text(text_pak: &PakArchive) -> BTreeMap<u32, Vec<String>> {
|
||||
// demo -> (page,line) -> text
|
||||
let mut by_demo: BTreeMap<u32, BTreeMap<(u32, u32), String>> = BTreeMap::new();
|
||||
for entry in text_pak.entries() {
|
||||
let Ok(bytes) = text_pak.read(entry) else {
|
||||
continue;
|
||||
};
|
||||
if !is_ixud(&bytes) {
|
||||
continue;
|
||||
}
|
||||
let toks = utf16le_tokens(&bytes);
|
||||
for w in toks.windows(2) {
|
||||
if let Some((demo, page, line)) = text_key(&w[1]) {
|
||||
// Pair only when the preceding token is real text — not another
|
||||
// MSG_DEMO key (bare keys are also serialized consecutively in the
|
||||
// record directory, which would otherwise masquerade as text).
|
||||
if demo_ref(&w[0]).is_none()
|
||||
&& text_key(&w[0]).is_none()
|
||||
&& !w[0].trim().is_empty()
|
||||
{
|
||||
by_demo
|
||||
.entry(demo)
|
||||
.or_default()
|
||||
.insert((page, line), clean(&w[0]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
by_demo
|
||||
.into_iter()
|
||||
.map(|(d, m)| (d, m.into_values().collect()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Parse a timing track's IXUD payload into `(token, start, end)` triples, where
|
||||
/// `token` is either a `MSG_DEMO_<d>` reference or an inline caption string.
|
||||
///
|
||||
/// A single on-screen caption may be stored as **several consecutive text
|
||||
/// tokens** followed by one timing (the source hard-splits a multi-line caption
|
||||
/// into one token per line — e.g. `"Look at it father"` + `"& beautiful isn't
|
||||
/// it"` share the `01:14.80-01:17.60` timing). We therefore accumulate every
|
||||
/// text token seen since the last timing and join them with a newline when the
|
||||
/// timing arrives, instead of pairing strictly 1:1 (which silently dropped every
|
||||
/// line but the last of a multi-line caption).
|
||||
fn parse_track(ixud: &[u8]) -> Vec<(String, f32, Option<f32>)> {
|
||||
let toks = utf16le_tokens(ixud);
|
||||
let start = toks
|
||||
.iter()
|
||||
.position(|t| t.ends_with("SUBTITLE"))
|
||||
.map(|i| i + 1)
|
||||
.unwrap_or(0);
|
||||
let rest = &toks[start..];
|
||||
let mut out = Vec::new();
|
||||
let mut pending: Vec<&str> = Vec::new();
|
||||
for tok in rest {
|
||||
match parse_timing(tok) {
|
||||
Some((s, e)) => {
|
||||
if !pending.is_empty() {
|
||||
out.push((pending.join("\n"), s, e));
|
||||
pending.clear();
|
||||
}
|
||||
}
|
||||
None => pending.push(tok),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn is_ixud(b: &[u8]) -> bool {
|
||||
b.len() >= 4 && &b[0..4] == b"IXUD"
|
||||
}
|
||||
|
||||
/// Normalize a caption string: the source stores line breaks as the literal
|
||||
/// two-character escape `\n`; turn it into a real newline and trim.
|
||||
fn clean(s: &str) -> String {
|
||||
s.replace("\\n", "\n").trim().to_string()
|
||||
}
|
||||
|
||||
/// `MSG_DEMO_<d>` → `Some(d)` (reference token, no page/line).
|
||||
fn demo_ref(t: &str) -> Option<u32> {
|
||||
let rest = t.strip_prefix("MSG_DEMO_")?;
|
||||
if rest.contains('_') {
|
||||
return None; // that's a text key (has page/line), not a bare reference
|
||||
}
|
||||
rest.parse().ok()
|
||||
}
|
||||
|
||||
/// `MSG_DEMO_<d>_<page>_<line>` → `Some((d,page,line))` (text key).
|
||||
fn text_key(t: &str) -> Option<(u32, u32, u32)> {
|
||||
let rest = t.strip_prefix("MSG_DEMO_")?;
|
||||
let mut it = rest.split('_');
|
||||
let d = it.next()?.parse().ok()?;
|
||||
let p = it.next()?.parse().ok()?;
|
||||
let l = it.next()?.parse().ok()?;
|
||||
if it.next().is_some() {
|
||||
return None;
|
||||
}
|
||||
Some((d, p, l))
|
||||
}
|
||||
|
||||
/// Extract UTF-16**LE** text runs from a blob, **independent of byte alignment**.
|
||||
///
|
||||
/// The IXUD string pool packs records at odd byte offsets, so a fixed 2-byte
|
||||
/// stride from the block start misreads every character. Instead we scan a
|
||||
/// sliding window, decoding each 16-bit LE unit and keeping runs of "text-like"
|
||||
/// code points (ASCII, Latin-1 supplement — the German umlauts / accented
|
||||
/// Latin — and Latin Extended-A). A non-text unit ends the run and we advance by
|
||||
/// one byte to re-lock onto the correct parity of the next run. Accepting the
|
||||
/// Latin ranges (not just ASCII) is what keeps `müsste`, `Français`, `español`
|
||||
/// intact — earlier the accented char *and its predecessor* were dropped.
|
||||
///
|
||||
/// CJK (Japanese) is deliberately out of range: those units also occur as noise
|
||||
/// at the wrong parity, and the UI font can't render them anyway.
|
||||
fn utf16le_tokens(bytes: &[u8]) -> Vec<String> {
|
||||
let mut tokens = Vec::new();
|
||||
let mut cur = String::new();
|
||||
let mut i = 0;
|
||||
while i + 1 < bytes.len() {
|
||||
let u = u16::from_le_bytes([bytes[i], bytes[i + 1]]);
|
||||
if is_text_unit(u) {
|
||||
if let Some(c) = char::from_u32(u as u32) {
|
||||
cur.push(c);
|
||||
}
|
||||
i += 2;
|
||||
} else {
|
||||
if cur.chars().count() >= 2 {
|
||||
tokens.push(std::mem::take(&mut cur));
|
||||
} else {
|
||||
cur.clear();
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
if cur.chars().count() >= 2 {
|
||||
tokens.push(cur);
|
||||
}
|
||||
tokens
|
||||
}
|
||||
|
||||
/// Whether a UTF-16 unit is a printable Latin text character we keep in a run.
|
||||
/// Excludes the C0/C1 control blocks (incl. 0x7F–0x9F) so binary noise breaks
|
||||
/// runs instead of joining them.
|
||||
fn is_text_unit(u: u16) -> bool {
|
||||
matches!(u, 0x20..=0x7e | 0xa0..=0xff | 0x100..=0x17f)
|
||||
}
|
||||
|
||||
/// Parse `MM:SS.ss` or a `start-end` range into seconds.
|
||||
fn parse_timing(s: &str) -> Option<(f32, Option<f32>)> {
|
||||
let one = |p: &str| -> Option<f32> {
|
||||
let (mm, ss) = p.trim().split_once(':')?;
|
||||
let m: f32 = if mm.trim().is_empty() {
|
||||
0.0
|
||||
} else {
|
||||
mm.trim().parse().ok()?
|
||||
};
|
||||
let sec: f32 = ss.trim().parse().ok()?;
|
||||
Some(m * 60.0 + sec)
|
||||
};
|
||||
match s.split_once('-') {
|
||||
Some((a, b)) => Some((one(a)?, Some(one(b)?))),
|
||||
None => Some((one(s)?, None)),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn track_key_matches_disc() {
|
||||
// Verified against dat/movie/eng.pak.
|
||||
assert_eq!(track_key("S00A"), 0x6F2D_9663);
|
||||
assert_eq!(track_key("hokyu_DS_s02A"), 0x3662_B1F8);
|
||||
assert_eq!(track_key("RT01C_1"), 0x756F_69FB);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn demo_and_text_keys() {
|
||||
assert_eq!(demo_ref("MSG_DEMO_192"), Some(192));
|
||||
assert_eq!(demo_ref("MSG_DEMO_604_000_00"), None);
|
||||
assert_eq!(text_key("MSG_DEMO_604_000_01"), Some((604, 0, 1)));
|
||||
assert_eq!(text_key("MSG_DEMO_192"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_latin1_accents() {
|
||||
// "müsste" must survive intact (umlaut + its neighbour), not collapse to
|
||||
// "sste". Encode as UTF-16LE at an ODD start offset to exercise the
|
||||
// alignment-independent scan.
|
||||
let mut b = vec![0xAAu8]; // 1 junk byte → strings start at an odd offset
|
||||
for s in ["müsste", "Français", "español"] {
|
||||
for u in s.encode_utf16() {
|
||||
b.extend_from_slice(&u.to_le_bytes());
|
||||
}
|
||||
b.extend_from_slice(&[0, 0]);
|
||||
}
|
||||
let toks = utf16le_tokens(&b);
|
||||
assert!(toks.contains(&"müsste".to_string()), "got {toks:?}");
|
||||
assert!(toks.contains(&"Français".to_string()), "got {toks:?}");
|
||||
assert!(toks.contains(&"español".to_string()), "got {toks:?}");
|
||||
}
|
||||
|
||||
/// Build a synthetic UTF-16LE IXUD and check the LE token walk + timing pair.
|
||||
#[test]
|
||||
fn parses_le_track() {
|
||||
let mut b = b"IXUD".to_vec();
|
||||
b.extend_from_slice(&[0, 1, 0, 0, 0x70, 0x3E, 0xC8, 0x6C]);
|
||||
for t in ["SUBTITLE", "MSG_DEMO_5", "00:01.50", "Hello", "00:03.00"] {
|
||||
for u in t.encode_utf16() {
|
||||
b.extend_from_slice(&u.to_le_bytes());
|
||||
}
|
||||
b.extend_from_slice(&[0, 0]);
|
||||
}
|
||||
let raw = parse_track(&b);
|
||||
assert_eq!(raw.len(), 2);
|
||||
assert_eq!(raw[0], ("MSG_DEMO_5".to_string(), 1.5, None));
|
||||
assert_eq!(raw[1], ("Hello".to_string(), 3.0, None));
|
||||
}
|
||||
|
||||
/// Two text tokens before a single timing = one two-line caption; the first
|
||||
/// line must NOT be dropped (the real S13A `Look at it father` regression).
|
||||
#[test]
|
||||
fn joins_multiline_caption() {
|
||||
let mut b = b"IXUD".to_vec();
|
||||
b.extend_from_slice(&[0, 1, 0, 0, 0x70, 0x3E, 0xC8, 0x6C]);
|
||||
for t in [
|
||||
"SUBTITLE",
|
||||
"That is such magnificent power.",
|
||||
"01:09.70-01:12.20",
|
||||
"Look at it father",
|
||||
"& beautiful isn't it",
|
||||
"01:14.80-01:17.60",
|
||||
] {
|
||||
for u in t.encode_utf16() {
|
||||
b.extend_from_slice(&u.to_le_bytes());
|
||||
}
|
||||
b.extend_from_slice(&[0, 0]);
|
||||
}
|
||||
let raw = parse_track(&b);
|
||||
assert_eq!(raw.len(), 2);
|
||||
assert_eq!(raw[0].0, "That is such magnificent power.");
|
||||
assert_eq!(
|
||||
raw[1].0, "Look at it father\n& beautiful isn't it",
|
||||
"both lines of the caption must be kept"
|
||||
);
|
||||
assert_eq!((raw[1].1, raw[1].2), (74.8, Some(77.6)));
|
||||
}
|
||||
}
|
||||
@@ -1,142 +0,0 @@
|
||||
//! Cutscene-voice resolution: movie → sound-id → continuous-stream byte region.
|
||||
//!
|
||||
//! Reverse-engineered 2026-07-22 (Canary file-I/O trace, user-confirmed by ear).
|
||||
//! The movie voices form **one continuous XMA stream**, physically chunked into
|
||||
//! `<lang>\Movie\VOICE_*.slb` `sound.pak` TOC entries whose boundaries do **not**
|
||||
//! align with the cutscene cues — a single cue routinely spans two `.slb` chunks,
|
||||
//! so a `.slb` does not necessarily hold the track its name claims. Each cue's
|
||||
//! audio ends at an inline **trailer descriptor** `(sound_id: u32be, 0x11, …)`
|
||||
//! whose id repeats at +0x800. Cue N's audio = the stream bytes
|
||||
//! `[descriptor(N-1) .. descriptor(N)]`, read continuously across chunk
|
||||
//! boundaries. Verified: decoded voice length matches each movie within ~0.3 s,
|
||||
//! including cross-boundary cues (RT01B/RT01C span `VOICE_ADV`→`VOICE_RT01A`→…).
|
||||
//!
|
||||
//! Resolution chain:
|
||||
//! 1. movie → cue name (`ADVERTISE_MOVIE` manifest `VOICETRACK`, e.g. `VOICE_RT01A`)
|
||||
//! 2. cue name → sound-id (master sound registry, [`registry_voice_ids`], → 1601)
|
||||
//! 3. sound-id → `[start, end]` global offsets via [`find_descriptor`] over the
|
||||
//! `sound.pNN` stream (the caller supplies the bytes + the physical anchor).
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// Parse the master sound registry — the large per-language `tables.pak` IDXD
|
||||
/// entry (schema `0x13cb84ba`) that carries the `<lang>\Movie\VOICE_*.slb` paths —
|
||||
/// into `cue-name → sound-id` from its `NAME\0 ID\0` string pool
|
||||
/// (e.g. `VOICE_ADV`→1600, `VOICE_RT01A`→1601).
|
||||
pub fn registry_voice_ids(registry: &[u8]) -> HashMap<String, u32> {
|
||||
let mut toks: Vec<&[u8]> = Vec::new();
|
||||
let mut start = 0usize;
|
||||
for i in 0..registry.len() {
|
||||
if registry[i] == 0 {
|
||||
if i > start {
|
||||
toks.push(®istry[start..i]);
|
||||
}
|
||||
start = i + 1;
|
||||
}
|
||||
}
|
||||
let mut out = HashMap::new();
|
||||
for w in toks.windows(2) {
|
||||
let (name, num) = (w[0], w[1]);
|
||||
if name.starts_with(b"VOICE_")
|
||||
&& !num.is_empty()
|
||||
&& num.iter().all(u8::is_ascii_digit)
|
||||
{
|
||||
if let (Ok(n), Ok(id)) = (
|
||||
std::str::from_utf8(name),
|
||||
std::str::from_utf8(num).unwrap().parse::<u32>(),
|
||||
) {
|
||||
out.entry(n.to_string()).or_insert(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The constant marker following a cue's sound-id in its inline trailer.
|
||||
const DESC_MARK: u32 = 0x11;
|
||||
/// The trailer repeats its id this many bytes later; used to reject a coincidental
|
||||
/// `(id, 0x11)` pair inside XMA audio (probability of a false match is ~2⁻⁶⁴).
|
||||
const DESC_REPEAT: usize = 0x800;
|
||||
|
||||
/// Byte offset (within `buf`, a slice of the continuous voice stream) of cue
|
||||
/// `id`'s trailer descriptor: the first big-endian `(id, 0x11)` pair whose id
|
||||
/// repeats at `+0x800`. `None` if absent in the slice.
|
||||
pub fn find_descriptor(buf: &[u8], id: u32) -> Option<usize> {
|
||||
if buf.len() < DESC_REPEAT + 4 {
|
||||
return None;
|
||||
}
|
||||
let be = |o: usize| u32::from_be_bytes([buf[o], buf[o + 1], buf[o + 2], buf[o + 3]]);
|
||||
let end = buf.len() - (DESC_REPEAT + 4);
|
||||
let mut o = 0;
|
||||
while o <= end {
|
||||
if be(o) == id && be(o + 4) == DESC_MARK && be(o + DESC_REPEAT) == id {
|
||||
return Some(o);
|
||||
}
|
||||
o += 4;
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Plausible sound-id range for a trailer (all real cue ids are well under this).
|
||||
const ID_MAX: u32 = 0x1_0000;
|
||||
|
||||
/// Offset of the nearest cue trailer strictly **before** `before` — any plausible
|
||||
/// id. Used to bound a cue's START when its `id-1` predecessor doesn't exist
|
||||
/// (the sound-id sequence has gaps, e.g. `VOICE_D_453`=7142 → `VOICE_D_454`=7188).
|
||||
/// Scans downward and returns the first (largest-offset) valid `(id, 0x11)` with
|
||||
/// the `+0x800` id-repeat. `None` if there is no trailer below `before`.
|
||||
pub fn find_descriptor_before(buf: &[u8], before: usize) -> Option<usize> {
|
||||
if before < 4 {
|
||||
return None;
|
||||
}
|
||||
let cap = buf.len().checked_sub(DESC_REPEAT + 4)?;
|
||||
let be = |o: usize| u32::from_be_bytes([buf[o], buf[o + 1], buf[o + 2], buf[o + 3]]);
|
||||
// Start strictly below `before` (4-aligned) so the target's own trailer is
|
||||
// never returned as its predecessor.
|
||||
let mut o = (before - 1).min(cap) & !3;
|
||||
loop {
|
||||
let id = be(o);
|
||||
if id >= 1 && id < ID_MAX && be(o + 4) == DESC_MARK && be(o + DESC_REPEAT) == id {
|
||||
return Some(o);
|
||||
}
|
||||
if o < 4 {
|
||||
return None;
|
||||
}
|
||||
o -= 4;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn registry_parses_name_id_pairs() {
|
||||
let mut b = Vec::new();
|
||||
for tok in [
|
||||
b"VOICE_ADV".as_slice(),
|
||||
b"1600",
|
||||
b"VOICE_RT01A",
|
||||
b"1601",
|
||||
b"NOT_A_VOICE",
|
||||
b"9",
|
||||
] {
|
||||
b.extend_from_slice(tok);
|
||||
b.push(0);
|
||||
}
|
||||
let ids = registry_voice_ids(&b);
|
||||
assert_eq!(ids.get("VOICE_ADV"), Some(&1600));
|
||||
assert_eq!(ids.get("VOICE_RT01A"), Some(&1601));
|
||||
assert_eq!(ids.get("NOT_A_VOICE"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn find_descriptor_matches_repeat() {
|
||||
let mut b = vec![0u8; 0x900];
|
||||
b[0..4].copy_from_slice(&1601u32.to_be_bytes());
|
||||
b[4..8].copy_from_slice(&0x11u32.to_be_bytes());
|
||||
b[DESC_REPEAT..DESC_REPEAT + 4].copy_from_slice(&1601u32.to_be_bytes());
|
||||
assert_eq!(find_descriptor(&b, 1601), Some(0));
|
||||
assert_eq!(find_descriptor(&b, 1600), None);
|
||||
}
|
||||
}
|
||||
@@ -178,18 +178,6 @@ impl PakArchive {
|
||||
})
|
||||
}
|
||||
|
||||
/// Parse **only** the TOC from a `.pak` index, without any segment data.
|
||||
///
|
||||
/// For huge archives (`sound.pak` is ~1 GB across `.p00..p04`) this lets a
|
||||
/// caller locate one entry's `(offset, size)` and read just that byte range
|
||||
/// from the segments, instead of loading the whole thing into memory. The
|
||||
/// returned entries are sorted by `name_hash` (binary-searchable).
|
||||
pub fn parse_toc(index: &[u8]) -> Result<Vec<PakEntry>, PakError> {
|
||||
// Reuse from_parts' validation with an empty data blob; the entries are
|
||||
// independent of the data.
|
||||
Ok(Self::from_parts(index, Vec::new())?.entries)
|
||||
}
|
||||
|
||||
/// All TOC entries, in stored order (ascending `name_hash`).
|
||||
pub fn entries(&self) -> &[PakEntry] {
|
||||
&self.entries
|
||||
|
||||
@@ -1,649 +0,0 @@
|
||||
//! Whole-ship assembly from XBG7 part families.
|
||||
//!
|
||||
//! Project Sylpheed's capital ships are never stored as a single mesh. A ship is
|
||||
//! modelled, then **split into destructible parts** — hull segments, bridge,
|
||||
//! engines, integral turrets — each shipped as its own XBG7 resource inside a
|
||||
//! `hidden/resource3d/Stage_SNN.xpr` container. The split lets the game hide a
|
||||
//! part when the player destroys it (bridge, shield generator, thruster) and swap
|
||||
//! in a `_break` variant.
|
||||
//!
|
||||
//! Each part's vertices are authored around the origin; the world placement lives
|
||||
//! in the **primary composite scene graph** `e_rou_<id>` (see [`assemble_ship`]).
|
||||
//! Its node hierarchy (`rou_<id>_root`→`…_front`/`…_rear`→`rou_<id>_bdy_NN`) names
|
||||
//! the separate hull resources and carries their world TRS — the cross-resource
|
||||
//! analogue of how [`mesh::node_transforms`] poses one model's sub-parts. The
|
||||
//! `GN_*` nodes in the same composite are the Vessel hardpoint frames (bridge /
|
||||
//! shield / engine / turret mounts, matching the IDXD recipe `Frame` names).
|
||||
//!
|
||||
//! Resource naming (learned from the retail stage containers):
|
||||
//! - `<id>` is `[a-z]NNN` (`e106`, `f105`, `n050`). The leading letter is the
|
||||
//! faction: `e` = ADAN (enemy), `f` = TCAF (player side), `n` = neutral /
|
||||
//! structures / debris.
|
||||
//! - A base part is `<id>_<name>` (`e106_bdy_01`, `e106_brg_01`, `f105_sld_02`).
|
||||
//! - `_l` / `_m` / `_d`(`NN`) suffixes are lower level-of-detail copies; `_bNN` /
|
||||
//! `_dead` / `_break` are destruction geometry; `_joint` / `_open` / `_Near` are
|
||||
//! logic/animation nodes. All are skipped.
|
||||
//! - `e_rou_<id>` is the primary composite; `e_rou_<id>_eng` / `_wep_*` are LOCAL
|
||||
//! detail rigs (their nodes are in their own frame, not ship-space) and are NOT
|
||||
//! used for placement.
|
||||
|
||||
use crate::mesh::{scene_world_nodes, xbg7_resource_names, ScenePart};
|
||||
use std::collections::HashSet;
|
||||
|
||||
/// Which side a ship belongs to, from the first letter of its resource id.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Faction {
|
||||
/// `e…` — ADAN (the enemy).
|
||||
Adan,
|
||||
/// `f…` — TCAF (the player's coalition).
|
||||
Tcaf,
|
||||
/// `n…` — neutral: stations, structures, asteroids, debris.
|
||||
Neutral,
|
||||
/// Anything else (`j…`, `s…`, …).
|
||||
Other,
|
||||
}
|
||||
|
||||
impl Faction {
|
||||
fn from_id(id: &str) -> Faction {
|
||||
match id.as_bytes().first() {
|
||||
Some(b'e') => Faction::Adan,
|
||||
Some(b'f') => Faction::Tcaf,
|
||||
Some(b'n') => Faction::Neutral,
|
||||
_ => Faction::Other,
|
||||
}
|
||||
}
|
||||
|
||||
/// Short human label.
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
Faction::Adan => "ADAN",
|
||||
Faction::Tcaf => "TCAF",
|
||||
Faction::Neutral => "Neutral",
|
||||
Faction::Other => "Other",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A ship reconstructed from one XBG7 part family in a stage container.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ShipModel {
|
||||
/// The family id, e.g. `e106` — matches a [`crate::game_data::Vessel`] whose
|
||||
/// `model` is `rou_e106`.
|
||||
pub id: String,
|
||||
/// Faction inferred from the id's leading letter.
|
||||
pub faction: Faction,
|
||||
/// Base geometry resource names to draw together, in directory order.
|
||||
pub parts: Vec<String>,
|
||||
/// Whether a composite scene graph (`e_rou_<id>`) exists — i.e. this is a
|
||||
/// real assembled ship. Families without one (fighter morph sets, shared
|
||||
/// turret/prop parts) have no placement data and would stack at the origin.
|
||||
pub has_composite: bool,
|
||||
}
|
||||
|
||||
/// The `[a-z]NNN` id prefix of a resource name, if it has one (`e106_bdy_01`
|
||||
/// → `e106`). Returns `None` for scene/logic resources (`e_rou_e106`) and
|
||||
/// anything not starting with a letter + three digits.
|
||||
pub fn ship_id_of(resource: &str) -> Option<&str> {
|
||||
let b = resource.as_bytes();
|
||||
if b.len() >= 4
|
||||
&& b[0].is_ascii_lowercase()
|
||||
&& b[1].is_ascii_digit()
|
||||
&& b[2].is_ascii_digit()
|
||||
&& b[3].is_ascii_digit()
|
||||
{
|
||||
// Reject a longer alnum run (`e1234…`): the id is exactly letter+3 digits,
|
||||
// followed by end-of-string or a non-alphanumeric (`_`).
|
||||
if b.get(4).is_none_or(|c| !c.is_ascii_alphanumeric()) {
|
||||
return Some(&resource[..4]);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Whether a resource is a base geometry part (not a LOD copy, destruction
|
||||
/// variant, or scene/logic node) that should be drawn in a whole-ship render.
|
||||
pub fn is_base_part(resource: &str) -> bool {
|
||||
if ship_id_of(resource).is_none() {
|
||||
return false;
|
||||
}
|
||||
// Level-of-detail copies of a base part: a trailing `_l`/`_m`/`_d` token,
|
||||
// optionally with a number (`_d01`, `_l02`).
|
||||
if let Some(last) = resource.rsplit('_').next() {
|
||||
let mut cs = last.chars();
|
||||
if matches!(cs.next(), Some('l' | 'm' | 'd')) && cs.all(|c| c.is_ascii_digit()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// Destruction / logic geometry.
|
||||
if resource.contains("break")
|
||||
|| resource.contains("dead")
|
||||
|| resource.contains("_joint")
|
||||
|| resource.contains("_open")
|
||||
|| resource.contains("_Near")
|
||||
{
|
||||
return false;
|
||||
}
|
||||
// Break-piece geometry carries a bare `b` / `bNN` token (`e106_brg_01_b_02`,
|
||||
// `e108_eng_01_b01`). `bdy` etc. are safe — only an exact `b`-then-digits token
|
||||
// counts.
|
||||
if resource.split('_').skip(1).any(|t| {
|
||||
t == "b" || (t.starts_with('b') && t.len() >= 2 && t[1..].bytes().all(|c| c.is_ascii_digit()))
|
||||
}) {
|
||||
return false;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
/// Group every base part in an XPR2 container into whole ships, keyed by id.
|
||||
///
|
||||
/// Ships are returned sorted by id. A stage container also holds shared turret /
|
||||
/// prop models as their own ids — every group with at least one base part is
|
||||
/// returned; the caller can filter by [`ShipModel::parts`] length or faction.
|
||||
pub fn ships_in_container(bytes: &[u8]) -> Vec<ShipModel> {
|
||||
let names = xbg7_resource_names(bytes);
|
||||
let mut ids: Vec<String> = Vec::new();
|
||||
let mut ships: std::collections::HashMap<String, ShipModel> = std::collections::HashMap::new();
|
||||
for n in &names {
|
||||
if !is_base_part(n) {
|
||||
continue;
|
||||
}
|
||||
let id = ship_id_of(n).unwrap().to_string();
|
||||
let entry = ships.entry(id.clone()).or_insert_with(|| {
|
||||
ids.push(id.clone());
|
||||
let has_composite = !composites_for(&names, &id).is_empty();
|
||||
ShipModel {
|
||||
id: id.clone(),
|
||||
faction: Faction::from_id(&id),
|
||||
parts: Vec::new(),
|
||||
has_composite,
|
||||
}
|
||||
});
|
||||
entry.parts.push(n.clone());
|
||||
}
|
||||
ids.sort();
|
||||
ids.into_iter().map(|id| ships.remove(&id).unwrap()).collect()
|
||||
}
|
||||
|
||||
/// Map a composite scene-graph node name to the geometry resource it draws.
|
||||
/// Hull nodes are `rou_<id>_<part>[_root|_mov|_NN]`; the geometry resource is the
|
||||
/// `<id>_<part>` stem. Structural nodes (`rou_e106_front`, `…_root`) resolve to
|
||||
/// nothing and only pose their children.
|
||||
fn resolve_hull_resource(node: &str, resources: &HashSet<String>) -> Option<String> {
|
||||
let stem = node.rsplit_once("rou_").map(|(_, s)| s).unwrap_or(node);
|
||||
let try_stem = |s: &str| -> Option<String> {
|
||||
if resources.contains(s) {
|
||||
return Some(s.to_string());
|
||||
}
|
||||
// Squeezed digit run (`wep02` names the `wep_02_01` resource): insert an
|
||||
// underscore before the digits and try the `_01` first-part too.
|
||||
if let Some(pos) = s.rfind(|c: char| c.is_ascii_digit()) {
|
||||
let mut start = pos;
|
||||
while start > 0 && s.as_bytes()[start - 1].is_ascii_digit() {
|
||||
start -= 1;
|
||||
}
|
||||
if start > 0 && s.as_bytes()[start - 1] != b'_' {
|
||||
let split = format!("{}_{}", &s[..start], &s[start..]);
|
||||
if resources.contains(&split) {
|
||||
return Some(split);
|
||||
}
|
||||
let first = format!("{split}_01");
|
||||
if resources.contains(&first) {
|
||||
return Some(first);
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
};
|
||||
if let Some(r) = try_stem(stem) {
|
||||
return Some(r);
|
||||
}
|
||||
for suf in ["_root", "_mov"] {
|
||||
if let Some(s) = stem.strip_suffix(suf) {
|
||||
if let Some(r) = try_stem(s) {
|
||||
return Some(r);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Trailing `_NN` instance index (`eng_01_1` → `eng_01`).
|
||||
if let Some(pos) = stem.rfind('_') {
|
||||
if !stem[pos + 1..].is_empty() && stem[pos + 1..].bytes().all(|c| c.is_ascii_digit()) {
|
||||
if let Some(r) = try_stem(&stem[..pos]) {
|
||||
return Some(r);
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The trailing digit run of a name (`GN_Bridge_01` → `01`, `sld_02` → `02`).
|
||||
fn trailing_index(name: &str) -> &str {
|
||||
let bytes = name.as_bytes();
|
||||
let mut start = bytes.len();
|
||||
while start > 0 && bytes[start - 1].is_ascii_digit() {
|
||||
start -= 1;
|
||||
}
|
||||
&name[start..]
|
||||
}
|
||||
|
||||
/// Which stage-container resources are the composite scene graphs for ship `id`
|
||||
/// (`e_rou_e106`, `e_rou_e106_eng`, …). Excludes destruction (`_break`) scenes.
|
||||
fn composites_for<'a>(names: &'a [String], id: &str) -> Vec<&'a String> {
|
||||
let needle = format!("rou_{id}");
|
||||
names
|
||||
.iter()
|
||||
.filter(|n| {
|
||||
n.contains(&needle)
|
||||
&& ship_id_of(n).is_none()
|
||||
&& !n.contains("break")
|
||||
&& !n.contains("dead")
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Reconstruct a whole ship as a list of geometry-resource placements in a shared
|
||||
/// ship-local frame — the placement the game builds at runtime.
|
||||
///
|
||||
/// Fully static and EXACT (validated part-for-part against an e106 runtime
|
||||
/// capture — see `docs/re/ship-placement-runtime-capture.md`):
|
||||
/// 1. **Composite nodes** — every `rou_*` node in the primary composite
|
||||
/// (`e_rou_<id>`) places a geometry resource, INCLUDING repeated instances
|
||||
/// and cross-id turret mounts (`rou_e303_wep_01_root` ×2 on the e106 hull).
|
||||
/// 2. **Detail rigs** — `e_rou_<id>_eng` is the engine cluster rig; its nodes
|
||||
/// (e.g. two `eng_01` nacelle instances + `eng_02`) mount at the primary
|
||||
/// composite's `GN_Engine_01` frame: `world = frame ∘ rig_local`.
|
||||
/// 3. **GN hardpoints** — remaining unplaced `brg`/`sld` parts sit exactly at
|
||||
/// their `GN_Bridge_NN` / `GN_ShieldG_NN` frame (frames carry full TRS).
|
||||
/// 4. **Mirrored twins** — a port/starboard pair (`bdy_01`/`bdy_02`) shares one
|
||||
/// geometry; the instance whose lateral offset points the geometry's dominant
|
||||
/// side inboard is drawn X-reflected (capture-verified; det < 0 → the caller
|
||||
/// reverses winding).
|
||||
///
|
||||
/// `include_external` keeps tiers 2–4 (off = bare composite-node hull).
|
||||
pub fn assemble_ship(bytes: &[u8], id: &str, include_external: bool) -> Vec<ScenePart> {
|
||||
let names = xbg7_resource_names(bytes);
|
||||
let resources: HashSet<String> = names.iter().cloned().collect();
|
||||
|
||||
// The PRIMARY composite carries the ship-space layout (hull bodies, turret
|
||||
// mounts + every `GN_*` hardpoint frame): the one with the most nodes.
|
||||
let scenes: Vec<(String, Vec<ScenePart>)> = composites_for(&names, id)
|
||||
.into_iter()
|
||||
.filter(|c| !c.ends_with("_joint"))
|
||||
.map(|c| (c.clone(), scene_world_nodes(bytes, c)))
|
||||
.collect();
|
||||
let Some((_, nodes)) = scenes.iter().max_by_key(|(_, n)| n.len()) else {
|
||||
// No composite at all → raw fallback below.
|
||||
let mut placed = Vec::new();
|
||||
const ID: [[f32; 3]; 3] = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
|
||||
for part in names.iter().filter(|n| is_base_part(n) && ship_id_of(n) == Some(id)) {
|
||||
placed.push(ScenePart { resource: part.clone(), m: ID, t: [0.0; 3], s: [1.0; 3] });
|
||||
}
|
||||
return placed;
|
||||
};
|
||||
|
||||
let mut placed: Vec<ScenePart> = Vec::new();
|
||||
let mut placed_res: HashSet<String> = HashSet::new();
|
||||
// GN hardpoint frames, world-space, from the primary composite.
|
||||
let mut frames: Vec<ScenePart> = Vec::new();
|
||||
|
||||
// Tier 1: every composite node placement, instances included. Cross-id
|
||||
// resources (shared e303/e4NN turret models the composite mounts) count too.
|
||||
for node in nodes {
|
||||
if node.resource.starts_with("GN_") {
|
||||
frames.push(node.clone());
|
||||
} else if let Some(res) = resolve_hull_resource(&node.resource, &resources) {
|
||||
if ship_id_of(&res) != Some(id) && !include_external {
|
||||
continue; // hull-only view: own parts only
|
||||
}
|
||||
// Distinct INSTANCES keep their own placement; a nested alias of the
|
||||
// same resource at the same transform (`bdy_01_mov` + its identity
|
||||
// `bdy_01` child) collapses to one draw.
|
||||
let dup = placed.iter().any(|p| {
|
||||
p.resource == res
|
||||
&& (p.t[0] - node.t[0]).abs() < 0.01
|
||||
&& (p.t[1] - node.t[1]).abs() < 0.01
|
||||
&& (p.t[2] - node.t[2]).abs() < 0.01
|
||||
});
|
||||
if !dup {
|
||||
placed_res.insert(res.clone());
|
||||
placed.push(ScenePart { resource: res, m: node.m, t: node.t, s: node.s });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Tier 2: the engine cluster rig, mounted at GN_Engine_01. The rig's nodes
|
||||
// are in the FRAME's local space (two mirrored `eng_01` nacelles + centre
|
||||
// `eng_02` for e106) — capture-verified to 0.1 units.
|
||||
if include_external {
|
||||
let rig_name = format!("e_rou_{id}_eng");
|
||||
if names.contains(&rig_name) {
|
||||
if let Some(frame) = frames.iter().find(|f| f.resource.starts_with("GN_Engine")) {
|
||||
for rn in scene_world_nodes(bytes, &rig_name) {
|
||||
let Some(res) = resolve_hull_resource(&rn.resource, &resources) else {
|
||||
continue;
|
||||
};
|
||||
// world = frame ∘ rig_local
|
||||
let m = m3_mul_pub(frame.m, rn.m);
|
||||
let rt = m3_vec_pub(frame.m, rn.t);
|
||||
let t = [rt[0] + frame.t[0], rt[1] + frame.t[1], rt[2] + frame.t[2]];
|
||||
placed_res.insert(res.clone());
|
||||
placed.push(ScenePart { resource: res, m, t, s: rn.s });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Tier 3: remaining external parts at their exact GN frame (full TRS).
|
||||
const CATS: [(&str, &str); 3] = [("brg", "Bridge"), ("sld", "ShieldG"), ("eng", "Engine")];
|
||||
for part in names
|
||||
.iter()
|
||||
.filter(|_| include_external)
|
||||
.filter(|n| is_base_part(n) && ship_id_of(n) == Some(id))
|
||||
{
|
||||
if placed_res.contains(part) {
|
||||
continue;
|
||||
}
|
||||
let rest = &part[(id.len() + 1).min(part.len())..]; // "brg_01"
|
||||
let mut toks = rest.split('_');
|
||||
let cat = toks.next().unwrap_or("");
|
||||
let idx = toks.next().unwrap_or("");
|
||||
let Some((_, gncat)) = CATS.iter().find(|(c, _)| *c == cat) else {
|
||||
continue;
|
||||
};
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
// Tier 4: mirror one of a shared-geometry twin pair. The engine uploads the
|
||||
// second of a port/starboard pair X-reflected (capture-verified on
|
||||
// bdy_01/bdy_02): for two same-geometry resources placed at ±TX, the
|
||||
// instance whose TX sign matches the geometry's dominant-X side draws
|
||||
// mirrored (so the pair ends up symmetric instead of twice the same side).
|
||||
apply_twin_mirrors(bytes, &mut placed);
|
||||
|
||||
// Fallback for a ship with no composite scene graph (a simple prop): draw its
|
||||
// base parts untransformed rather than nothing.
|
||||
if placed.is_empty() {
|
||||
const ID: [[f32; 3]; 3] = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
|
||||
for part in names.iter().filter(|n| is_base_part(n) && ship_id_of(n) == Some(id)) {
|
||||
placed.push(ScenePart { resource: part.clone(), m: ID, t: [0.0; 3], s: [1.0; 3] });
|
||||
}
|
||||
}
|
||||
|
||||
placed
|
||||
}
|
||||
|
||||
/// The ship's exhaust mount frames (`GN_Jet_*` / `GN_SJet_*`), world-space, from
|
||||
/// the primary composite. These are where the game renders the engine exhaust
|
||||
/// FX — the visible "thrusters". The engine GEOMETRY itself sits recessed in
|
||||
/// the hull (capture-verified across 43 e106 instances: the game draws
|
||||
/// `eng_01`/`eng_02` exactly where [`assemble_ship`] puts them); without the
|
||||
/// FX the assembled ship reads engine-less, so a viewer can draw exhaust
|
||||
/// markers at these frames.
|
||||
pub fn exhaust_frames(bytes: &[u8], id: &str) -> Vec<ScenePart> {
|
||||
let names = xbg7_resource_names(bytes);
|
||||
let scenes: Vec<Vec<ScenePart>> = composites_for(&names, id)
|
||||
.into_iter()
|
||||
.filter(|c| !c.ends_with("_joint"))
|
||||
.map(|c| scene_world_nodes(bytes, c))
|
||||
.collect();
|
||||
let Some(nodes) = scenes.into_iter().max_by_key(|n| n.len()) else {
|
||||
return Vec::new();
|
||||
};
|
||||
nodes
|
||||
.into_iter()
|
||||
.filter(|n| n.resource.starts_with("GN_Jet") || n.resource.starts_with("GN_SJet"))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Detect shared-geometry port/starboard twin RESOURCES placed at ±TX and mark
|
||||
/// the dominant-side instance as an X-reflection (negate the matrix X column).
|
||||
/// Twins are `<stem>_01`/`<stem>_02` pairs with equal vertex data; the reflected
|
||||
/// one is the instance whose TX sign equals the geometry's mean-X sign (the
|
||||
/// un-reflected drawing already covers that side's opposite).
|
||||
fn apply_twin_mirrors(bytes: &[u8], placed: &mut [ScenePart]) {
|
||||
use crate::mesh::Xbg7Model;
|
||||
// Candidate pairs: resources differing only in a trailing _01/_02, both
|
||||
// placed exactly once, at opposite-sign TX of equal magnitude.
|
||||
let mut pairs: Vec<(usize, usize)> = Vec::new();
|
||||
for i in 0..placed.len() {
|
||||
let a = &placed[i];
|
||||
let Some(stem) = a.resource.strip_suffix("_01") else { continue };
|
||||
let twin = format!("{stem}_02");
|
||||
let Some(j) = placed.iter().position(|p| p.resource == twin) else { continue };
|
||||
let b = &placed[j];
|
||||
if (a.t[0] + b.t[0]).abs() < 0.5 && a.t[0].abs() > 1.0 {
|
||||
pairs.push((i, j));
|
||||
}
|
||||
}
|
||||
if pairs.is_empty() {
|
||||
return;
|
||||
}
|
||||
let want: HashSet<String> = pairs
|
||||
.iter()
|
||||
.flat_map(|&(i, j)| [placed[i].resource.clone(), placed[j].resource.clone()])
|
||||
.collect();
|
||||
let models = Xbg7Model::models_named(bytes, &want, &|| false);
|
||||
for (i, j) in pairs {
|
||||
let get = |r: &str| models.iter().find(|m| m.name == r);
|
||||
let (Some(ma), Some(mb)) = (get(&placed[i].resource), get(&placed[j].resource)) else {
|
||||
continue;
|
||||
};
|
||||
let first = |m: &Xbg7Model| -> Vec<[f32; 3]> {
|
||||
m.meshes.iter().flat_map(|s| s.positions.iter().copied()).take(16).collect()
|
||||
};
|
||||
let (fa, fb) = (first(ma), first(mb));
|
||||
if fa.len() != fb.len()
|
||||
|| !fa.iter().zip(&fb).all(|(p, q)| {
|
||||
(p[0] - q[0]).abs() < 1e-3 && (p[1] - q[1]).abs() < 1e-3 && (p[2] - q[2]).abs() < 1e-3
|
||||
})
|
||||
{
|
||||
continue; // distinct (already-mirrored) geometries — nothing to do
|
||||
}
|
||||
let mean_x: f32 = ma
|
||||
.meshes
|
||||
.iter()
|
||||
.flat_map(|s| s.positions.iter())
|
||||
.map(|p| p[0])
|
||||
.sum::<f32>()
|
||||
/ ma.meshes.iter().map(|s| s.positions.len()).sum::<usize>().max(1) as f32;
|
||||
if mean_x.abs() < 1e-3 {
|
||||
continue; // symmetric geometry — mirroring is a no-op
|
||||
}
|
||||
// Reflect the instance whose lateral offset OPPOSES the geometry's
|
||||
// dominant side (drawn plain it would fold onto the centreline; the
|
||||
// capture shows the engine reflects exactly this one — for e106 the
|
||||
// −264 port instance draws the file data plain, the +264 one mirrored).
|
||||
let k = if (placed[i].t[0] > 0.0) == (mean_x > 0.0) { j } else { i };
|
||||
for row in &mut placed[k].m {
|
||||
row[0] = -row[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Small helpers mirroring mesh.rs's private affine ops.
|
||||
fn m3_mul_pub(a: [[f32; 3]; 3], b: [[f32; 3]; 3]) -> [[f32; 3]; 3] {
|
||||
let mut o = [[0.0f32; 3]; 3];
|
||||
for r in 0..3 {
|
||||
for c in 0..3 {
|
||||
o[r][c] = a[r][0] * b[0][c] + a[r][1] * b[1][c] + a[r][2] * b[2][c];
|
||||
}
|
||||
}
|
||||
o
|
||||
}
|
||||
fn m3_vec_pub(a: [[f32; 3]; 3], v: [f32; 3]) -> [f32; 3] {
|
||||
[
|
||||
a[0][0] * v[0] + a[0][1] * v[1] + a[0][2] * v[2],
|
||||
a[1][0] * v[0] + a[1][1] * v[1] + a[1][2] * v[2],
|
||||
a[2][0] * v[0] + a[2][1] * v[1] + a[2][2] * v[2],
|
||||
]
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn id_extraction() {
|
||||
assert_eq!(ship_id_of("e106_bdy_01"), Some("e106"));
|
||||
assert_eq!(ship_id_of("f105_sld_02_l"), Some("f105"));
|
||||
assert_eq!(ship_id_of("e_rou_e106"), None);
|
||||
assert_eq!(ship_id_of("_rou_e106_break"), None);
|
||||
assert_eq!(ship_id_of("Base"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn base_part_filter() {
|
||||
assert!(is_base_part("e106_bdy_01"));
|
||||
assert!(is_base_part("e106_brg_01"));
|
||||
assert!(is_base_part("f105_wep_02_01"));
|
||||
assert!(!is_base_part("e106_bdy_01_l")); // LOD
|
||||
assert!(!is_base_part("e106_bdy_01_m")); // LOD
|
||||
assert!(!is_base_part("e106_brg_01_b_02")); // break piece
|
||||
assert!(!is_base_part("_rou_e106_break")); // logic
|
||||
assert!(!is_base_part("e_rou_e106")); // scene node
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn faction_from_id() {
|
||||
assert_eq!(Faction::from_id("e106"), Faction::Adan);
|
||||
assert_eq!(Faction::from_id("f105"), Faction::Tcaf);
|
||||
assert_eq!(Faction::from_id("n050"), Faction::Neutral);
|
||||
assert_eq!(Faction::from_id("j004"), Faction::Other);
|
||||
}
|
||||
|
||||
// Disc-gated: reconstruct the ADAN cruiser family from a real stage container.
|
||||
#[test]
|
||||
fn ships_from_real_stage() {
|
||||
let Ok(iso) = std::env::var("SYLPHEED_ISO") else {
|
||||
eprintln!("SYLPHEED_ISO unset — skipping");
|
||||
return;
|
||||
};
|
||||
let bytes = {
|
||||
use crate::xiso::open_iso;
|
||||
let rt = tokio::runtime::Builder::new_current_thread().build().unwrap();
|
||||
rt.block_on(async {
|
||||
let mut r = open_iso(std::path::Path::new(&iso)).await.unwrap();
|
||||
r.read_file("hidden/resource3d/Stage_S02.xpr").await.unwrap()
|
||||
})
|
||||
};
|
||||
let ships = ships_in_container(&bytes);
|
||||
assert!(!ships.is_empty(), "stage should hold ships");
|
||||
// The ADAN frigate e108 appears in S02 with hull + engine + weapon parts.
|
||||
let e108 = ships.iter().find(|s| s.id == "e108").expect("e108 present");
|
||||
assert_eq!(e108.faction, Faction::Adan);
|
||||
assert!(e108.parts.iter().any(|p| p.contains("_bdy_")));
|
||||
assert!(e108.parts.iter().all(|p| is_base_part(p)));
|
||||
}
|
||||
|
||||
// Disc-gated GROUND-TRUTH test: the fully-static assembly must reproduce the
|
||||
// runtime F10 capture (the baked e106 table) part-for-part — translations
|
||||
// AND the engine-rig rotation — plus the multi-instance parts the capture's
|
||||
// vbase-dedup could not see (two nacelles, two turrets).
|
||||
#[test]
|
||||
fn static_assembly_matches_runtime_capture() {
|
||||
let Ok(iso) = std::env::var("SYLPHEED_ISO") else {
|
||||
eprintln!("SYLPHEED_ISO unset — skipping");
|
||||
return;
|
||||
};
|
||||
let bytes = {
|
||||
use crate::xiso::open_iso;
|
||||
let rt = tokio::runtime::Builder::new_current_thread().build().unwrap();
|
||||
rt.block_on(async {
|
||||
let mut r = open_iso(std::path::Path::new(&iso)).await.unwrap();
|
||||
r.read_file("hidden/resource3d/Stage_S01.xpr").await.unwrap()
|
||||
})
|
||||
};
|
||||
let placed = assemble_ship(&bytes, "e106", true);
|
||||
let cap = crate::ship_capture::embedded_placement("e106").expect("e106 baked");
|
||||
// Express static placements relative to bdy_04 (the capture's reference).
|
||||
let r4 = placed
|
||||
.iter()
|
||||
.find(|p| p.resource == "e106_bdy_04")
|
||||
.expect("bdy_04 placed")
|
||||
.clone();
|
||||
let rel = |p: &crate::mesh::ScenePart| -> [f32; 3] {
|
||||
[p.t[0] - r4.t[0], p.t[1] - r4.t[1], p.t[2] - r4.t[2]]
|
||||
};
|
||||
for want in &cap.parts {
|
||||
let best = placed
|
||||
.iter()
|
||||
.filter(|p| p.resource == want.part)
|
||||
.map(|p| {
|
||||
let t = rel(p);
|
||||
let d = (t[0] - want.t[0]).abs()
|
||||
+ (t[1] - want.t[1]).abs()
|
||||
+ (t[2] - want.t[2]).abs();
|
||||
(d, p)
|
||||
})
|
||||
.min_by(|a, b| a.0.partial_cmp(&b.0).unwrap())
|
||||
.unwrap_or_else(|| panic!("{} not placed statically", want.part));
|
||||
assert!(
|
||||
best.0 < 1.0,
|
||||
"{}: static rel-T {:?} != captured {:?} (Δ={:.2})",
|
||||
want.part,
|
||||
rel(best.1),
|
||||
want.t,
|
||||
best.0
|
||||
);
|
||||
// Rotations must match too (the engine rig is the interesting case).
|
||||
let m = &best.1.m;
|
||||
for r in 0..3 {
|
||||
for c in 0..3 {
|
||||
assert!(
|
||||
(m[r][c] - want.m[r][c]).abs() < 0.02,
|
||||
"{}: static M row{r} {:?} != captured {:?}",
|
||||
want.part,
|
||||
m[r],
|
||||
want.m[r]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
// 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");
|
||||
// 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 mirrored");
|
||||
assert!(det(&one("e106_bdy_01").m) > 0.0, "port hull plain");
|
||||
}
|
||||
|
||||
// Disc-gated: the scene graph must SPREAD a ship's parts, not stack them at
|
||||
// the origin. Reconstruct the ADAN frigate e106 and assert its bridge sits
|
||||
// clearly aft of its forward hull body (a real ship layout, not a pile).
|
||||
#[test]
|
||||
fn assemble_spreads_parts() {
|
||||
let Ok(iso) = std::env::var("SYLPHEED_ISO") else {
|
||||
eprintln!("SYLPHEED_ISO unset — skipping");
|
||||
return;
|
||||
};
|
||||
let bytes = {
|
||||
use crate::xiso::open_iso;
|
||||
let rt = tokio::runtime::Builder::new_current_thread().build().unwrap();
|
||||
rt.block_on(async {
|
||||
let mut r = open_iso(std::path::Path::new(&iso)).await.unwrap();
|
||||
r.read_file("hidden/resource3d/Stage_S02.xpr").await.unwrap()
|
||||
})
|
||||
};
|
||||
let placed = assemble_ship(&bytes, "e106", true);
|
||||
assert!(placed.len() >= 5, "e106 should place its hull + external parts");
|
||||
// The forward hull body and the bridge must land at distinct fore/aft Z.
|
||||
let z = |res: &str| placed.iter().find(|p| p.resource == res).map(|p| p.t[2]);
|
||||
let bdy = z("e106_bdy_01").expect("bdy_01 placed");
|
||||
let brg = z("e106_brg_01").expect("brg_01 placed at its GN_Bridge frame");
|
||||
assert!(
|
||||
(bdy - brg).abs() > 200.0,
|
||||
"bridge ({brg}) and forward body ({bdy}) must be far apart, not stacked"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,694 +0,0 @@
|
||||
//! Exact capital-ship part placement from a Canary **F10 ship-capture** log —
|
||||
//! the runtime ground truth that static [`crate::ship::assemble_ship`] only
|
||||
//! approximates for external parts.
|
||||
//!
|
||||
//! ## Why a capture is needed
|
||||
//!
|
||||
//! A captured part's vertex BUFFER holds **local** coordinates (byte-identical to
|
||||
//! the `.xpr`), so capital-ship parts are placed **entirely in the vertex shader**
|
||||
//! — the buffer carries no placement. The per-part transform lives in the ship
|
||||
//! shader's **vertex float constants**: `c0..c2` are the **WorldViewProjection**
|
||||
//! matrix rows. Each row's norm is `(sx, sy, 1)` (the projection x/y scales, with
|
||||
//! `sy/sx ≈ 1.78 = 16:9`); dividing a row by its norm yields the rigid
|
||||
//! **WorldView** row (verified orthonormal, `det = +1`) and `row[3]/norm` is that
|
||||
//! axis' view-space translation.
|
||||
//!
|
||||
//! The camera View cancels when every part is expressed relative to a **reference
|
||||
//! part**: `rel_p = WV_ref⁻¹ · WV_p = (Rᵀ_ref·R_p , Rᵀ_ref·(T_p − T_ref))` — a pure
|
||||
//! ship-space rigid transform. That is what [`correlate`] emits and what the
|
||||
//! checked-in [placement table](parse_table) stores, so the viewer can assemble a
|
||||
//! ship exactly without re-capturing.
|
||||
//!
|
||||
//! ## Pipeline
|
||||
//!
|
||||
//! 1. Canary F10 → `xenia_ship_capture.log` (per-draw `vbase`/`vcount` + the first
|
||||
//! 48 VS float4 constants). [`parse_capture`] → [`CapturedDraw`]s.
|
||||
//! 2. [`correlate`] matches each ship base part to a draw **by vertex count**
|
||||
//! (unique per part) and expresses it in the reference part's frame →
|
||||
//! [`ShipPlacement`].
|
||||
//! 3. [`serialize_table`]/[`parse_table`] persist it as a checked-in data file
|
||||
//! (`data/ship_placements.txt`, embedded via [`embedded_placement`]); the viewer
|
||||
//! prefers it over the static assembler when present.
|
||||
|
||||
use crate::mesh::ScenePart;
|
||||
|
||||
type M3 = [[f64; 3]; 3];
|
||||
|
||||
/// One captured draw's rigid **WorldView**: rotation rows `r` + view-space
|
||||
/// translation `t`, recovered from the `c0..c2` WVP constants.
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct CapturedDraw {
|
||||
/// Guest vertex-buffer base address (the draw's identity for de-duping).
|
||||
pub vbase: u32,
|
||||
/// Vertex count — the key that matches a draw to a decoded part.
|
||||
pub vcount: u32,
|
||||
/// WorldView rotation rows (orthonormal).
|
||||
pub r: M3,
|
||||
/// WorldView view-space translation.
|
||||
pub t: [f64; 3],
|
||||
/// First few LOCAL vertex positions dumped with the draw (buffer order).
|
||||
/// Used to disambiguate same-vcount twins (mirrored port/starboard parts).
|
||||
pub pos: Vec<[f32; 3]>,
|
||||
}
|
||||
|
||||
/// A ship part to match against the capture. `part` is the **base** part name
|
||||
/// (what goes in the placement table); `vcount`/`ref_pos` come from whichever
|
||||
/// resource variant is being tried (base or an `_m`/`_l` LOD copy — a LOD is the
|
||||
/// same part in the same local frame, so its captured transform is the part's).
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct PartKey {
|
||||
/// Base part name for the table, e.g. `e106_bdy_01`.
|
||||
pub part: String,
|
||||
/// The tried resource's vertex count (the draw match key).
|
||||
pub vcount: u32,
|
||||
/// The tried resource's decoded positions (any order — validation is
|
||||
/// set-based), used to validate a vcount hit and to route mirrored twins.
|
||||
/// Empty = match by vcount alone.
|
||||
pub ref_pos: Vec<[f32; 3]>,
|
||||
}
|
||||
|
||||
/// A part's ship-relative rigid placement (in the reference part's frame).
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct PartPlacement {
|
||||
/// Geometry resource name, e.g. `e106_eng_01`.
|
||||
pub part: String,
|
||||
/// Rotation rows.
|
||||
pub m: [[f32; 3]; 3],
|
||||
/// Ship-relative translation.
|
||||
pub t: [f32; 3],
|
||||
}
|
||||
|
||||
/// A whole ship's captured placement: every part in a shared ship-local frame.
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct ShipPlacement {
|
||||
/// Ship family id, e.g. `e106`.
|
||||
pub id: String,
|
||||
/// The reference part whose frame the placements are expressed in.
|
||||
pub reference: String,
|
||||
/// Ship-relative placement of each matched part.
|
||||
pub parts: Vec<PartPlacement>,
|
||||
}
|
||||
|
||||
/// Parse a Canary ship-capture log into per-draw rigid WorldView transforms.
|
||||
///
|
||||
/// Only draws that carry the `c0..c2` constants are returned (a culled/occluded
|
||||
/// part produces no draw and is simply absent). Robust to the exact spacing of
|
||||
/// the `DRAW …` / `vsconst …` lines.
|
||||
pub fn parse_capture(text: &str) -> Vec<CapturedDraw> {
|
||||
let mut out = Vec::new();
|
||||
let mut vbase = 0u32;
|
||||
let mut vcount = 0u32;
|
||||
let mut pos: Vec<[f32; 3]> = Vec::new();
|
||||
let mut consts: Vec<(usize, [f64; 4])> = Vec::new();
|
||||
|
||||
let flush = |vbase: u32,
|
||||
vcount: u32,
|
||||
pos: &mut Vec<[f32; 3]>,
|
||||
consts: &[(usize, [f64; 4])],
|
||||
out: &mut Vec<CapturedDraw>| {
|
||||
let pos = std::mem::take(pos);
|
||||
if vbase == 0 {
|
||||
return;
|
||||
}
|
||||
let get = |i: usize| consts.iter().find(|(k, _)| *k == i).map(|(_, v)| *v);
|
||||
let (Some(c0), Some(c1), Some(c2)) = (get(0), get(1), get(2)) else {
|
||||
return; // no WorldView for this draw — skip it
|
||||
};
|
||||
if let Some((r, t)) = normalize_wvp([c0, c1, c2]) {
|
||||
out.push(CapturedDraw { vbase, vcount, r, t, pos });
|
||||
}
|
||||
};
|
||||
|
||||
for line in text.lines() {
|
||||
let l = line.trim();
|
||||
if let Some(rest) = l.strip_prefix("DRAW ") {
|
||||
flush(vbase, vcount, &mut pos, &consts, &mut out);
|
||||
consts.clear();
|
||||
let f = |k: &str| rest.split_whitespace().find_map(|t| t.strip_prefix(k));
|
||||
vbase = f("vbase=0x").and_then(|s| u32::from_str_radix(s, 16).ok()).unwrap_or(0);
|
||||
vcount = f("vcount=").and_then(|s| s.parse().ok()).unwrap_or(0);
|
||||
} else if l.starts_with("pos:") || l.starts_with("positions:") {
|
||||
pos = parse_pos_line(l, 8);
|
||||
} else if l.starts_with("vsconst") {
|
||||
for cap in l.split('c').skip(1) {
|
||||
let Some((idx, rest)) = cap.split_once('=') else { continue };
|
||||
let Ok(i) = idx.trim().parse::<usize>() else { continue };
|
||||
let nums: Vec<f64> = rest
|
||||
.trim_start_matches('(')
|
||||
.split(')')
|
||||
.next()
|
||||
.unwrap_or("")
|
||||
.split(',')
|
||||
.filter_map(|x| x.trim().parse().ok())
|
||||
.collect();
|
||||
if nums.len() == 4 {
|
||||
consts.push((i, [nums[0], nums[1], nums[2], nums[3]]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
flush(vbase, vcount, &mut pos, &consts, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
/// Parse a `pos: (x,y,z) (x,y,z) …` dump line into up to `max` positions.
|
||||
fn parse_pos_line(l: &str, max: usize) -> Vec<[f32; 3]> {
|
||||
let mut out = Vec::new();
|
||||
for group in l.split('(').skip(1) {
|
||||
let Some(inner) = group.split(')').next() else { continue };
|
||||
let nums: Vec<f32> = inner.split(',').filter_map(|x| x.trim().parse().ok()).collect();
|
||||
if nums.len() == 3 {
|
||||
out.push([nums[0], nums[1], nums[2]]);
|
||||
if out.len() >= max {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The vertex shader capital ships (and the player fighter) are drawn with — the
|
||||
/// `c0..c2` WVP-row layout [`parse_capture`]/[`parse_drawlog`] rely on.
|
||||
pub const SHIP_VS_HASH: &str = "0xC7F781F4C1D58054";
|
||||
|
||||
/// Parse the **draw-logger** format (`xenia_re_draws.log` / `mission_draws.log`,
|
||||
/// the `--log_draws` cvar) into per-part rigid transforms — the alternative to the
|
||||
/// F10 [`parse_capture`] snapshot. That log is what a normal instrumented run
|
||||
/// already produces, so a capital ship seen in-mission can be baked without a
|
||||
/// dedicated F10 capture.
|
||||
///
|
||||
/// A capital ship's parts each own a **distinct vertex buffer**, so we group by
|
||||
/// the `stream … base=…` address, take its vertex count as `size_words /
|
||||
/// stride_words`, and keep the first `c0..c2` WVP seen for that buffer. Only draws
|
||||
/// 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.)
|
||||
pub fn parse_drawlog(text: &str) -> Vec<CapturedDraw> {
|
||||
let mut out = Vec::new();
|
||||
let mut seen: std::collections::HashSet<u32> = std::collections::HashSet::new();
|
||||
let mut is_ship = false;
|
||||
let mut base = 0u32;
|
||||
let mut stride = 0u32;
|
||||
let mut size = 0u32;
|
||||
let mut pos: Vec<[f32; 3]> = Vec::new();
|
||||
let mut consts: Vec<(usize, [f64; 4])> = Vec::new();
|
||||
|
||||
let mut flush = |base: u32,
|
||||
size: u32,
|
||||
stride: u32,
|
||||
pos: &mut Vec<[f32; 3]>,
|
||||
consts: &[(usize, [f64; 4])],
|
||||
seen: &mut std::collections::HashSet<u32>,
|
||||
out: &mut Vec<CapturedDraw>| {
|
||||
let pos = std::mem::take(pos);
|
||||
if base == 0 || stride == 0 || !seen.insert(base) {
|
||||
return;
|
||||
}
|
||||
let get = |i: usize| consts.iter().find(|(k, _)| *k == i).map(|(_, v)| *v);
|
||||
let (Some(c0), Some(c1), Some(c2)) = (get(0), get(1), get(2)) else { return };
|
||||
if let Some((r, t)) = normalize_wvp([c0, c1, c2]) {
|
||||
out.push(CapturedDraw { vbase: base, vcount: size / stride, r, t, pos });
|
||||
}
|
||||
};
|
||||
|
||||
for line in text.lines() {
|
||||
let l = line.trim();
|
||||
if let Some(rest) = l.strip_prefix("DRAW ") {
|
||||
flush(base, size, stride, &mut pos, &consts, &mut seen, &mut out);
|
||||
consts.clear();
|
||||
base = 0;
|
||||
stride = 0;
|
||||
size = 0;
|
||||
is_ship = rest.contains(&format!("vs={SHIP_VS_HASH}"));
|
||||
} else if is_ship && l.starts_with("positions:") {
|
||||
pos = parse_pos_line(l, 8);
|
||||
} else if is_ship && l.starts_with("stream ") {
|
||||
let f = |k: &str| l.split_whitespace().find_map(|t| t.strip_prefix(k));
|
||||
if let Some(b) = f("base=0x").and_then(|s| u32::from_str_radix(s, 16).ok()) {
|
||||
base = b;
|
||||
}
|
||||
stride = f("stride_words=").and_then(|s| s.parse().ok()).unwrap_or(stride);
|
||||
size = f("size_words=").and_then(|s| s.parse().ok()).unwrap_or(size);
|
||||
} else if is_ship && l.starts_with('c') {
|
||||
// `c<idx> x y z w` — the vsconst rows (space-separated).
|
||||
let mut it = l.splitn(2, char::is_whitespace);
|
||||
let Some(tag) = it.next() else { continue };
|
||||
let Ok(i) = tag[1..].parse::<usize>() else { continue };
|
||||
let nums: Vec<f64> = it.next().unwrap_or("").split_whitespace().filter_map(|x| x.parse().ok()).collect();
|
||||
if nums.len() >= 4 {
|
||||
consts.push((i, [nums[0], nums[1], nums[2], nums[3]]));
|
||||
}
|
||||
}
|
||||
}
|
||||
flush(base, size, stride, &mut pos, &consts, &mut seen, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
/// Normalize the three `c0..c2` WVP rows to a rigid WorldView `(R rows, T)` by
|
||||
/// dividing each row by its (projection-scale) norm. `None` if any row is
|
||||
/// degenerate.
|
||||
fn normalize_wvp(rows: [[f64; 4]; 3]) -> Option<(M3, [f64; 3])> {
|
||||
let mut r = [[0.0; 3]; 3];
|
||||
let mut t = [0.0; 3];
|
||||
for (i, row) in rows.iter().enumerate() {
|
||||
let n = (row[0] * row[0] + row[1] * row[1] + row[2] * row[2]).sqrt();
|
||||
if n < 1e-6 {
|
||||
return None;
|
||||
}
|
||||
r[i] = [row[0] / n, row[1] / n, row[2] / n];
|
||||
t[i] = row[3] / n;
|
||||
}
|
||||
Some((r, t))
|
||||
}
|
||||
|
||||
/// Validate a vcount hit by the draw's dumped positions against the part's
|
||||
/// decoded position SET (order-independent — decode order can differ from buffer
|
||||
/// order). Returns `Some((hits, mirrored))` when at least half the dumped
|
||||
/// positions are found among the part's vertices, either directly or **all
|
||||
/// X-negated** — the engine uploads the second of a mirrored port/starboard pair
|
||||
/// as an X-reflection of the shared file geometry, so the guest buffer disagrees
|
||||
/// in X sign with every decoded copy. `None` = the dump belongs to a different
|
||||
/// model (a coincidental vcount).
|
||||
fn pos_validate(draw: &CapturedDraw, ref_pos: &[[f32; 3]]) -> Option<(usize, bool)> {
|
||||
if draw.pos.is_empty() || ref_pos.is_empty() {
|
||||
return Some((0, false)); // no data to validate with — accept neutrally
|
||||
}
|
||||
let near = |a: &[f32; 3], b: &[f32; 3]| {
|
||||
(a[0] - b[0]).abs() <= 1e-2 && (a[1] - b[1]).abs() <= 1e-2 && (a[2] - b[2]).abs() <= 1e-2
|
||||
};
|
||||
let mut direct = 0usize;
|
||||
let mut mirror = 0usize;
|
||||
for p in &draw.pos {
|
||||
if ref_pos.iter().any(|v| near(p, v)) {
|
||||
direct += 1;
|
||||
}
|
||||
let pm = [-p[0], p[1], p[2]];
|
||||
if ref_pos.iter().any(|v| near(&pm, v)) {
|
||||
mirror += 1;
|
||||
}
|
||||
}
|
||||
let need = draw.pos.len().div_ceil(2);
|
||||
if direct >= need && direct >= mirror {
|
||||
Some((direct, false))
|
||||
} else if mirror >= need {
|
||||
Some((mirror, true))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Correlate captured draws to a ship's parts and express each in the reference
|
||||
/// part's frame.
|
||||
///
|
||||
/// Each [`PartKey`]'s `vcount` is the match key; when several draws share the
|
||||
/// vcount (mirrored port/starboard twins) the draw whose dumped positions match
|
||||
/// the part's `ref_pos` validates best is chosen. `ref_sub` selects the reference part by
|
||||
/// substring (e.g. `bdy_04`); the first matched part is used if none contains it.
|
||||
/// Parts with no matching captured draw (culled at that camera angle) are
|
||||
/// omitted. Returns `None` if nothing matched.
|
||||
pub fn correlate(
|
||||
id: &str,
|
||||
draws: &[CapturedDraw],
|
||||
parts: &[PartKey],
|
||||
ref_sub: &str,
|
||||
) -> Option<ShipPlacement> {
|
||||
let mut matched: Vec<(String, M3, [f64; 3], bool)> = Vec::new();
|
||||
let mut used: std::collections::HashSet<u32> = std::collections::HashSet::new();
|
||||
for key in parts {
|
||||
// Several PartKeys may carry the same part (one per LOD-variant vcount);
|
||||
// the first that validates wins, the rest are skipped.
|
||||
if matched.iter().any(|(p, ..)| p == &key.part) {
|
||||
continue;
|
||||
}
|
||||
// A vcount hit alone can be a coincidence (small LODs share counts across
|
||||
// unrelated models — a 51-vert draw once matched the bridge but was a
|
||||
// different mesh). Candidates failing position validation are REJECTED;
|
||||
// among validated candidates the best hit count wins (routes twins), and
|
||||
// a mirror-validated match records the X-reflection.
|
||||
let mut best: Option<(&CapturedDraw, usize, bool)> = None;
|
||||
for d in draws.iter().filter(|d| d.vcount == key.vcount && !used.contains(&d.vbase)) {
|
||||
let Some((score, mirrored)) = pos_validate(d, &key.ref_pos) else {
|
||||
continue; // positions disagree — not this part
|
||||
};
|
||||
if best.map_or(true, |(_, s, _)| score > s) {
|
||||
best = Some((d, score, mirrored));
|
||||
}
|
||||
}
|
||||
if let Some((d, _, mirrored)) = best {
|
||||
used.insert(d.vbase);
|
||||
matched.push((key.part.clone(), d.r, d.t, mirrored));
|
||||
}
|
||||
}
|
||||
let ref_idx = matched.iter().position(|(p, ..)| p.contains(ref_sub)).unwrap_or(0);
|
||||
let (ref_part, ref_r, ref_t, _) = matched.get(ref_idx)?.clone();
|
||||
let rt_ref = transpose(&ref_r);
|
||||
|
||||
let parts_out = matched
|
||||
.iter()
|
||||
.map(|(part, r, t, mirrored)| {
|
||||
let mut rel_r = mmul(&rt_ref, r);
|
||||
let dt = [t[0] - ref_t[0], t[1] - ref_t[1], t[2] - ref_t[2]];
|
||||
let rel_t = mat_vec(&rt_ref, dt);
|
||||
// The captured WorldView transforms the *uploaded* buffer; for the
|
||||
// mirrored twin that buffer is the X-reflection of the file geometry,
|
||||
// so the file-local placement is R·diag(−1,1,1) — negate column 0.
|
||||
if *mirrored {
|
||||
for row in &mut rel_r {
|
||||
row[0] = -row[0];
|
||||
}
|
||||
}
|
||||
PartPlacement {
|
||||
part: part.clone(),
|
||||
m: snap_m3(&rel_r),
|
||||
t: [rel_t[0] as f32, rel_t[1] as f32, rel_t[2] as f32],
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
Some(ShipPlacement { id: id.to_string(), reference: ref_part, parts: parts_out })
|
||||
}
|
||||
|
||||
/// Snap near-axis rotation entries (float noise from the WV products) to exact
|
||||
/// 0/±1 so the checked-in table is clean; real rotations are untouched.
|
||||
fn snap_m3(m: &M3) -> [[f32; 3]; 3] {
|
||||
let snap = |v: f64| -> f32 {
|
||||
if v.abs() < 5e-4 {
|
||||
0.0
|
||||
} else if (v - 1.0).abs() < 5e-4 {
|
||||
1.0
|
||||
} else if (v + 1.0).abs() < 5e-4 {
|
||||
-1.0
|
||||
} else {
|
||||
v as f32
|
||||
}
|
||||
};
|
||||
[
|
||||
[snap(m[0][0]), snap(m[0][1]), snap(m[0][2])],
|
||||
[snap(m[1][0]), snap(m[1][1]), snap(m[1][2])],
|
||||
[snap(m[2][0]), snap(m[2][1]), snap(m[2][2])],
|
||||
]
|
||||
}
|
||||
|
||||
/// Convert a captured placement into viewer [`ScenePart`]s (rigid, unit scale).
|
||||
pub fn to_scene_parts(ship: &ShipPlacement) -> Vec<ScenePart> {
|
||||
ship.parts
|
||||
.iter()
|
||||
.map(|p| ScenePart { resource: p.part.clone(), m: p.m, t: p.t, s: [1.0, 1.0, 1.0] })
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The checked-in placement table, embedded at build time. Empty until captures
|
||||
/// are baked in with `correlate_capture --emit`.
|
||||
const EMBEDDED_TABLE: &str = include_str!("../data/ship_placements.txt");
|
||||
|
||||
/// The captured placement for ship `id` from the embedded table, if baked in.
|
||||
pub fn embedded_placement(id: &str) -> Option<ShipPlacement> {
|
||||
parse_table(EMBEDDED_TABLE).into_iter().find(|s| s.id == id)
|
||||
}
|
||||
|
||||
/// Serialize a placement table to the checked-in text format (see [`parse_table`]).
|
||||
pub fn serialize_table(ships: &[ShipPlacement]) -> String {
|
||||
let mut s = String::new();
|
||||
s.push_str("# Capital-ship part placements — runtime-captured ground truth.\n");
|
||||
s.push_str("# Generated by: cargo run --release --example correlate_capture -- \\\n");
|
||||
s.push_str("# <capture.log> <Stage_SNN> <ship_id> [ref_part_substr] --emit\n");
|
||||
s.push_str("# Per line: <part> <R00 R01 R02 R10 R11 R12 R20 R21 R22> <T0 T1 T2>\n");
|
||||
for ship in ships {
|
||||
s.push_str(&format!("\nship {} ref={}\n", ship.id, ship.reference));
|
||||
for p in &ship.parts {
|
||||
s.push_str(&format!(
|
||||
" {} {} {} {} {} {} {} {} {} {} {} {} {}\n",
|
||||
p.part,
|
||||
p.m[0][0], p.m[0][1], p.m[0][2],
|
||||
p.m[1][0], p.m[1][1], p.m[1][2],
|
||||
p.m[2][0], p.m[2][1], p.m[2][2],
|
||||
p.t[0], p.t[1], p.t[2],
|
||||
));
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// Parse the checked-in placement table. `#` comments and blank lines are ignored;
|
||||
/// a `ship <id> ref=<part>` line starts a block, and each following
|
||||
/// `<part> <9 rotation floats> <3 translation floats>` line is one placement.
|
||||
pub fn parse_table(text: &str) -> Vec<ShipPlacement> {
|
||||
let mut ships: Vec<ShipPlacement> = Vec::new();
|
||||
for line in text.lines() {
|
||||
let l = line.trim();
|
||||
if l.is_empty() || l.starts_with('#') {
|
||||
continue;
|
||||
}
|
||||
if let Some(rest) = l.strip_prefix("ship ") {
|
||||
let mut it = rest.split_whitespace();
|
||||
let id = it.next().unwrap_or("").to_string();
|
||||
let reference = it
|
||||
.next()
|
||||
.and_then(|s| s.strip_prefix("ref="))
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
ships.push(ShipPlacement { id, reference, parts: Vec::new() });
|
||||
} else if let Some(ship) = ships.last_mut() {
|
||||
let mut it = l.split_whitespace();
|
||||
let part = it.next().unwrap_or("").to_string();
|
||||
let nums: Vec<f32> = it.filter_map(|x| x.parse().ok()).collect();
|
||||
if part.is_empty() || nums.len() != 12 {
|
||||
continue;
|
||||
}
|
||||
ship.parts.push(PartPlacement {
|
||||
part,
|
||||
m: [
|
||||
[nums[0], nums[1], nums[2]],
|
||||
[nums[3], nums[4], nums[5]],
|
||||
[nums[6], nums[7], nums[8]],
|
||||
],
|
||||
t: [nums[9], nums[10], nums[11]],
|
||||
});
|
||||
}
|
||||
}
|
||||
ships
|
||||
}
|
||||
|
||||
fn transpose(m: &M3) -> M3 {
|
||||
[
|
||||
[m[0][0], m[1][0], m[2][0]],
|
||||
[m[0][1], m[1][1], m[2][1]],
|
||||
[m[0][2], m[1][2], m[2][2]],
|
||||
]
|
||||
}
|
||||
fn mmul(a: &M3, b: &M3) -> M3 {
|
||||
let mut o = [[0.0; 3]; 3];
|
||||
for i in 0..3 {
|
||||
for j in 0..3 {
|
||||
o[i][j] = (0..3).map(|k| a[i][k] * b[k][j]).sum();
|
||||
}
|
||||
}
|
||||
o
|
||||
}
|
||||
fn mat_vec(m: &M3, v: [f64; 3]) -> [f64; 3] {
|
||||
[
|
||||
m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2],
|
||||
m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2],
|
||||
m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2],
|
||||
]
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A `vsconst` line for an already-unit WorldView (norm 1) so R = rows and
|
||||
/// T = row[3]: identity rotation, translation `t`.
|
||||
fn draw_line(vbase: u32, vcount: u32, t: [f64; 3]) -> String {
|
||||
format!(
|
||||
"DRAW vbase=0x{vbase:X} stride=32 vcount={vcount} indices=0 prim=tri vs=0x1\n \
|
||||
vsconst base=0: c0=(1,0,0,{}) c1=(0,1,0,{}) c2=(0,0,1,{})\n",
|
||||
t[0], t[1], t[2]
|
||||
)
|
||||
}
|
||||
|
||||
fn key(part: &str, vcount: u32) -> PartKey {
|
||||
PartKey { part: part.to_string(), vcount, ref_pos: Vec::new() }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_recovers_worldview() {
|
||||
let log = draw_line(0x1000, 3, [10.0, 0.0, 0.0]);
|
||||
let draws = parse_capture(&log);
|
||||
assert_eq!(draws.len(), 1);
|
||||
assert_eq!(draws[0].vcount, 3);
|
||||
assert_eq!(draws[0].t, [10.0, 0.0, 0.0]);
|
||||
assert_eq!(draws[0].r, [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_normalizes_projection_scale() {
|
||||
// A row scaled by the projection sx=2 must normalize back to unit, and its
|
||||
// translation divides by the same norm.
|
||||
let log = "DRAW vbase=0x2000 vcount=4\n \
|
||||
vsconst base=0: c0=(2,0,0,20) c1=(0,2,0,0) c2=(0,0,1,0)\n";
|
||||
let d = &parse_capture(log)[0];
|
||||
assert!((d.r[0][0] - 1.0).abs() < 1e-9);
|
||||
assert!((d.t[0] - 10.0).abs() < 1e-9, "20/2 = 10");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn correlate_expresses_parts_in_reference_frame() {
|
||||
// Two parts, identity rotation: ref at view (10,0,0), other at (10,0,50).
|
||||
// Relative to ref, the other must sit at (0,0,50).
|
||||
let log = format!(
|
||||
"{}{}",
|
||||
draw_line(0x1000, 3, [10.0, 0.0, 0.0]),
|
||||
draw_line(0x2000, 4, [10.0, 0.0, 50.0])
|
||||
);
|
||||
let draws = parse_capture(&log);
|
||||
let parts = vec![key("e106_bdy_04", 3), key("e106_eng_01", 4)];
|
||||
let ship = correlate("e106", &draws, &parts, "bdy_04").unwrap();
|
||||
assert_eq!(ship.reference, "e106_bdy_04");
|
||||
let refp = ship.parts.iter().find(|p| p.part == "e106_bdy_04").unwrap();
|
||||
assert_eq!(refp.t, [0.0, 0.0, 0.0]);
|
||||
let eng = ship.parts.iter().find(|p| p.part == "e106_eng_01").unwrap();
|
||||
assert_eq!(eng.t, [0.0, 0.0, 50.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn drawlog_format_parses_capital_ship_parts() {
|
||||
// Two capital-ship parts, each its own vertex buffer (distinct base),
|
||||
// stride 6 → vcount = size_words/6. Identity WVP with known translations.
|
||||
let log = format!(
|
||||
"DRAW prim=4 indices=6 src=0 index[...] vs={SHIP_VS_HASH}\n \
|
||||
stream fc=0 base=0x12A60228 stride_words=6 size_words=9798 endian=2 type=3\n \
|
||||
vsconst:\n c0 1.0 0.0 0.0 10.0\n c1 0.0 1.0 0.0 0.0\n c2 0.0 0.0 1.0 0.0\n\
|
||||
DRAW prim=4 indices=6 src=0 index[...] vs={SHIP_VS_HASH}\n \
|
||||
stream fc=0 base=0x12ABF2CC stride_words=6 size_words=4890 endian=2 type=3\n \
|
||||
vsconst:\n c0 1.0 0.0 0.0 10.0\n c1 0.0 1.0 0.0 0.0\n c2 0.0 0.0 1.0 50.0\n\
|
||||
DRAW prim=4 indices=3 src=0 index[...] vs=0xDEADBEEF00000000\n \
|
||||
stream fc=0 base=0x99990000 stride_words=6 size_words=18 endian=2 type=3\n \
|
||||
vsconst:\n c0 1.0 0.0 0.0 0.0\n c1 0.0 1.0 0.0 0.0\n c2 0.0 0.0 1.0 0.0\n"
|
||||
);
|
||||
let draws = parse_drawlog(&log);
|
||||
// Two ship-shader buffers; the non-ship shader draw is ignored.
|
||||
assert_eq!(draws.len(), 2);
|
||||
assert_eq!(draws[0].vcount, 1633); // 9798/6
|
||||
assert_eq!(draws[1].vcount, 815); // 4890/6
|
||||
// Correlate: part B sits 50 along Z from reference part A.
|
||||
let parts = vec![key("e106_bdy_04", 1633), key("e106_bdy_03", 815)];
|
||||
let ship = correlate("e106", &draws, &parts, "bdy_04").unwrap();
|
||||
let b = ship.parts.iter().find(|p| p.part == "e106_bdy_03").unwrap();
|
||||
assert_eq!(b.t, [0.0, 0.0, 50.0]);
|
||||
}
|
||||
|
||||
/// The real e106 bdy_01/bdy_02 case: both twin resources decode to
|
||||
/// IDENTICAL file geometry; the engine uploads the second instance as an
|
||||
/// X-reflection, so one captured buffer disagrees in X sign with the file.
|
||||
/// Both draws must be placed, and the mirrored one must bake the X-flip
|
||||
/// (negated first matrix column) so file-local geometry lands port-side.
|
||||
#[test]
|
||||
fn runtime_mirrored_twin_placed_with_reflection() {
|
||||
let log = "DRAW vbase=0x1000 stride=24 vcount=426 indices=21 prim=4 vs=0x1\n \
|
||||
pos: (134.4215,133.8319,-118.1757) (178.8384,85.3847,238.0463)\n \
|
||||
vsconst base=0: c0=(1,0,0,264) c1=(0,1,0,0) c2=(0,0,1,0)\n\
|
||||
DRAW vbase=0x2000 stride=24 vcount=426 indices=21 prim=4 vs=0x1\n \
|
||||
pos: (-134.4215,133.8319,-118.1757) (-178.8384,85.3847,238.0463)\n \
|
||||
vsconst base=0: c0=(1,0,0,-264) c1=(0,1,0,0) c2=(0,0,1,0)\n\
|
||||
DRAW vbase=0x3000 stride=24 vcount=558 indices=9 prim=4 vs=0x1\n \
|
||||
vsconst base=0: c0=(1,0,0,0) c1=(0,1,0,0) c2=(0,0,1,0)\n";
|
||||
let draws = parse_capture(log);
|
||||
assert_eq!(draws.len(), 3);
|
||||
assert_eq!(draws[0].pos.len(), 2);
|
||||
// Both twins carry the SAME (file) positions — +X side geometry.
|
||||
let file_pos = vec![[134.4215, 133.8319, -118.1757], [178.8384, 85.3847, 238.0463]];
|
||||
let parts = vec![
|
||||
PartKey { part: "e106_bdy_01".to_string(), vcount: 426, ref_pos: file_pos.clone() },
|
||||
PartKey { part: "e106_bdy_02".to_string(), vcount: 426, ref_pos: file_pos },
|
||||
key("e106_bdy_04", 558),
|
||||
];
|
||||
let ship = correlate("e106", &draws, &parts, "bdy_04").unwrap();
|
||||
assert_eq!(ship.parts.len(), 3, "both twins + reference placed");
|
||||
let get = |p: &str| ship.parts.iter().find(|x| x.part == p).unwrap().clone();
|
||||
// bdy_01 validated directly → the +264 draw, identity rotation.
|
||||
let a = get("e106_bdy_01");
|
||||
assert_eq!(a.t, [264.0, 0.0, 0.0]);
|
||||
assert_eq!(a.m[0][0], 1.0);
|
||||
// bdy_02 validated as the MIRROR → the −264 draw, X-flip baked in.
|
||||
let b = get("e106_bdy_02");
|
||||
assert_eq!(b.t, [-264.0, 0.0, 0.0]);
|
||||
assert_eq!(b.m[0][0], -1.0, "mirrored twin must negate the X column");
|
||||
assert_eq!(b.m[1][1], 1.0);
|
||||
}
|
||||
|
||||
/// A draw whose vcount matches but whose position dump disagrees must be
|
||||
/// REJECTED, not placed — the real false-positive: a foreign 51-vert model
|
||||
/// matched `e106_brg_01_l` by count alone and put the bridge 2 km off-hull.
|
||||
#[test]
|
||||
fn vcount_coincidence_rejected_by_positions() {
|
||||
let log = "DRAW vbase=0x1000 stride=24 vcount=51 indices=36 prim=4 vs=0x1\n \
|
||||
pos: (-0.0000,46.2359,-12.9454) (-0.0000,-6.1936,264.8687)\n \
|
||||
vsconst base=0: c0=(1,0,0,1975) c1=(0,1,0,0) c2=(0,0,1,0)\n\
|
||||
DRAW vbase=0x3000 stride=24 vcount=558 indices=9 prim=4 vs=0x1\n \
|
||||
vsconst base=0: c0=(1,0,0,0) c1=(0,1,0,0) c2=(0,0,1,0)\n";
|
||||
let draws = parse_capture(log);
|
||||
let parts = vec![
|
||||
PartKey {
|
||||
part: "e106_brg_01".to_string(),
|
||||
vcount: 51,
|
||||
// The REAL bridge LOD's vertices — disagree with the dump.
|
||||
ref_pos: vec![[35.2480, 26.0376, 49.2504], [6.0, 55.9632, 41.1370]],
|
||||
},
|
||||
key("e106_bdy_04", 558),
|
||||
];
|
||||
let ship = correlate("e106", &draws, &parts, "bdy_04").unwrap();
|
||||
assert!(
|
||||
!ship.parts.iter().any(|p| p.part == "e106_brg_01"),
|
||||
"coincidental vcount match must not place the bridge"
|
||||
);
|
||||
assert_eq!(ship.parts.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_round_trips() {
|
||||
let ship = ShipPlacement {
|
||||
id: "e106".to_string(),
|
||||
reference: "e106_bdy_04".to_string(),
|
||||
parts: vec![
|
||||
PartPlacement {
|
||||
part: "e106_bdy_04".to_string(),
|
||||
m: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
|
||||
t: [0.0, 0.0, 0.0],
|
||||
},
|
||||
PartPlacement {
|
||||
part: "e106_eng_01".to_string(),
|
||||
m: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
|
||||
t: [131.0, -133.0, -132.0],
|
||||
},
|
||||
],
|
||||
};
|
||||
let text = serialize_table(std::slice::from_ref(&ship));
|
||||
let back = parse_table(&text);
|
||||
assert_eq!(back, vec![ship]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn embedded_table_parses() {
|
||||
// The checked-in data file must always parse (even if empty).
|
||||
let _ = parse_table(EMBEDDED_TABLE);
|
||||
}
|
||||
|
||||
/// The baked e106 capture (2026-07-26 F10, Stage_S01): all 8 parts placed,
|
||||
/// port/starboard pair symmetric with the mirror on bdy_02, bridge on the
|
||||
/// centreline. Guards the checked-in data against accidental edits.
|
||||
#[test]
|
||||
fn embedded_e106_is_complete() {
|
||||
let e106 = embedded_placement("e106").expect("e106 baked in");
|
||||
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, 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_01").m[0][0], 1.0);
|
||||
// Bridge: centreline, above and aft of the hull reference.
|
||||
let brg = get("e106_brg_01");
|
||||
assert!(brg.t[0].abs() < 0.1 && brg.t[1] > 150.0 && brg.t[2] < -160.0);
|
||||
}
|
||||
}
|
||||
@@ -1,370 +0,0 @@
|
||||
//! `.slb` XACT sound banks → a decodable XMA1 `RIFF`.
|
||||
//!
|
||||
//! `dat/sound.pak` (9519 entries across `sound.p00..p04`) is the game's audio
|
||||
//! bank. Each entry is an XACT `.slb` wrapping **XMA1** (`fmt ` tag `0x0165`,
|
||||
//! 48 kHz). Files are named `<lang>\Voice\…`, `<lang>\Movie\VOICE_<movie>.slb`,
|
||||
//! `BGM_###.slb`, etc. (see `docs/re/structures/sound-slb.md`); look them up by
|
||||
//! [`crate::hash::name_hash`]. Movie cutscene voice = one continuous
|
||||
//! `<eng|jpn>\Movie\VOICE_<movie>.slb` track meant to play from the video start.
|
||||
//!
|
||||
//! Two on-disc layouts, both reversed statically:
|
||||
//! - **RIFF present** — a standard `RIFF/WAVE` sits inside the bank; its 32-byte
|
||||
//! `fmt ` is the real `XMAWAVEFORMAT` and the XMA packets are everything after
|
||||
//! that RIFF's `data` chunk header (the declared `data` size is unreliable, so
|
||||
//! we take to end and let the caller clamp to the known media length).
|
||||
//! - **Headerless** — no RIFF at all; a fixed **1392-byte** header precedes raw
|
||||
//! XMA1 packets (48 kHz, 2 channels).
|
||||
//!
|
||||
//! [`to_xma_riff`] rebuilds a standalone `RIFF/WAVE` (XMA1) for either layout,
|
||||
//! ready to hand to an XMA decoder (e.g. FFmpeg's `xma1`). The content is always
|
||||
//! mono (some clips put it in the left channel only, others duplicate L=R), so
|
||||
//! the decode step should downmix to mono (take the left channel).
|
||||
|
||||
/// Fixed offset of the raw XMA1 stream in a headerless `.slb` (no `RIFF`).
|
||||
pub const HEADERLESS_DATA_OFFSET: usize = 1392;
|
||||
|
||||
/// Voice language for cutscene audio. Only English and Japanese voice exist on
|
||||
/// the disc (subtitles cover more languages, voice does not).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum VoiceLang {
|
||||
English,
|
||||
Japanese,
|
||||
}
|
||||
|
||||
impl VoiceLang {
|
||||
fn code(self) -> &'static str {
|
||||
match self {
|
||||
VoiceLang::English => "eng",
|
||||
VoiceLang::Japanese => "jpn",
|
||||
}
|
||||
}
|
||||
|
||||
/// `eng` / `jpn` — the `sound.pak` path prefix for this voice language.
|
||||
pub fn code_pub(self) -> &'static str {
|
||||
self.code()
|
||||
}
|
||||
}
|
||||
|
||||
/// The `sound.pak` entry name for a movie's continuous voice track, e.g.
|
||||
/// `eng\Movie\VOICE_RT07A.slb`. Hash it with [`crate::hash::name_hash`] to get
|
||||
/// the `sound.pak` TOC key.
|
||||
pub fn movie_voice_name(movie_basename: &str, lang: VoiceLang) -> String {
|
||||
format!("{}\\Movie\\VOICE_{}.slb", lang.code(), movie_basename)
|
||||
}
|
||||
|
||||
/// One playable voice clip discovered in `sounds.tbl`.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct VoiceClip {
|
||||
/// Full `sound.pak` entry name, e.g. `eng\Voice\VOICE_ADAN_010.slb`.
|
||||
pub name: String,
|
||||
/// Speaker/category code, e.g. `ADAN`, `TCAF`, `A`, `RT07A`.
|
||||
pub speaker: String,
|
||||
/// Short UI label, e.g. `ADAN 010`.
|
||||
pub display: String,
|
||||
}
|
||||
|
||||
/// Enumerate the voice/dialog clips named in a decompressed `sounds.tbl` (the
|
||||
/// IDXD in `tables.pak`). Extracts every `<lang>\{Voice,etc,Movie,Briefing}\…`
|
||||
/// path ending in `.slb` for `lang`, parsed into `(name, speaker, display)`.
|
||||
pub fn list_voice_clips(sounds_tbl: &[u8], lang: VoiceLang) -> Vec<VoiceClip> {
|
||||
let prefix = format!("{}\\", lang.code());
|
||||
let mut seen = std::collections::BTreeSet::new();
|
||||
let mut out = Vec::new();
|
||||
// Scan for printable-ASCII runs; keep those that look like a voice path.
|
||||
let mut i = 0;
|
||||
while i < sounds_tbl.len() {
|
||||
let start = i;
|
||||
while i < sounds_tbl.len() && (0x20..=0x7e).contains(&sounds_tbl[i]) {
|
||||
i += 1;
|
||||
}
|
||||
if i - start >= 6 {
|
||||
if let Ok(s) = std::str::from_utf8(&sounds_tbl[start..i]) {
|
||||
// Every spoken-line category, so the standalone player covers them
|
||||
// all: in-mission radio (`\Voice\`, `\etc\`) and bound movie voices
|
||||
// (`\Movie\`) all carry `VOICE_`; mission-briefing lines live in
|
||||
// `\Briefing\` as `BR<NN>_<MM>.slb` (no `VOICE` in the name).
|
||||
let is_voice = s.contains("VOICE") || s.contains("\\Briefing\\");
|
||||
if s.starts_with(&prefix) && s.ends_with(".slb") && is_voice {
|
||||
if seen.insert(s.to_string()) {
|
||||
out.push(parse_voice_clip(s));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn parse_voice_clip(name: &str) -> VoiceClip {
|
||||
// `<lang>\<cat>\VOICE_<SPK>_<NNN>.slb` or `..\VOICE_<movie>.slb`.
|
||||
let stem = name
|
||||
.rsplit('\\')
|
||||
.next()
|
||||
.unwrap_or(name)
|
||||
.strip_suffix(".slb")
|
||||
.unwrap_or(name);
|
||||
let body = stem.strip_prefix("VOICE_").unwrap_or(stem);
|
||||
let (speaker, display) = match body.rsplit_once('_') {
|
||||
Some((spk, num)) if num.chars().all(|c| c.is_ascii_digit()) => {
|
||||
(spk.to_string(), format!("{spk} {num}"))
|
||||
}
|
||||
_ => (body.to_string(), body.to_string()),
|
||||
};
|
||||
VoiceClip {
|
||||
name: name.to_string(),
|
||||
speaker,
|
||||
display,
|
||||
}
|
||||
}
|
||||
|
||||
/// Build one standalone XMA1 `RIFF/WAVE` **per sub-wave** in a `.slb` bank, in
|
||||
/// on-disc order. A `.slb` is an XACT bank of one or more sub-waves; the sub-waves
|
||||
/// are EITHER alternate takes (the first is the whole track — e.g. `VOICE_S01A`,
|
||||
/// `VOICE_ADV`: sub0 ≈ the movie length) OR sequential segments that must be
|
||||
/// concatenated (e.g. `VOICE_RT07A`: 24s + 14s + 11s ≈ the 50s movie). The caller
|
||||
/// decodes each to PCM, concatenates in order, and clamps to the movie length —
|
||||
/// that yields the full track for segment banks while the clamp drops the
|
||||
/// duplicate takes for alternate-take banks. (Dynamic RE via Canary file-I/O
|
||||
/// tracing confirmed the movie→voice binding; this fixes the *decode* of `RT*`.)
|
||||
pub fn to_xma_riffs(slb: &[u8]) -> Vec<Vec<u8>> {
|
||||
let mut out = Vec::new();
|
||||
if find(slb, b"RIFF", 0).is_none() {
|
||||
// Headerless single-stream bank.
|
||||
if let Some(data) = slb.get(HEADERLESS_DATA_OFFSET..) {
|
||||
if !data.is_empty() {
|
||||
out.push(build_riff(&synth_xma1_fmt(2, 2, 48000), data));
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
let mut pos = 0usize;
|
||||
while let Some(ri) = find(slb, b"RIFF", pos) {
|
||||
// Parse this sub-wave's fmt + data (declared size is honest per sub-wave).
|
||||
let Some(fi) = find(slb, b"fmt ", ri) else { break };
|
||||
let Some(fsz) = le32(slb, fi + 4) else { break };
|
||||
let Some(fmt_end) = fi.checked_add(8).and_then(|v| v.checked_add(fsz as usize)) else {
|
||||
break;
|
||||
};
|
||||
if fmt_end > slb.len() {
|
||||
break;
|
||||
}
|
||||
let Some(di) = find(slb, b"data", fi) else { break };
|
||||
let Some(dsz) = le32(slb, di + 4) else { break };
|
||||
let Some(ds) = di.checked_add(8) else { break };
|
||||
let de = ds
|
||||
.checked_add(dsz as usize)
|
||||
.unwrap_or(slb.len())
|
||||
.min(slb.len());
|
||||
if let Some(data) = slb.get(ds..de) {
|
||||
if !data.is_empty() {
|
||||
out.push(build_riff(&slb[fi..fmt_end], data));
|
||||
}
|
||||
}
|
||||
// Advance past this sub-wave's data to find the next RIFF.
|
||||
pos = de.max(ri + 4);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Build a standalone XMA1 `RIFF/WAVE` from a `.slb` bank, decodable by FFmpeg's
|
||||
/// `xma1`. Returns `None` if the bank is too small / malformed. This is the
|
||||
/// FIRST sub-wave only; prefer [`to_xma_riffs`] for correct multi-segment banks.
|
||||
pub fn to_xma_riff(slb: &[u8]) -> Option<Vec<u8>> {
|
||||
if let Some(ri) = find(slb, b"RIFF", 0) {
|
||||
// RIFF layout: a `.slb` is an XACT bank of one or more sub-waves, each
|
||||
// `[seek][RIFF: fmt + Dmmy pad + data][declared_size XMA bytes]`. Take the
|
||||
// FIRST sub-wave, bounded by its **declared `data` size** (which is
|
||||
// honest per sub-wave). Decoding to end-of-file instead would append the
|
||||
// later sub-waves — for multi-take story movies those are ALTERNATE takes,
|
||||
// which is what made S10–S16 play the wrong audio.
|
||||
let fi = find(slb, b"fmt ", ri)?;
|
||||
let fsz = le32(slb, fi + 4)? as usize;
|
||||
let fmt_end = fi.checked_add(8)?.checked_add(fsz)?;
|
||||
if fmt_end > slb.len() {
|
||||
return None;
|
||||
}
|
||||
let fmt_chunk = &slb[fi..fmt_end];
|
||||
let di = find(slb, b"data", fi)?;
|
||||
let dsz = le32(slb, di + 4)? as usize;
|
||||
let end = di.checked_add(8)?.checked_add(dsz)?.min(slb.len());
|
||||
let data = slb.get(di + 8..end)?;
|
||||
Some(build_riff(fmt_chunk, data))
|
||||
} else {
|
||||
// Headerless: 1392-byte header, then raw XMA1 (48 kHz, 2 channels).
|
||||
let data = slb.get(HEADERLESS_DATA_OFFSET..)?;
|
||||
if data.is_empty() {
|
||||
return None;
|
||||
}
|
||||
Some(build_riff(&synth_xma1_fmt(2, 2, 48000), data))
|
||||
}
|
||||
}
|
||||
|
||||
/// Rebuild a standalone XMA1 `RIFF/WAVE` from a single-stream `.slb`, robust to
|
||||
/// the layout variants seen in `<lang>\etc\` radio clips. Unlike [`to_xma_riff`]
|
||||
/// (which assumes `RIFF → fmt → data` in order), this picks the **largest `data`
|
||||
/// chunk anywhere** in the bank — some radio banks store the audio *before* the
|
||||
/// trailing `RIFF`/`fmt` metadata (an empty post-`RIFF` `data` chunk), which the
|
||||
/// ordered scan misses. Pairs it with the first `fmt ` chunk; falls back to the
|
||||
/// headerless layout. Returns `None` only when no usable audio can be found.
|
||||
pub fn to_xma_riff_best(slb: &[u8]) -> Option<Vec<u8>> {
|
||||
// Largest usable `data` chunk (bounded by its declared size and the buffer).
|
||||
let mut best: Option<(usize, usize)> = None; // (data offset, usable payload len)
|
||||
let mut i = 0;
|
||||
while let Some(di) = find(slb, b"data", i) {
|
||||
let declared = le32(slb, di + 4).unwrap_or(0) as usize;
|
||||
let usable = declared.min(slb.len().saturating_sub(di + 8));
|
||||
if best.map_or(true, |(_, b)| usable > b) {
|
||||
best = Some((di, usable));
|
||||
}
|
||||
i = di + 4;
|
||||
}
|
||||
if let (Some(fi), Some((di, sz))) = (find(slb, b"fmt ", 0), best) {
|
||||
if sz > 512 {
|
||||
let fsz = le32(slb, fi + 4)? as usize;
|
||||
let fmt_end = (fi + 8 + fsz).min(slb.len());
|
||||
let data = slb.get(di + 8..di + 8 + sz)?;
|
||||
return Some(build_riff(slb.get(fi..fmt_end)?, data));
|
||||
}
|
||||
}
|
||||
// Headerless fallback: fixed data offset, synthesized XMA1 stereo/48k fmt.
|
||||
let data = slb.get(HEADERLESS_DATA_OFFSET..)?;
|
||||
(!data.is_empty()).then(|| build_riff(&synth_xma1_fmt(2, 2, 48000), data))
|
||||
}
|
||||
|
||||
/// A minimal `fmt ` chunk carrying an XMA1 `XMAWAVEFORMAT` (one stream).
|
||||
fn synth_xma1_fmt(channels: u8, channel_mask: u16, rate: u32) -> Vec<u8> {
|
||||
let mut fmt = Vec::with_capacity(40);
|
||||
fmt.extend_from_slice(b"fmt ");
|
||||
fmt.extend_from_slice(&32u32.to_le_bytes());
|
||||
// XMAWAVEFORMAT header
|
||||
fmt.extend_from_slice(&0x0165u16.to_le_bytes()); // wFormatTag = XMA1
|
||||
fmt.extend_from_slice(&16u16.to_le_bytes()); // BitsPerSample
|
||||
fmt.extend_from_slice(&0u16.to_le_bytes()); // EncodeOptions
|
||||
fmt.extend_from_slice(&0u16.to_le_bytes()); // LargestSkip
|
||||
fmt.extend_from_slice(&1u16.to_le_bytes()); // NumStreams
|
||||
fmt.push(0); // LoopCount
|
||||
fmt.push(3); // Version
|
||||
// XMASTREAMFORMAT[0]
|
||||
fmt.extend_from_slice(&(rate * channels as u32 * 2).to_le_bytes()); // PsuedoBytesPerSec
|
||||
fmt.extend_from_slice(&rate.to_le_bytes()); // SampleRate
|
||||
fmt.extend_from_slice(&0u32.to_le_bytes()); // LoopStart
|
||||
fmt.extend_from_slice(&0u32.to_le_bytes()); // LoopEnd
|
||||
fmt.push(4); // SubframeData
|
||||
fmt.push(channels); // Channels
|
||||
fmt.extend_from_slice(&channel_mask.to_le_bytes()); // ChannelMask
|
||||
fmt
|
||||
}
|
||||
|
||||
fn build_riff(fmt_chunk: &[u8], data: &[u8]) -> Vec<u8> {
|
||||
let mut body = Vec::with_capacity(4 + fmt_chunk.len() + 8 + data.len());
|
||||
body.extend_from_slice(b"WAVE");
|
||||
body.extend_from_slice(fmt_chunk);
|
||||
body.extend_from_slice(b"data");
|
||||
body.extend_from_slice(&(data.len() as u32).to_le_bytes());
|
||||
body.extend_from_slice(data);
|
||||
let mut out = Vec::with_capacity(8 + body.len());
|
||||
out.extend_from_slice(b"RIFF");
|
||||
out.extend_from_slice(&(body.len() as u32).to_le_bytes());
|
||||
out.extend_from_slice(&body);
|
||||
out
|
||||
}
|
||||
|
||||
fn find(hay: &[u8], needle: &[u8], from: usize) -> Option<usize> {
|
||||
if from >= hay.len() {
|
||||
return None;
|
||||
}
|
||||
hay[from..]
|
||||
.windows(needle.len())
|
||||
.position(|w| w == needle)
|
||||
.map(|p| p + from)
|
||||
}
|
||||
|
||||
fn le32(b: &[u8], o: usize) -> Option<u32> {
|
||||
let s = b.get(o..o + 4)?;
|
||||
Some(u32::from_le_bytes([s[0], s[1], s[2], s[3]]))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::hash::name_hash;
|
||||
|
||||
#[test]
|
||||
fn movie_voice_names_and_hashes() {
|
||||
assert_eq!(
|
||||
movie_voice_name("RT07A", VoiceLang::English),
|
||||
"eng\\Movie\\VOICE_RT07A.slb"
|
||||
);
|
||||
// Verified present in dat/sound.pak (VOICE_S00A == TOC entry 0x2A4F97D3).
|
||||
assert_eq!(name_hash("eng\\Movie\\VOICE_RT07A.slb"), 0xA44A_EA1C);
|
||||
assert_eq!(name_hash("eng\\Movie\\VOICE_S00A.slb"), 0x2A4F_97D3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn takes_only_first_subwave() {
|
||||
// Bank of TWO sub-waves; only the FIRST must be extracted (bounded by its
|
||||
// declared `data` size), not everything to end-of-file.
|
||||
let fmt = synth_xma1_fmt(2, 2, 48000);
|
||||
let mut slb = vec![0xAB; 16];
|
||||
slb.extend_from_slice(b"RIFF");
|
||||
slb.extend_from_slice(&999u32.to_le_bytes()); // riff size (ignored)
|
||||
slb.extend_from_slice(b"WAVE");
|
||||
slb.extend_from_slice(&fmt);
|
||||
slb.extend_from_slice(b"data");
|
||||
slb.extend_from_slice(&4u32.to_le_bytes()); // declared: 4 bytes
|
||||
slb.extend_from_slice(&[1, 2, 3, 4]); // sub-wave 1 XMA
|
||||
slb.extend_from_slice(&[9, 9, 9, 9]); // a second sub-wave's bytes — excluded
|
||||
let riff = to_xma_riff(&slb).unwrap();
|
||||
assert_eq!(&riff[0..4], b"RIFF");
|
||||
let dpos = find(&riff, b"data", 0).unwrap();
|
||||
assert_eq!(le32(&riff, dpos + 4), Some(4));
|
||||
assert_eq!(&riff[dpos + 8..], &[1, 2, 3, 4]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn list_voice_clips_covers_movie_radio_and_briefing() {
|
||||
// The standalone player must enumerate every spoken-line category: bound
|
||||
// movie voices, in-mission radio (\etc\ + \Voice\), and briefing (\Briefing\,
|
||||
// whose BR<NN>_<MM> names lack "VOICE"). Music (BGM_*) must stay excluded.
|
||||
let mut tbl = Vec::new();
|
||||
for s in [
|
||||
"eng\\Movie\\VOICE_S13A.slb",
|
||||
"eng\\etc\\VOICE_D_450.slb",
|
||||
"eng\\Voice\\VOICE_ADAN_010.slb",
|
||||
"eng\\Briefing\\BR01_01.slb",
|
||||
"eng\\bgm\\BGM_001.slb",
|
||||
] {
|
||||
tbl.extend_from_slice(s.as_bytes());
|
||||
tbl.push(0);
|
||||
}
|
||||
let names: Vec<String> = list_voice_clips(&tbl, VoiceLang::English)
|
||||
.into_iter()
|
||||
.map(|c| c.name)
|
||||
.collect();
|
||||
for want in [
|
||||
"eng\\Movie\\VOICE_S13A.slb",
|
||||
"eng\\etc\\VOICE_D_450.slb",
|
||||
"eng\\Voice\\VOICE_ADAN_010.slb",
|
||||
"eng\\Briefing\\BR01_01.slb",
|
||||
] {
|
||||
assert!(names.iter().any(|n| n == want), "missing {want}");
|
||||
}
|
||||
assert!(
|
||||
!names.iter().any(|n| n.contains("BGM_")),
|
||||
"music must not be listed as a voice clip"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rebuilds_riff_from_headerless() {
|
||||
let mut slb = vec![0u8; HEADERLESS_DATA_OFFSET];
|
||||
slb.extend_from_slice(&[9, 8, 7, 6]);
|
||||
let riff = to_xma_riff(&slb).unwrap();
|
||||
let dpos = find(&riff, b"data", 0).unwrap();
|
||||
assert_eq!(&riff[dpos + 8..], &[9, 8, 7, 6]);
|
||||
// synthetic fmt advertises XMA1.
|
||||
let fpos = find(&riff, b"fmt ", 0).unwrap();
|
||||
assert_eq!(le32(&riff, fpos + 8).map(|v| v as u16), Some(0x0165));
|
||||
}
|
||||
}
|
||||
@@ -1,25 +1,27 @@
|
||||
//! `T8aD` — the game's 2D UI/HUD texture format.
|
||||
//!
|
||||
//! 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).
|
||||
//! A linear (untiled) 32bpp surface stored **A8R8G8B8** (Xbox byte order), with
|
||||
//! a small fixed-per-variant header:
|
||||
//!
|
||||
//! ```text
|
||||
//! 0x00 4 Magic "T8aD"
|
||||
//! 0x14 4 width (BE u32)
|
||||
//! 0x18 4 height (BE u32)
|
||||
//! 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
|
||||
//! 0x00 4 Magic "T8aD"
|
||||
//! 0x14 4 width (BE u32)
|
||||
//! 0x18 4 height (BE u32)
|
||||
//! 0x1c 4 type field → header size: 1→64 2→84 3→104 4→124 15→344
|
||||
//! <header> w*h*4 bytes of A8R8G8B8 pixel data, row-major
|
||||
//! ```
|
||||
//!
|
||||
//! 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
|
||||
//! one tile it lands on the same pixel start. Wide textures were garbled because
|
||||
//! the offset table + 16-byte per-tile headers weren't accounted for.
|
||||
//! Static forensics over the disc showed ~85% of entries decode exactly with
|
||||
//! this rule; the rest (unknown type field or a `w*h*4` that doesn't fit — most
|
||||
//! likely DXT / palettized variants) return `None` rather than a wrong image.
|
||||
//!
|
||||
//! Keying the header size off the type field (not `len - w*h*4`) makes the
|
||||
//! decoder **container-safe**: RATC/LSTA hand us a child slice that may have
|
||||
//! trailing padding before the next child, so we must not infer the header from
|
||||
//! the slice length.
|
||||
//!
|
||||
//! ⚠️ Colour correctness (channel order / endianness / sRGB) is unverified
|
||||
//! against the running game — see the RE backlog.
|
||||
|
||||
/// Magic at the start of every T8aD surface.
|
||||
pub const T8AD_MAGIC: [u8; 4] = *b"T8aD";
|
||||
@@ -37,74 +39,54 @@ pub fn is_t8ad(bytes: &[u8]) -> bool {
|
||||
bytes.len() >= 4 && bytes[0..4] == T8AD_MAGIC
|
||||
}
|
||||
|
||||
/// Header size in bytes for a given type field (`@0x1c`), or `None` for an
|
||||
/// unrecognized variant.
|
||||
fn header_size(type_field: u32) -> Option<usize> {
|
||||
match type_field {
|
||||
1 => Some(64),
|
||||
2 => Some(84),
|
||||
3 => Some(104),
|
||||
4 => Some(124),
|
||||
15 => Some(344),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn be32(b: &[u8], off: usize) -> u32 {
|
||||
u32::from_be_bytes([b[off], b[off + 1], b[off + 2], b[off + 3]])
|
||||
}
|
||||
|
||||
/// Side of the square storage tile, in texels, and the per-tile header size.
|
||||
const TILE: usize = 256;
|
||||
const TILE_HDR: usize = 16;
|
||||
|
||||
/// Decode a T8aD surface from a slice whose first bytes ARE the magic. Returns
|
||||
/// `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;
|
||||
}
|
||||
let width = be32(bytes, 0x14) as usize;
|
||||
let height = be32(bytes, 0x18) as usize;
|
||||
let width = be32(bytes, 0x14);
|
||||
let height = be32(bytes, 0x18);
|
||||
if !(1..=4096).contains(&width) || !(1..=4096).contains(&height) {
|
||||
return None;
|
||||
}
|
||||
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 + tiles * 4 {
|
||||
return None;
|
||||
let header = header_size(be32(bytes, 0x1c))?;
|
||||
let n = (width as usize) * (height as usize) * 4;
|
||||
if bytes.len() < header + n {
|
||||
return None; // DXT/palettized/short variant — defer, don't misdecode
|
||||
}
|
||||
|
||||
let mut rgba = vec![0u8; width * height * 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
// A8R8G8B8 → RGBA8.
|
||||
let src = &bytes[header..header + n];
|
||||
let mut rgba = vec![0u8; n];
|
||||
for (px, out) in src.chunks_exact(4).zip(rgba.chunks_exact_mut(4)) {
|
||||
let (a, r, g, b) = (px[0], px[1], px[2], px[3]);
|
||||
out[0] = r;
|
||||
out[1] = g;
|
||||
out[2] = b;
|
||||
out[3] = a;
|
||||
}
|
||||
Some(T8adImage {
|
||||
width: width as u32,
|
||||
height: height as u32,
|
||||
width,
|
||||
height,
|
||||
rgba,
|
||||
})
|
||||
}
|
||||
@@ -113,17 +95,13 @@ pub fn parse(bytes: &[u8]) -> Option<T8adImage> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Build a synthetic single-tile T8aD (`w,h ≤ 256`) with a known A8R8G8B8
|
||||
/// pattern: base header + 1-entry offset table + 16-byte tile header + pixels.
|
||||
/// Build a synthetic type-1 (header 64) T8aD with a known A8R8G8B8 pattern.
|
||||
fn synth(w: u32, h: u32) -> Vec<u8> {
|
||||
assert!(w <= 256 && h <= 256);
|
||||
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()); // 1 tile
|
||||
b.extend_from_slice(&0x30u32.to_be_bytes()); // offset table: tile 0 @ 0x30
|
||||
b.extend_from_slice(&[0u8; 16]); // 16-byte tile header → pixels at 0x40
|
||||
b[0x1c..0x20].copy_from_slice(&1u32.to_be_bytes()); // type 1 → header 64
|
||||
for i in 0..(w * h) {
|
||||
b.extend_from_slice(&[(i & 0xff) as u8, 0x24, 0x63, 0xB2]); // A, R, G, B
|
||||
}
|
||||
@@ -143,31 +121,8 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
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);
|
||||
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(&2u32.to_be_bytes()); // 2 tiles
|
||||
let off0 = 0x2c + 2 * 4; // after the 2-entry table
|
||||
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());
|
||||
b.extend_from_slice(&[0u8; 16]);
|
||||
b.extend_from_slice(&[0xFF, 0xFF, 0, 0].repeat(256)); // A,R,G,B red
|
||||
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));
|
||||
assert_eq!(&img.rgba[0..4], &[0xFF, 0, 0, 0xFF]); // tile 0 → red
|
||||
assert_eq!(&img.rgba[256 * 4..256 * 4 + 4], &[0, 0, 0xFF, 0xFF]); // tile 1 → blue
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_wrong_tilecount_and_short() {
|
||||
// tile-count field that isn't ceil(w/256)*ceil(h/256) → None
|
||||
fn rejects_unknown_variant_and_short() {
|
||||
// type field 7 (unknown) → None
|
||||
let mut b = synth(2, 2);
|
||||
b[0x1c..0x20].copy_from_slice(&7u32.to_be_bytes());
|
||||
assert!(parse(&b).is_none());
|
||||
|
||||
@@ -52,7 +52,10 @@ pub enum TextureError {
|
||||
#[error("No TX2D texture resource found in XPR2 file")]
|
||||
NoTextureFound,
|
||||
|
||||
#[error("Unsupported texture format: 0x{0:02X}")]
|
||||
#[error("Unsupported XPR container '{0}' (this reader handles XPR2 only)")]
|
||||
UnsupportedContainer(String),
|
||||
|
||||
#[error("Unsupported texture format: {} (0x{:02X})", gpu_format_name(*.0), .0)]
|
||||
UnsupportedFormat(u8),
|
||||
|
||||
#[error("Buffer too small: need {needed} bytes, have {have}")]
|
||||
@@ -125,6 +128,159 @@ impl X360TextureFormat {
|
||||
pub fn block_size(&self) -> usize {
|
||||
if self.is_block_compressed() { 4 } else { 1 }
|
||||
}
|
||||
|
||||
/// Canary's canonical `k_…` GPUTEXTUREFORMAT name (e.g. `k_DXT1`).
|
||||
pub fn gpu_name(&self) -> &'static str {
|
||||
gpu_format_name(*self as u8)
|
||||
}
|
||||
|
||||
/// The full Canary format descriptor (bpp, block dims, compression).
|
||||
pub fn desc(&self) -> &'static GpuFormatDesc {
|
||||
// Every enum value has a valid entry in the 0..=63 table.
|
||||
&GPU_FORMATS[*self as usize]
|
||||
}
|
||||
}
|
||||
|
||||
// ── GPUTEXTUREFORMAT reference table (ported from xenia-canary) ─────────────────
|
||||
|
||||
/// One row of Xenia's GPU texture-format table. `bpp` is bits per pixel; for a
|
||||
/// block-compressed format one "block" covers `block_w × block_h` texels.
|
||||
/// Source: xenia-canary `src/xenia/gpu/xenos.h` (`enum class TextureFormat`) +
|
||||
/// `src/xenia/gpu/texture_info_formats.inl` (`FORMAT_INFO(...)`).
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct GpuFormatDesc {
|
||||
/// 6-bit GPUTEXTUREFORMAT code (GPUFC dword_1 bits[5:0]).
|
||||
pub code: u8,
|
||||
/// Canary's canonical name, e.g. `k_8_8_8_8`, `k_DXT4_5`.
|
||||
pub name: &'static str,
|
||||
pub block_w: u8,
|
||||
pub block_h: u8,
|
||||
pub bpp: u16,
|
||||
pub compressed: bool,
|
||||
}
|
||||
|
||||
impl GpuFormatDesc {
|
||||
/// Bytes per block (or per pixel when `block_w == block_h == 1`).
|
||||
pub fn bytes_per_block(&self) -> usize {
|
||||
self.block_w as usize * self.block_h as usize * self.bpp as usize / 8
|
||||
}
|
||||
}
|
||||
|
||||
const fn d(
|
||||
code: u8,
|
||||
name: &'static str,
|
||||
block_w: u8,
|
||||
block_h: u8,
|
||||
bpp: u16,
|
||||
compressed: bool,
|
||||
) -> GpuFormatDesc {
|
||||
GpuFormatDesc { code, name, block_w, block_h, bpp, compressed }
|
||||
}
|
||||
|
||||
/// The complete GPUTEXTUREFORMAT table (codes 0..=63), verbatim from
|
||||
/// xenia-canary. Lets us name/describe *any* texture format the game uses —
|
||||
/// even ones this crate can't yet decode — instead of a bare hex code.
|
||||
#[rustfmt::skip]
|
||||
pub const GPU_FORMATS: [GpuFormatDesc; 64] = [
|
||||
d(0, "k_1_REVERSE", 1, 1, 1, false),
|
||||
d(1, "k_1", 1, 1, 1, false),
|
||||
d(2, "k_8", 1, 1, 8, false),
|
||||
d(3, "k_1_5_5_5", 1, 1, 16, false),
|
||||
d(4, "k_5_6_5", 1, 1, 16, false),
|
||||
d(5, "k_6_5_5", 1, 1, 16, false),
|
||||
d(6, "k_8_8_8_8", 1, 1, 32, false),
|
||||
d(7, "k_2_10_10_10", 1, 1, 32, false),
|
||||
d(8, "k_8_A", 1, 1, 8, false),
|
||||
d(9, "k_8_B", 1, 1, 8, false),
|
||||
d(10, "k_8_8", 1, 1, 16, false),
|
||||
d(11, "k_Cr_Y1_Cb_Y0_REP", 2, 1, 16, true),
|
||||
d(12, "k_Y1_Cr_Y0_Cb_REP", 2, 1, 16, true),
|
||||
d(13, "k_16_16_EDRAM", 1, 1, 32, false),
|
||||
d(14, "k_8_8_8_8_A", 1, 1, 32, false),
|
||||
d(15, "k_4_4_4_4", 1, 1, 16, false),
|
||||
d(16, "k_10_11_11", 1, 1, 32, false),
|
||||
d(17, "k_11_11_10", 1, 1, 32, false),
|
||||
d(18, "k_DXT1", 4, 4, 4, true),
|
||||
d(19, "k_DXT2_3", 4, 4, 8, true),
|
||||
d(20, "k_DXT4_5", 4, 4, 8, true),
|
||||
d(21, "k_16_16_16_16_EDRAM", 1, 1, 64, false),
|
||||
d(22, "k_24_8", 1, 1, 32, false),
|
||||
d(23, "k_24_8_FLOAT", 1, 1, 32, false),
|
||||
d(24, "k_16", 1, 1, 16, false),
|
||||
d(25, "k_16_16", 1, 1, 32, false),
|
||||
d(26, "k_16_16_16_16", 1, 1, 64, false),
|
||||
d(27, "k_16_EXPAND", 1, 1, 16, false),
|
||||
d(28, "k_16_16_EXPAND", 1, 1, 32, false),
|
||||
d(29, "k_16_16_16_16_EXPAND", 1, 1, 64, false),
|
||||
d(30, "k_16_FLOAT", 1, 1, 16, false),
|
||||
d(31, "k_16_16_FLOAT", 1, 1, 32, false),
|
||||
d(32, "k_16_16_16_16_FLOAT", 1, 1, 64, false),
|
||||
d(33, "k_32", 1, 1, 32, false),
|
||||
d(34, "k_32_32", 1, 1, 64, false),
|
||||
d(35, "k_32_32_32_32", 1, 1, 128, false),
|
||||
d(36, "k_32_FLOAT", 1, 1, 32, false),
|
||||
d(37, "k_32_32_FLOAT", 1, 1, 64, false),
|
||||
d(38, "k_32_32_32_32_FLOAT", 1, 1, 128, false),
|
||||
d(39, "k_32_AS_8", 4, 1, 8, true),
|
||||
d(40, "k_32_AS_8_8", 2, 1, 16, true),
|
||||
d(41, "k_16_MPEG", 1, 1, 16, false),
|
||||
d(42, "k_16_16_MPEG", 1, 1, 32, false),
|
||||
d(43, "k_8_INTERLACED", 1, 1, 8, false),
|
||||
d(44, "k_32_AS_8_INTERLACED", 4, 1, 8, true),
|
||||
d(45, "k_32_AS_8_8_INTERLACED", 1, 1, 16, true),
|
||||
d(46, "k_16_INTERLACED", 1, 1, 16, false),
|
||||
d(47, "k_16_MPEG_INTERLACED", 1, 1, 16, false),
|
||||
d(48, "k_16_16_MPEG_INTERLACED", 1, 1, 32, false),
|
||||
d(49, "k_DXN", 4, 4, 8, true),
|
||||
d(50, "k_8_8_8_8_AS_16_16_16_16", 1, 1, 32, false),
|
||||
d(51, "k_DXT1_AS_16_16_16_16", 4, 4, 4, true),
|
||||
d(52, "k_DXT2_3_AS_16_16_16_16", 4, 4, 8, true),
|
||||
d(53, "k_DXT4_5_AS_16_16_16_16", 4, 4, 8, true),
|
||||
d(54, "k_2_10_10_10_AS_16_16_16_16", 1, 1, 32, false),
|
||||
d(55, "k_10_11_11_AS_16_16_16_16", 1, 1, 32, false),
|
||||
d(56, "k_11_11_10_AS_16_16_16_16", 1, 1, 32, false),
|
||||
d(57, "k_32_32_32_FLOAT", 1, 1, 96, false),
|
||||
d(58, "k_DXT3A", 4, 4, 4, true),
|
||||
d(59, "k_DXT5A", 4, 4, 4, true),
|
||||
d(60, "k_CTX1", 4, 4, 4, true),
|
||||
d(61, "k_DXT3A_AS_1_1_1_1", 4, 4, 4, true),
|
||||
d(62, "k_8_8_8_8_GAMMA_EDRAM", 1, 1, 32, false),
|
||||
d(63, "k_2_10_10_10_FLOAT_EDRAM", 1, 1, 32, false),
|
||||
];
|
||||
|
||||
/// Canary's canonical name for a 6-bit GPUTEXTUREFORMAT code, or
|
||||
/// `"unknown(NN)"` when out of the 0..=63 range.
|
||||
pub fn gpu_format_name(code: u8) -> &'static str {
|
||||
GPU_FORMATS
|
||||
.get(code as usize)
|
||||
.map(|f| f.name)
|
||||
.unwrap_or("unknown")
|
||||
}
|
||||
|
||||
/// The full descriptor for a GPUTEXTUREFORMAT code, if in range.
|
||||
pub fn gpu_format_desc(code: u8) -> Option<&'static GpuFormatDesc> {
|
||||
GPU_FORMATS.get(code as usize)
|
||||
}
|
||||
|
||||
/// Identify the XPR container variant from the 4-byte magic (`XPR0`/`XPR2`/
|
||||
/// `XPR5`/…), so callers can report `XPR5` clearly instead of "bad magic".
|
||||
pub fn xpr_container_kind(bytes: &[u8]) -> Option<String> {
|
||||
if bytes.len() >= 4 && &bytes[..3] == b"XPR" {
|
||||
Some(String::from_utf8_lossy(&bytes[..4]).into_owned())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Guard the XPR2-only decode paths: turn a non-XPR2 container into a clear
|
||||
/// [`TextureError::UnsupportedContainer`] before binrw reports a generic
|
||||
/// magic mismatch. (The game also ships some `XPR5` packages, e.g. Common.xpr.)
|
||||
fn ensure_xpr2(bytes: &[u8]) -> Result<(), TextureError> {
|
||||
match xpr_container_kind(bytes) {
|
||||
Some(k) if k == "XPR2" => Ok(()),
|
||||
Some(k) => Err(TextureError::UnsupportedContainer(k)),
|
||||
None => Ok(()), // let the normal magic check produce BadMagic
|
||||
}
|
||||
}
|
||||
|
||||
// ── XPR2 container format ─────────────────────────────────────────────────────
|
||||
@@ -261,6 +417,7 @@ impl X360Texture {
|
||||
/// Decode the `want`-th texture resource (`TX2D` / `TXCM`, directory order).
|
||||
pub fn from_xpr2_index(bytes: &[u8], want: usize) -> Result<Self, TextureError> {
|
||||
use std::io::Cursor;
|
||||
ensure_xpr2(bytes)?;
|
||||
let mut cur = Cursor::new(bytes);
|
||||
|
||||
// Parse header — validates "XPR2" magic, reads 3 × u32 (total 16 bytes)
|
||||
@@ -353,6 +510,7 @@ impl X360Texture {
|
||||
/// `BG_Acheron`: `data_size == 6 × 0x400000` and all 6 faces decode cleanly.)
|
||||
pub fn cube_faces_from_xpr2(bytes: &[u8]) -> Result<Option<Cubemap>, TextureError> {
|
||||
use std::io::Cursor;
|
||||
ensure_xpr2(bytes)?;
|
||||
let mut cur = Cursor::new(bytes);
|
||||
let header = Xpr2Header::read(&mut cur)?;
|
||||
let mut entries = Vec::new();
|
||||
@@ -640,6 +798,25 @@ fn compact_bits(mut x: u32) -> u32 {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn gpu_format_table_is_index_aligned() {
|
||||
// The hand-transcribed Canary table must stay index==code for all 64.
|
||||
for (i, f) in GPU_FORMATS.iter().enumerate() {
|
||||
assert_eq!(f.code as usize, i, "GPU_FORMATS[{i}] has code {}", f.code);
|
||||
}
|
||||
// Spot-check the formats the game actually uses (from xenos.h + .inl).
|
||||
assert_eq!(gpu_format_name(6), "k_8_8_8_8");
|
||||
assert_eq!(gpu_format_name(18), "k_DXT1");
|
||||
assert_eq!(gpu_format_name(59), "k_DXT5A");
|
||||
assert_eq!(gpu_format_name(200), "unknown");
|
||||
// Every decodable enum variant resolves to a compressed/uncompressed
|
||||
// descriptor consistent with its own is_block_compressed().
|
||||
for code in [6u8, 7, 18, 19, 20, 49, 59] {
|
||||
let fmt = X360TextureFormat::from_u8(code).unwrap();
|
||||
assert_eq!(fmt.desc().compressed, fmt.is_block_compressed(), "code {code}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn morton_decode_corners() {
|
||||
assert_eq!(morton_decode(0), (0, 0));
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
//! Run: `cargo test -p sylpheed-formats --test mesh_disc -- --ignored --nocapture`
|
||||
|
||||
use std::path::PathBuf;
|
||||
use sylpheed_formats::mesh::{material_groups, node_transforms, submesh_albedos, Xbg7Model};
|
||||
use sylpheed_formats::mesh::Xbg7Model;
|
||||
|
||||
fn res3d_dir() -> Option<PathBuf> {
|
||||
if let Ok(p) = std::env::var("SYLPHEED_RES3D") {
|
||||
@@ -21,119 +21,6 @@ fn res3d_dir() -> Option<PathBuf> {
|
||||
default.is_dir().then_some(default)
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "requires extracted disc models — set SYLPHEED_RES3D"]
|
||||
fn hero_ship_submesh_material_graph() {
|
||||
let Some(dir) = res3d_dir() else {
|
||||
eprintln!("SKIP: resource3d dir not found (set SYLPHEED_RES3D)");
|
||||
return;
|
||||
};
|
||||
// The XBG7 node/material graph tags each sub-mesh record with its own albedo
|
||||
// (`rou_…_col` → TX2D name). DeltaSaber_T `f001`: the 7 detail parts use
|
||||
// bdy_04/06/07 — NOT the body's bdy_01a — which is the per-part texturing the
|
||||
// viewer needs so fins aren't painted with the hull map.
|
||||
let bytes = std::fs::read(dir.join("DeltaSaber_T.xpr")).unwrap();
|
||||
let mut map = std::collections::HashMap::new();
|
||||
for (v, i, name) in submesh_albedos(&bytes, "f001") {
|
||||
map.insert((v, i), name);
|
||||
}
|
||||
// (vtx, idx) → expected albedo (rou_ stripped = TX2D name).
|
||||
assert_eq!(map.get(&(314, 645)).map(String::as_str), Some("f001_bdy_04_col"));
|
||||
assert_eq!(map.get(&(48, 84)).map(String::as_str), Some("f001_bdy_04_col"));
|
||||
assert_eq!(map.get(&(96, 180)).map(String::as_str), Some("f001_bdy_06_col"));
|
||||
assert_eq!(map.get(&(60, 108)).map(String::as_str), Some("f001_bdy_07_col"));
|
||||
// Names strip cleanly to real TX2D resources.
|
||||
let tex = sylpheed_formats::texture::X360Texture::texture_names(&bytes);
|
||||
for name in map.values() {
|
||||
assert!(tex.iter().any(|t| t == name), "albedo {name} not a TX2D resource");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "requires extracted disc models — set SYLPHEED_RES3D"]
|
||||
fn hero_ship_body_splits_by_material() {
|
||||
let Some(dir) = res3d_dir() else {
|
||||
eprintln!("SKIP: resource3d dir not found (set SYLPHEED_RES3D)");
|
||||
return;
|
||||
};
|
||||
// The merged body (sub0 = 24561 indices / 8187 tris) is drawn as 9 groups
|
||||
// sharing one index buffer, each with its own albedo (bdy_01a hull, bdy_01b,
|
||||
// bdy_02/03, and the `daiza` hangar stand). `material_groups` recovers the
|
||||
// cumulative-offset chain so the viewer can texture each slice.
|
||||
let bytes = std::fs::read(dir.join("DeltaSaber_T.xpr")).unwrap();
|
||||
let groups = material_groups(&bytes, "f001", 24561);
|
||||
assert_eq!(groups.len(), 9, "body must split into 9 material groups");
|
||||
// Offsets chain from 0 and cover the whole index buffer exactly.
|
||||
let mut cursor = 0usize;
|
||||
for g in &groups {
|
||||
assert_eq!(g.idx_offset, cursor, "group offsets must be contiguous");
|
||||
cursor += g.idx_count;
|
||||
}
|
||||
assert_eq!(cursor, 24561, "groups must cover all body indices");
|
||||
// Expected per-group albedo (verified against the GPU draw log).
|
||||
let albedos: Vec<&str> = groups.iter().map(|g| g.albedo.as_str()).collect();
|
||||
assert_eq!(
|
||||
albedos,
|
||||
[
|
||||
"f001_bdy_01a_col",
|
||||
"f001_bdy_01a_col",
|
||||
"f001_bdy_01a_col",
|
||||
"f001_bdy_01b_col",
|
||||
"f001_bdy_01a_col",
|
||||
"f001_bdy_01b_col",
|
||||
"f001_bdy_02_col",
|
||||
"f001_bdy_03_col",
|
||||
"f001_bdy_daiza_col",
|
||||
]
|
||||
);
|
||||
// A single-material detail part (sub1 = 645 indices) → one group, bdy_04.
|
||||
let fin = material_groups(&bytes, "f001", 645);
|
||||
assert_eq!(fin.len(), 1);
|
||||
assert_eq!(fin[0].albedo, "f001_bdy_04_col");
|
||||
assert_eq!(fin[0].idx_offset, 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "requires extracted disc models — set SYLPHEED_RES3D"]
|
||||
fn hero_ship_node_transforms_move_fins_to_tail() {
|
||||
let Some(dir) = res3d_dir() else {
|
||||
eprintln!("SKIP: resource3d dir not found (set SYLPHEED_RES3D)");
|
||||
return;
|
||||
};
|
||||
// For the DeltaSaber, node_transforms returns the MEASURED runtime placements
|
||||
// (Canary draw-log WVP; see mesh.rs::DELTASABER_MEASURED) — the fin assemblies
|
||||
// are mounted OUT on the nacelles (world X ≈ −4.4..−6.6), an offset the static
|
||||
// graph omits. Body identity; each part a left/right mirrored pair. Vertex
|
||||
// space: X right, Y up, Z fore/aft (engines at −Z).
|
||||
let bytes = std::fs::read(dir.join("DeltaSaber_T.xpr")).unwrap();
|
||||
let places = node_transforms(&bytes, "f001");
|
||||
assert!(!places.is_empty(), "expected node placements");
|
||||
// Body (sub 0) identity, drawn once.
|
||||
let body: Vec<_> = places.iter().filter(|p| p.sub_index == 0).collect();
|
||||
assert_eq!(body.len(), 1, "body drawn once");
|
||||
assert!(body[0].t.iter().all(|c| c.abs() < 0.1), "body must not translate");
|
||||
assert!(!body[0].reflect, "body is not mirrored");
|
||||
// Fin bdy_04 (sub 1): mirrored pair near the tail, mounted OUT on the nacelle
|
||||
// (|X| ≈ 5.2, not the graph's inboard ≈1.1).
|
||||
let fins: Vec<_> = places.iter().filter(|p| p.sub_index == 1).collect();
|
||||
assert_eq!(fins.len(), 2, "V-tail is a mirrored pair");
|
||||
assert!(fins.iter().all(|f| (f.t[2] + 9.72).abs() < 0.3), "fin fore/aft ≈ −9.7");
|
||||
assert!(fins.iter().all(|f| f.t[0].abs() > 4.0), "fin mounted out on the nacelle");
|
||||
assert!(fins[0].t[0] * fins[1].t[0] < 0.0, "the pair mirrors across X");
|
||||
assert!(fins.iter().any(|f| f.reflect), "one of the pair is reflected");
|
||||
// Winglet bdy_06 (sub 4): on the nacelle (|X| ≈ 6.6, Z ≈ −15.5).
|
||||
let wings: Vec<_> = places.iter().filter(|p| p.sub_index == 4).collect();
|
||||
assert_eq!(wings.len(), 2, "L/R winglet pair");
|
||||
assert!(wings.iter().all(|p| p.t[0].abs() > 6.0 && (p.t[2] + 15.5).abs() < 0.3),
|
||||
"winglets out on the nacelle");
|
||||
assert!(wings[0].t[0] * wings[1].t[0] < 0.0, "winglets mirror across X");
|
||||
// Small fin bdy_10 (sub 6): inboard nacelle stub (|X| ≈ 4.45, Z ≈ −17).
|
||||
let sfins: Vec<_> = places.iter().filter(|p| p.sub_index == 6).collect();
|
||||
assert_eq!(sfins.len(), 2, "L/R small-fin pair");
|
||||
assert!(sfins.iter().all(|p| (p.t[0].abs() - 4.45).abs() < 0.3), "small fins on the stub");
|
||||
assert!(sfins[0].t[0] * sfins[1].t[0] < 0.0, "small fins mirror across X");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "requires extracted disc models — set SYLPHEED_RES3D"]
|
||||
fn weapon_model_decodes_to_expected_geometry() {
|
||||
@@ -235,85 +122,6 @@ fn complex_body_mesh_is_declined_not_garbage() {
|
||||
}
|
||||
}
|
||||
|
||||
/// The hero ship's **grouped-pool** layout decodes fully: `DeltaSaber_T.xpr`'s
|
||||
/// `f001` resource is one vertex+index pool shared by 8 sub-meshes (body + 7
|
||||
/// detail parts). Reversed statically and cross-checked against a Canary GPU
|
||||
/// draw-log capture — every sub-mesh's stored normals agree with its triangle
|
||||
/// winding (0 degenerate, full vertex coverage). This is the layout the old
|
||||
/// per-block adjacency anchor rendered as a spiky phantom.
|
||||
#[test]
|
||||
#[ignore = "requires extracted disc models — set SYLPHEED_RES3D"]
|
||||
fn hero_ship_grouped_pool_decodes() {
|
||||
let Some(dir) = res3d_dir() else {
|
||||
eprintln!("SKIP: resource3d dir not found (set SYLPHEED_RES3D)");
|
||||
return;
|
||||
};
|
||||
let bytes = std::fs::read(dir.join("DeltaSaber_T.xpr")).unwrap();
|
||||
let models = Xbg7Model::stage_models(&bytes);
|
||||
|
||||
// The neutral pose `f001` (the mnv*/turn180 resources are animation poses).
|
||||
let f001 = models.iter().find(|m| m.name == "f001").expect("f001 decoded");
|
||||
assert_eq!(f001.meshes.len(), 8, "body + 7 detail sub-meshes");
|
||||
let (v, t) = f001.totals();
|
||||
assert_eq!(v, 11607, "vertex total across sub-meshes");
|
||||
assert_eq!(t, 8650, "triangle total (body 8187 + 7 parts)");
|
||||
|
||||
// Sub-mesh 0 is the body: exactly the draw-log-verified geometry.
|
||||
let body = &f001.meshes[0];
|
||||
assert_eq!(body.positions.len(), 10891);
|
||||
assert_eq!(body.indices.len(), 24561);
|
||||
|
||||
for (i, m) in f001.meshes.iter().enumerate() {
|
||||
// Every index in range.
|
||||
assert!(
|
||||
m.indices.iter().all(|&ix| (ix as usize) < m.positions.len()),
|
||||
"sub{i}: index out of range"
|
||||
);
|
||||
// Correct alignment ⇒ unit normals, and the winding agrees with them
|
||||
// (the decisive correctness signal, ~1.0, not the ~0.5 of a mis-carve).
|
||||
let n = m.normals.len();
|
||||
assert_eq!(n, m.positions.len(), "sub{i}: a normal per vertex");
|
||||
let mean_nlen: f32 = m
|
||||
.normals
|
||||
.iter()
|
||||
.map(|nv| (nv[0] * nv[0] + nv[1] * nv[1] + nv[2] * nv[2]).sqrt())
|
||||
.sum::<f32>()
|
||||
/ n as f32;
|
||||
assert!((mean_nlen - 1.0).abs() < 0.05, "sub{i}: mean |normal| {mean_nlen} ≠ 1");
|
||||
|
||||
let mut agree = 0usize;
|
||||
let mut counted = 0usize;
|
||||
for tri in m.indices.chunks_exact(3) {
|
||||
let (a, b, c) = (tri[0] as usize, tri[1] as usize, tri[2] as usize);
|
||||
let (pa, pb, pc) = (m.positions[a], m.positions[b], m.positions[c]);
|
||||
let u = [pb[0] - pa[0], pb[1] - pa[1], pb[2] - pa[2]];
|
||||
let w = [pc[0] - pa[0], pc[1] - pa[1], pc[2] - pa[2]];
|
||||
let f = [
|
||||
u[1] * w[2] - u[2] * w[1],
|
||||
u[2] * w[0] - u[0] * w[2],
|
||||
u[0] * w[1] - u[1] * w[0],
|
||||
];
|
||||
if f[0] * f[0] + f[1] * f[1] + f[2] * f[2] < 1e-12 {
|
||||
continue;
|
||||
}
|
||||
let sn = [
|
||||
m.normals[a][0] + m.normals[b][0] + m.normals[c][0],
|
||||
m.normals[a][1] + m.normals[b][1] + m.normals[c][1],
|
||||
m.normals[a][2] + m.normals[b][2] + m.normals[c][2],
|
||||
];
|
||||
if f[0] * sn[0] + f[1] * sn[1] + f[2] * sn[2] > 0.0 {
|
||||
agree += 1;
|
||||
}
|
||||
counted += 1;
|
||||
}
|
||||
let na = agree as f32 / counted.max(1) as f32;
|
||||
assert!(
|
||||
na.max(1.0 - na) > 0.95,
|
||||
"sub{i}: winding-vs-normal agreement {na} — mis-carved (should be ~1.0 or ~0.0)"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Stage containers decode multiple enemy/prop sub-models via content anchoring.
|
||||
/// Prints coverage; asserts the known-good Stage_S10 meshes decode with sane geometry.
|
||||
#[test]
|
||||
|
||||
@@ -1,102 +0,0 @@
|
||||
//! Real-disc test for the movie manifest → voice binding. Skipped without
|
||||
//! `SYLPHEED_DISC`.
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
use sylpheed_formats::movie_manifest;
|
||||
use sylpheed_formats::slb::VoiceLang;
|
||||
use sylpheed_formats::PakArchive;
|
||||
|
||||
fn disc_root() -> Option<PathBuf> {
|
||||
let p = PathBuf::from(std::env::var("SYLPHEED_DISC").ok()?);
|
||||
p.join("dat").is_dir().then_some(p)
|
||||
}
|
||||
|
||||
/// Read the manifest + `eng\sounds.tbl` out of `tables.pak`.
|
||||
fn load_manifest_and_sounds(root: &PathBuf) -> (Vec<u8>, Vec<u8>) {
|
||||
let pak = PakArchive::open(root.join("dat/tables.pak")).unwrap();
|
||||
let manifest = pak
|
||||
.entries()
|
||||
.iter()
|
||||
.find_map(|e| pak.read(e).ok().filter(|b| movie_manifest::is_manifest(b)))
|
||||
.expect("movie manifest present in tables.pak");
|
||||
let sounds = pak
|
||||
.read_by_name("eng\\sounds.tbl")
|
||||
.expect("sounds.tbl present")
|
||||
.unwrap();
|
||||
(manifest, sounds)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn binds_and_resolves_movie_voice() {
|
||||
let Some(root) = disc_root() else {
|
||||
eprintln!("SKIP: set SYLPHEED_DISC");
|
||||
return;
|
||||
};
|
||||
let (manifest, sounds) = load_manifest_and_sounds(&root);
|
||||
let entries = movie_manifest::parse(&manifest);
|
||||
assert!(entries.len() > 90, "expected ~101 movies, got {}", entries.len());
|
||||
|
||||
// Standard story movie → VOICE_<movie> in <lang>\Movie\.
|
||||
assert_eq!(
|
||||
movie_manifest::voice_token(&manifest, "S13A").as_deref(),
|
||||
Some("VOICE_S13A")
|
||||
);
|
||||
assert_eq!(
|
||||
movie_manifest::resolve_voice_entry(&manifest, &sounds, "S13A", VoiceLang::English)
|
||||
.as_deref(),
|
||||
Some("eng\\Movie\\VOICE_S13A.slb")
|
||||
);
|
||||
|
||||
// A resupply movie bound to an in-mission radio clip → VOICE_D_* in \etc\.
|
||||
// (This is what a `VOICE_<movie>` guess would miss entirely.)
|
||||
assert_eq!(
|
||||
movie_manifest::voice_token(&manifest, "hokyu_LS_s02A").as_deref(),
|
||||
Some("VOICE_D_450")
|
||||
);
|
||||
assert_eq!(
|
||||
movie_manifest::resolve_voice_entry(
|
||||
&manifest,
|
||||
&sounds,
|
||||
"hokyu_LS_s02A",
|
||||
VoiceLang::English
|
||||
)
|
||||
.as_deref(),
|
||||
Some("eng\\etc\\VOICE_D_450.slb")
|
||||
);
|
||||
|
||||
// A resupply movie the game leaves unbound in the manifest → no DIRECT
|
||||
// binding. (Extending to unbound movies by shared demo line was verified
|
||||
// WRONG against the running game, so we do NOT resolve these.)
|
||||
let e = entries
|
||||
.iter()
|
||||
.find(|e| e.movie == "hokyu_DS_s13A")
|
||||
.expect("hokyu_DS_s13A present in manifest");
|
||||
assert_eq!(e.voice_token, None, "hokyu_DS_s13A has no direct voice binding");
|
||||
assert_eq!(
|
||||
movie_manifest::resolve_voice_entry(&manifest, &sounds, "hokyu_DS_s13A", VoiceLang::English),
|
||||
None
|
||||
);
|
||||
|
||||
// Every resolved voice entry must actually exist in sound.pak.
|
||||
let snd = std::fs::read(root.join("dat/sound.pak")).unwrap();
|
||||
let keys: std::collections::HashSet<u32> = PakArchive::parse_toc(&snd)
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|e| e.name_hash)
|
||||
.collect();
|
||||
let mut resolved = 0;
|
||||
let mut missing = Vec::new();
|
||||
for e in &entries {
|
||||
if let Some(full) =
|
||||
movie_manifest::resolve_voice_entry(&manifest, &sounds, &e.movie, VoiceLang::English)
|
||||
{
|
||||
resolved += 1;
|
||||
if !keys.contains(&sylpheed_formats::hash::name_hash(&full)) {
|
||||
missing.push(full);
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(resolved > 80, "expected 80+ voiced movies, got {resolved}");
|
||||
assert!(missing.is_empty(), "resolved but absent in sound.pak: {missing:?}");
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
//! Real-disc test for the movie subtitle chain. Skipped when the extracted disc
|
||||
//! is absent (set `SYLPHEED_DISC` to the extract root to enable).
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
use sylpheed_formats::movie_subtitle::{self, SubLang};
|
||||
use sylpheed_formats::PakArchive;
|
||||
|
||||
fn disc_root() -> Option<PathBuf> {
|
||||
let p = PathBuf::from(std::env::var("SYLPHEED_DISC").ok()?);
|
||||
p.join("dat").is_dir().then_some(p)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolves_english_radio_subtitles() {
|
||||
let Some(root) = disc_root() else {
|
||||
eprintln!("SKIP: set SYLPHEED_DISC");
|
||||
return;
|
||||
};
|
||||
let lang = SubLang::English;
|
||||
let lang_pak = PakArchive::open(root.join(format!("dat/movie/{}.pak", lang.pak_code()))).unwrap();
|
||||
let text_pak =
|
||||
PakArchive::open(root.join(format!("dat/GP_MAIN_GAME_{}.pak", lang.game_code()))).unwrap();
|
||||
|
||||
// A radio movie: real timed English dialogue.
|
||||
let cues = movie_subtitle::load("RT01C_1", &lang_pak, &text_pak);
|
||||
assert!(!cues.is_empty(), "RT01C_1 should have timed cues");
|
||||
assert!(cues[0].start >= 0.0 && cues[0].start < 5.0);
|
||||
assert!(
|
||||
cues.iter().any(|c| c.text.contains("Rhino Leader")),
|
||||
"expected recognizable dialogue, got: {:?}",
|
||||
cues.iter().map(|c| &c.text).collect::<Vec<_>>()
|
||||
);
|
||||
|
||||
// No MSG_DEMO keys should leak into resolved caption text.
|
||||
assert!(
|
||||
cues.iter().all(|c| !c.text.contains("MSG_DEMO")),
|
||||
"unresolved key leaked: {:?}",
|
||||
cues.iter().map(|c| &c.text).collect::<Vec<_>>()
|
||||
);
|
||||
|
||||
// A resupply movie: the canonical resupply line.
|
||||
let hokyu = movie_subtitle::load("hokyu_DS_s02A", &lang_pak, &text_pak);
|
||||
assert!(hokyu.iter().any(|c| c.text.contains("Resupply complete")));
|
||||
|
||||
// S00A carries inline narration text (not MSG_DEMO refs) with timecodes.
|
||||
let story = movie_subtitle::load("S00A", &lang_pak, &text_pak);
|
||||
assert!(!story.is_empty() && story.iter().any(|c| c.text.contains("27th century")));
|
||||
|
||||
// S13A stores a two-line caption as two consecutive text tokens sharing one
|
||||
// timing; both lines must survive (the "Look at it father" regression — the
|
||||
// first line used to be dropped).
|
||||
let s13 = movie_subtitle::load("S13A", &lang_pak, &text_pak);
|
||||
let multiline = s13
|
||||
.iter()
|
||||
.find(|c| c.text.contains("Look at it father"))
|
||||
.expect("S13A should contain the 'Look at it father' caption");
|
||||
assert_eq!(
|
||||
multiline.text, "Look at it father\n& beautiful isn't it",
|
||||
"both lines of the caption must be present"
|
||||
);
|
||||
assert!((multiline.start - 74.8).abs() < 0.1, "start {}", multiline.start);
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
//! Real-disc test: read a movie voice `.slb` out of the segmented `sound.pak`
|
||||
//! and rebuild a decodable XMA1 RIFF. Skipped without `SYLPHEED_DISC`.
|
||||
|
||||
use std::fs::File;
|
||||
use std::io::{Read, Seek, SeekFrom};
|
||||
use std::path::PathBuf;
|
||||
|
||||
use sylpheed_formats::hash::name_hash;
|
||||
use sylpheed_formats::slb::{self, VoiceLang};
|
||||
use sylpheed_formats::PakArchive;
|
||||
|
||||
fn disc_root() -> Option<PathBuf> {
|
||||
let p = PathBuf::from(std::env::var("SYLPHEED_DISC").ok()?);
|
||||
p.join("dat").is_dir().then_some(p)
|
||||
}
|
||||
|
||||
/// Read `[off, off+size)` from `dat/sound.p00..` (segments concatenated).
|
||||
fn read_range(root: &PathBuf, mut off: u64, size: usize) -> Vec<u8> {
|
||||
let mut out = Vec::with_capacity(size);
|
||||
let mut need = size;
|
||||
for i in 0..100u32 {
|
||||
if need == 0 {
|
||||
break;
|
||||
}
|
||||
let seg = root.join(format!("dat/sound.p{i:02}"));
|
||||
let Ok(meta) = std::fs::metadata(&seg) else { break };
|
||||
let len = meta.len();
|
||||
if off >= len {
|
||||
off -= len;
|
||||
continue;
|
||||
}
|
||||
let mut f = File::open(&seg).unwrap();
|
||||
f.seek(SeekFrom::Start(off)).unwrap();
|
||||
let take = need.min((len - off) as usize);
|
||||
let start = out.len();
|
||||
out.resize(start + take, 0);
|
||||
f.read_exact(&mut out[start..]).unwrap();
|
||||
need -= take;
|
||||
off = 0;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_and_rebuilds_movie_voice_riff() {
|
||||
let Some(root) = disc_root() else {
|
||||
eprintln!("SKIP: set SYLPHEED_DISC");
|
||||
return;
|
||||
};
|
||||
let toc = std::fs::read(root.join("dat/sound.pak")).unwrap();
|
||||
let entries = PakArchive::parse_toc(&toc).unwrap();
|
||||
assert_eq!(entries.len(), 9519);
|
||||
|
||||
for movie in ["S00A", "RT07A", "RT02D_1"] {
|
||||
// RT02D_1 is a headerless variant; S00A/RT07A embed a RIFF.
|
||||
let key = name_hash(&slb::movie_voice_name(movie, VoiceLang::English));
|
||||
let idx = entries
|
||||
.binary_search_by_key(&key, |e| e.name_hash)
|
||||
.unwrap_or_else(|_| panic!("{movie} voice missing"));
|
||||
let e = &entries[idx];
|
||||
let bank = read_range(&root, e.offset as u64, e.comp_size as usize);
|
||||
|
||||
let riff = slb::to_xma_riff(&bank).expect("rebuild RIFF");
|
||||
assert_eq!(&riff[0..4], b"RIFF", "{movie}");
|
||||
assert_eq!(&riff[8..12], b"WAVE", "{movie}");
|
||||
// fmt chunk advertises XMA1 (tag 0x0165).
|
||||
let fpos = riff.windows(4).position(|w| w == b"fmt ").unwrap();
|
||||
let tag = u16::from_le_bytes([riff[fpos + 8], riff[fpos + 9]]);
|
||||
assert_eq!(tag, 0x0165, "{movie} should be XMA1");
|
||||
// data chunk carries the XMA payload.
|
||||
let dpos = riff.windows(4).position(|w| w == b"data").unwrap();
|
||||
let dsz = u32::from_le_bytes([
|
||||
riff[dpos + 4],
|
||||
riff[dpos + 5],
|
||||
riff[dpos + 6],
|
||||
riff[dpos + 7],
|
||||
]) as usize;
|
||||
assert!(dsz > 10_000, "{movie} data too small: {dsz}");
|
||||
assert_eq!(riff.len(), dpos + 8 + dsz, "{movie} data length consistent");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn enumerates_voice_clips_from_sounds_tbl() {
|
||||
let Some(root) = disc_root() else {
|
||||
eprintln!("SKIP: set SYLPHEED_DISC");
|
||||
return;
|
||||
};
|
||||
let pak = PakArchive::open(root.join("dat/tables.pak")).unwrap();
|
||||
let tbl = pak.read_by_name("eng\\sounds.tbl").unwrap().unwrap();
|
||||
let clips = slb::list_voice_clips(&tbl, VoiceLang::English);
|
||||
assert!(clips.len() > 1000, "expected many voice clips, got {}", clips.len());
|
||||
// Every clip is an eng voice path present in sound.pak.
|
||||
let sound = std::fs::read(root.join("dat/sound.pak")).unwrap();
|
||||
let keys: std::collections::HashSet<u32> =
|
||||
PakArchive::parse_toc(&sound).unwrap().iter().map(|e| e.name_hash).collect();
|
||||
let present = clips.iter().filter(|c| keys.contains(&name_hash(&c.name))).count();
|
||||
assert!(
|
||||
present as f32 / clips.len() as f32 > 0.95,
|
||||
"{present}/{} clips resolve in sound.pak",
|
||||
clips.len()
|
||||
);
|
||||
assert!(clips.iter().any(|c| c.speaker == "ADAN"));
|
||||
}
|
||||
@@ -8,10 +8,6 @@
|
||||
|
||||
use bevy::prelude::*;
|
||||
use bevy::input::mouse::{MouseMotion, MouseWheel};
|
||||
use bevy::render::render_asset::RenderAssetUsages;
|
||||
use bevy::render::render_resource::{
|
||||
Extent3d, TextureDimension, TextureFormat, TextureViewDescriptor, TextureViewDimension,
|
||||
};
|
||||
|
||||
pub struct OrbitCameraPlugin;
|
||||
|
||||
@@ -58,17 +54,10 @@ impl Default for OrbitCamera {
|
||||
}
|
||||
}
|
||||
|
||||
fn spawn_camera(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
|
||||
fn spawn_camera(mut commands: Commands) {
|
||||
let orbit = OrbitCamera::default();
|
||||
let transform = orbit_transform(&orbit);
|
||||
|
||||
// The game's ship shader reflects a shared HDR environment cubemap off the
|
||||
// hull (three cube samples — see the shader RE). Reproduce that "look" with a
|
||||
// procedural sky cube feeding Bevy's image-based lighting, so metallic
|
||||
// surfaces reflect an environment instead of reading flat. Procedural (not a
|
||||
// bundled KTX2) so it also works on WASM with no extra assets.
|
||||
let env = make_env_cubemap(&mut images);
|
||||
|
||||
commands.spawn((
|
||||
Camera3d::default(),
|
||||
// Wide near/far so both tiny weapons and multi-thousand-unit stages fit;
|
||||
@@ -80,78 +69,9 @@ fn spawn_camera(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
|
||||
}),
|
||||
transform,
|
||||
orbit,
|
||||
EnvironmentMapLight {
|
||||
diffuse_map: env.clone(),
|
||||
specular_map: env,
|
||||
intensity: 900.0,
|
||||
..default()
|
||||
},
|
||||
));
|
||||
}
|
||||
|
||||
/// Build a small procedural sky cubemap (6 faces) for image-based lighting.
|
||||
///
|
||||
/// A vertical gradient (bright zenith → warm horizon → dark ground) plus a warm
|
||||
/// "sun" highlight roughly where the game's key light sits — enough for a
|
||||
/// metallic hull to read as reflective rather than flat. Stored as an sRGB cube
|
||||
/// (filterable, no half-float encoding needed); a single mip means reflections
|
||||
/// stay sharp (fine for a shiny ship).
|
||||
fn make_env_cubemap(images: &mut Assets<Image>) -> Handle<Image> {
|
||||
let size: i32 = 64;
|
||||
// Approx key-light direction from the RE (PS c32 ≈ (0,-0.76,-0.65), i.e. light
|
||||
// arriving from top-front); place the bright spot there.
|
||||
let sun = Vec3::new(0.0, 0.85, 0.5).normalize();
|
||||
let zenith = Vec3::new(0.70, 0.80, 0.95);
|
||||
let horizon = Vec3::new(0.42, 0.45, 0.50);
|
||||
let ground = Vec3::new(0.09, 0.09, 0.11);
|
||||
let srgb = |c: f32| (c.clamp(0.0, 1.0).powf(1.0 / 2.2) * 255.0).round() as u8;
|
||||
|
||||
let mut data: Vec<u8> = Vec::with_capacity((size * size * 6 * 4) as usize);
|
||||
for face in 0..6 {
|
||||
for y in 0..size {
|
||||
for x in 0..size {
|
||||
let u = (x as f32 + 0.5) / size as f32 * 2.0 - 1.0;
|
||||
let v = (y as f32 + 0.5) / size as f32 * 2.0 - 1.0;
|
||||
// Standard cube-face → direction mapping.
|
||||
let d = match face {
|
||||
0 => Vec3::new(1.0, -v, -u),
|
||||
1 => Vec3::new(-1.0, -v, u),
|
||||
2 => Vec3::new(u, 1.0, v),
|
||||
3 => Vec3::new(u, -1.0, -v),
|
||||
4 => Vec3::new(u, -v, 1.0),
|
||||
_ => Vec3::new(-u, -v, -1.0),
|
||||
}
|
||||
.normalize();
|
||||
let mut col = if d.y >= 0.0 {
|
||||
horizon.lerp(zenith, (d.y).powf(0.6))
|
||||
} else {
|
||||
horizon.lerp(ground, (-d.y).powf(0.5))
|
||||
};
|
||||
let s = d.dot(sun).max(0.0).powf(60.0);
|
||||
col += Vec3::new(1.0, 0.85, 0.6) * s * 1.5;
|
||||
data.extend_from_slice(&[srgb(col.x), srgb(col.y), srgb(col.z), 255]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut image = Image::new(
|
||||
Extent3d {
|
||||
width: size as u32,
|
||||
height: size as u32,
|
||||
depth_or_array_layers: 6,
|
||||
},
|
||||
TextureDimension::D2,
|
||||
data,
|
||||
TextureFormat::Rgba8UnormSrgb,
|
||||
RenderAssetUsages::RENDER_WORLD,
|
||||
);
|
||||
image.texture_view_descriptor = Some(TextureViewDescriptor {
|
||||
dimension: Some(TextureViewDimension::Cube),
|
||||
..default()
|
||||
});
|
||||
images.add(image)
|
||||
}
|
||||
|
||||
fn orbit_camera(
|
||||
mut query: Query<(&mut OrbitCamera, &mut Transform, &mut Projection)>,
|
||||
mouse_buttons: Res<ButtonInput<MouseButton>>,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -72,28 +72,9 @@ pub fn run() {
|
||||
}
|
||||
|
||||
fn setup_scene(mut commands: Commands) {
|
||||
// Bright ambient so surfaces facing away from every light aren't pure black.
|
||||
commands.insert_resource(AmbientLight {
|
||||
color: Color::srgb(0.9, 0.93, 1.0),
|
||||
brightness: 900.0,
|
||||
commands.spawn(DirectionalLight {
|
||||
illuminance: 10_000.0,
|
||||
shadows_enabled: true,
|
||||
..default()
|
||||
});
|
||||
// A multi-directional rig (key + fills + rim + underside) so an orbiting
|
||||
// camera always has some light on the visible side — the single front light
|
||||
// left the backside unreadable.
|
||||
let lights = [
|
||||
(Vec3::new(1.0, 2.0, 1.5), 10_000.0, true), // key: front-top-right
|
||||
(Vec3::new(-2.0, 1.0, 0.5), 4_500.0, false), // fill: left
|
||||
(Vec3::new(0.5, 0.8, -2.0), 6_000.0, false), // rim: behind
|
||||
(Vec3::new(0.0, -1.5, 0.5), 2_500.0, false), // underside fill
|
||||
];
|
||||
for (from, lux, shadows) in lights {
|
||||
commands.spawn((
|
||||
DirectionalLight {
|
||||
illuminance: lux,
|
||||
shadows_enabled: shadows,
|
||||
..default()
|
||||
},
|
||||
Transform::from_translation(from).looking_at(Vec3::ZERO, Vec3::Y),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,95 +0,0 @@
|
||||
# Handoff — movie subtitles, voice, and the movie manifest (2026-07-19)
|
||||
|
||||
Branch `feature/ipfb-idxd-parser`. This commit flushes several sessions of local
|
||||
WIP; the **new, finished** work is the movie subtitle + voice + audio pipeline
|
||||
and the movie manifest. One item is deliberately **left open** (see §4).
|
||||
|
||||
## 1. What's DONE and verified (static RE + tests)
|
||||
|
||||
### Movie subtitles (`crates/sylpheed-formats/src/movie_subtitle.rs`)
|
||||
- Full movie→track→text chain (see `docs/re/structures/movie-subtitles.md`).
|
||||
- **Multi-line caption fix**: a caption stored as several consecutive text tokens
|
||||
sharing one timing (S13A: `"Look at it father"` + `"& beautiful isn't it"` @
|
||||
`01:14.80`) — `parse_track` now joins them with `\n`. Previously all but the
|
||||
last line were dropped. Disc test asserts both lines survive.
|
||||
- **Overlap rendering**: `MovieSubtitles::active_cues(t)` returns every cue active
|
||||
at `t`; the viewer stacks them (was: only the first cue shown).
|
||||
- Umlauts / Latin-1 accents preserved (`utf16le_tokens`); Japanese label romanized
|
||||
(CJK font still a known gap — see §5).
|
||||
|
||||
### Voice decode (`crates/sylpheed-formats/src/slb.rs`)
|
||||
- `sound.pak` entries are XACT `.slb` banks wrapping **XMA1** (fmt tag `0x0165`,
|
||||
48 kHz, mono content). `to_xma_riff` rebuilds a decodable RIFF; FFmpeg `xma1`
|
||||
decodes it. Downmix mono via `-af pan=mono|c0=c0`.
|
||||
- **Multi-subwave fix**: take the FIRST sub-wave bounded by its declared `data`
|
||||
size — NOT `data..EOF` (which appended later takes = the S10–S16 garble).
|
||||
Verified: S13A→83.78s == video.
|
||||
- `list_voice_clips` enumerates the voice library from `sounds.tbl`.
|
||||
|
||||
### Movie manifest (`crates/sylpheed-formats/src/movie_manifest.rs`) — the index
|
||||
- `tables.pak` entry `ADVERTISE_MOVIE` (IDXD, hash `0x5B983A08`) is the
|
||||
authoritative **movie → subtitle → voice** map. Located by shape (`is_manifest`),
|
||||
parsed by grouping the string pool on `.wmv`.
|
||||
- **Authoritative voice binding** replaces the old `VOICE_<movie>` guess:
|
||||
101 movies, 83 with a `VOICE_` token, 18 without. The token is NOT always
|
||||
`VOICE_<movie>` — 5 `hokyu_*` movies bind to `VOICE_D_450..454` in `\etc\`,
|
||||
which a guess would miss. Token's subdir varies (Movie/etc/Voice) → resolve via
|
||||
`sounds.tbl`. Disc test: all 83 resolved entries exist in `sound.pak`.
|
||||
|
||||
### Viewer wiring (`iso_loader.rs`, `ui.rs`)
|
||||
- `resolve_movie_voice_clip` reads the manifest + `sounds.tbl` (DIRECT bindings
|
||||
only) → `handle_voice_request` (movie player 🗣 toggle) and the 🎧 solo button
|
||||
(`RequestAudio.movie`) use it. Unbound movies correctly post no audio.
|
||||
- Standalone **View → 🎙 Voice Lines** browser (filter + ▶ play any `sound.pak`
|
||||
clip) via `VoiceLibrary` + `AudioPreview`.
|
||||
|
||||
Tests: 46 formats-lib + 11 viewer-lib + disc (`movie_manifest_disc`,
|
||||
`movie_subtitle_disc`, `slb_disc`) all green. Full `cargo test --workspace` green.
|
||||
|
||||
## 2. Also bundled in this commit (prior local WIP, not this session's focus)
|
||||
- Viewer **async stage/model loading** (off-thread `prepare_xpr`, cancellable) —
|
||||
`iso_loader.rs`/`ui.rs`/`camera.rs`. See memory `reborn-viewer-async-loading`.
|
||||
- **Grouped-pool XBG7 / hero-ship** decode refinements in `mesh.rs`, `cli/main.rs`,
|
||||
`mesh_disc.rs`. See memory `reborn-ship-drawlog` / `reborn-saber-texture-investigation`.
|
||||
- `tools/analyze_drawlog_wvp.py`, `tools/extract_movie_subtitles.py`.
|
||||
|
||||
These build and test green but were not re-verified for behaviour this session.
|
||||
|
||||
## 3. USER TO VERIFY IN GUI (couldn't be tested from CLI)
|
||||
1. S13A cutscene shows BOTH lines of the "Look at it father" caption.
|
||||
2. Story-movie voice (S13A etc.) lines up with the video after the subwave fix.
|
||||
3. The 5 directly-bound `hokyu_*` movies play voice; other hokyu are silent (see §4).
|
||||
4. View → 🎙 Voice Lines browser lists and plays clips.
|
||||
|
||||
## 4. OPEN PROBLEM — unbound-hokyu resupply voice (do NOT re-guess)
|
||||
The resupply cutscenes clearly SHARE voice recordings (video-only varies per
|
||||
mission), but the correct join key for the **13 unbound `hokyu_*`** movies is
|
||||
**unknown**:
|
||||
- Manifest DIRECTLY binds only 5: `LS_s02A→450, LS_s09A→451, DS_s02A→452,
|
||||
LS_s02H→453, DS_s07H→454` (grouping verified against the raw layout).
|
||||
- Keying unbound movies by subtitle **demo id** (600→450…604→454, so
|
||||
`hokyu_DS_s13A` demo602→`VOICE_D_452`) was implemented, tested against the
|
||||
running game by the user, and is **WRONG** (wrong line). It has been **reverted**
|
||||
— unbound hokyu now stay unvoiced rather than play wrong audio.
|
||||
- Red flag: only `VOICE_D_450..454` exist; decoded durations `450=2.8s 451=1.6s
|
||||
452=2.2s` but `453=0.14s 454=0.43s` — far too short for the spoken line, so
|
||||
these `.slb` are likely **multi-subwave / not cleanly sliced** (same class as
|
||||
the deferred B/C banks below).
|
||||
|
||||
**Next-box options:** (a) get the real join key from mission-event data (mission
|
||||
scripts/IDXD tables that trigger resupply), or (b) build a proper multi-subwave
|
||||
`.slb` decoder and verify audio by ear. Needs a concrete calibration clue from the
|
||||
user (e.g. "s13A should sound like <movie X>" or the actual spoken words).
|
||||
|
||||
## 5. Other deferred items (unchanged)
|
||||
- ~49 "layout-B/C" movie/voice banks (most RT + S07B/S11A/S12B/S13B) + some
|
||||
individual clips need an XMA1 packet/seek-table reassembler.
|
||||
- CJK/Japanese text rendering in the viewer (needs a CJK TTF via egui FontDefinitions).
|
||||
- Texture colours (channel order / sRGB) still on the dynamic-RE backlog.
|
||||
|
||||
## 6. Resume checklist (next box)
|
||||
1. `git pull` on `feature/ipfb-idxd-parser`; set `SYLPHEED_DISC=<extract root>`
|
||||
(had `.../sylph_extract`).
|
||||
2. Build guardrail: `CARGO_BUILD_JOBS=4` always (15 GB box; full `-j` OOM'd before).
|
||||
3. `cargo test --workspace` (with `SYLPHEED_DISC`) should be green.
|
||||
4. Pick up §4 (unbound-hokyu voice) — the only open thread from this session.
|
||||
@@ -1,71 +0,0 @@
|
||||
# Handoff — capital-ship placement: static assembly EXACT (2026-07-26)
|
||||
|
||||
Branch `feature/ipfb-idxd-parser`, commits `c6ca5ce..ea32e77`. Canary fork
|
||||
branch `capture-ship-placement`, tip `877163792`.
|
||||
|
||||
## Outcome
|
||||
|
||||
**Capital ships assemble exactly from the ISO alone — no captures needed.**
|
||||
Runtime captures served as the oracle that cracked the static encoding and now
|
||||
remain as verification tooling only.
|
||||
|
||||
## The two format discoveries (docs/re/ship-placement-runtime-capture.md)
|
||||
|
||||
1. **Node-TRS off-by-one** (`mesh.rs::read_trs9`): an XBG7 scene-graph node's
|
||||
joint table holds NINE keyframe channels `[TX TY TZ RY RX RZ SX SY SZ]`
|
||||
behind EIGHT pointer slots shifted one track forward — channel k+1 =
|
||||
`f64@(ptr[k]+8)`, channel 0 (TX) = `f64@(ptr[0]−0x48)`. The old read never
|
||||
saw TX (why hulls stacked on the centreline) and misassigned TY/RY.
|
||||
2. **Euler order** (`mesh.rs::node_rotation`): `Ry(ch3)·Rx(ch4)·Rz(ch5)`,
|
||||
angles direct — pinned by decomposing the captured engine-nacelle rotation
|
||||
`Rx(−15°)·Rz(30°)` element-for-element.
|
||||
|
||||
## assemble_ship (ship.rs) — fully static, capture-validated
|
||||
|
||||
- Every composite-node instance (alias duplicates collapsed), including
|
||||
cross-id turret mounts (`rou_e303_wep_01_root` ×2 on e106; e108 places 7).
|
||||
- Engine cluster rig `e_rou_<id>_eng` mounts at `GN_Engine_01`
|
||||
(two mirrored nacelles + centre engine).
|
||||
- `brg`/`sld` at their exact GN frames (frames were always exact).
|
||||
- Shared-geometry ±TX twins: the instance whose offset opposes the geometry's
|
||||
dominant side draws X-reflected (viewer reverses winding on det<0).
|
||||
- `exhaust_frames()`: the `GN_Jet`/`GN_SJet` frames — the game renders its
|
||||
engine-exhaust FX there; the viewer draws marker cones at them (the engine
|
||||
GEOMETRY is recessed in the hull by design; without the FX ships read
|
||||
engine-less — that was the "engines inside the hull" report).
|
||||
|
||||
## Validation chain (all green)
|
||||
|
||||
- `ship::tests::static_assembly_matches_runtime_capture` (SYLPHEED_ISO): static
|
||||
== the baked e106 capture, all 8 parts, T<1.0 R<0.02, nacelles ×2, turrets
|
||||
×2, starboard mirror.
|
||||
- `examples/capture_verify.rs` over the user's 5 multi-angle snapshots
|
||||
(43 e106 instances): dominant clusters match static to ~1 unit on every part
|
||||
incl. both nacelles. Run:
|
||||
`cargo run --release --example capture_verify -- <Stage.xpr> e106 <logs…>`
|
||||
- Offline audit (`examples/ship_audit.rs`) across all stages: no outliers among
|
||||
composite ships; composite-less families (fighter morph sets, turret/prop
|
||||
parts) are filtered from the viewer's Ships catalog.
|
||||
- 81 formats-lib + all disc tests; viewer builds.
|
||||
|
||||
## Canary instrumentation (branch `capture-ship-placement`)
|
||||
|
||||
F10 → `xenia_ship_capture_NN.log` per press (multi-angle in one run), de-duped
|
||||
by (vertex-buffer, c0..c2 WVP hash) so every instance of every part is
|
||||
recorded. Launch:
|
||||
```
|
||||
cd xenia-canary/build/bin/Linux/Release
|
||||
./xenia_canary "<…/Project Sylpheed - Arc of Deception (USA, Europe) (En,Ja).iso>"
|
||||
```
|
||||
|
||||
## Open / next
|
||||
|
||||
- Verify remaining capital ships against the existing 5 snapshots (they contain
|
||||
every on-screen ship): e105 (its engine block assembles dorsally — the one
|
||||
placement to confirm), f105/f106/f101, e102. Same capture_verify invocation
|
||||
with the other ship id.
|
||||
- AA-gun models at `GN_AAGun*` frames need the Vessel recipe binding.
|
||||
- SJet (maneuvering-vernier) marker orientation is approximate; main aft plumes
|
||||
verified.
|
||||
- `_mov` node animation keys (hull-opening sequences) — rest pose rendered now.
|
||||
- Viewer GUI verification by the user (exhaust cones, catalog cleanup).
|
||||
@@ -20,7 +20,6 @@ Promote to a prose `structures/…md` file when a format needs behavioural notes
|
||||
| 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)) | 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,180 +0,0 @@
|
||||
# Capital-ship part placement — runtime capture (ground truth)
|
||||
|
||||
**Status:** ✅✅ **STATIC ASSEMBLY IS EXACT — no captures needed anymore
|
||||
(2026-07-26).** The capture became the oracle that cracked the static encoding:
|
||||
the node joint tables are **9 keyframe channels `[TX TY TZ RY RX RZ SX SY SZ]`
|
||||
with the 8 table pointers shifted one track forward** (channel 0 = TX sits at
|
||||
`ptr[0]−0x48`; the old 8-slot read took TY as X, never saw TX — why hulls
|
||||
stacked on the centreline). Euler order `Ry·Rx·Rz`, angles direct
|
||||
(`mesh.rs::read_trs9` / `node_rotation`). `assemble_ship` now places every
|
||||
composite-node instance (cross-id turrets ×2), mounts the `e_rou_<id>_eng`
|
||||
cluster rig at `GN_Engine_01` (two mirrored nacelles + centre engine), puts
|
||||
`brg`/`sld` at their exact GN frames, and X-reflects the shared-geometry twin
|
||||
whose lateral offset opposes the geometry's dominant side.
|
||||
`ship::tests::static_assembly_matches_runtime_capture` asserts static ==
|
||||
captured for all 8 e106 parts (T < 1.0, R < 0.02) + both nacelles + both
|
||||
turrets + the hull mirror. The viewer uses pure static assembly; the baked
|
||||
table + correlator remain as the verification oracle only.
|
||||
|
||||
## Problem
|
||||
|
||||
Capital ships ship as **split XBG7 parts** (hull bodies, bridge, engines, turrets)
|
||||
in `hidden/resource3d/Stage_SNN.xpr`. Reconstructing the whole ship needs each
|
||||
part's placement. Static reverse-engineering of the composite scene graph
|
||||
(`e_rou_<id>`, `GN_*` frames) got the **hull right but external parts only
|
||||
approximately** — a `GN_*` frame is the mount *pivot*, and the real outboard /
|
||||
rotational offset lives in a detail sub-rig or in runtime code not recoverable
|
||||
statically. See `sylpheed-formats::ship::assemble_ship` (the static best-effort).
|
||||
|
||||
## Finding
|
||||
|
||||
The **guest vertex buffer holds LOCAL coordinates** — byte-identical to the
|
||||
`.xpr` (verified: `e106_bdy_04`'s first vertex `(-20.0000,153.1539,45.9997)`
|
||||
matches the decode exactly). So parts are placed **entirely in the vertex
|
||||
shader**; the buffer carries no placement. (Contrast: static *stage* geometry is
|
||||
pre-transformed into world space and byte-matches the `.xpr` at file offsets —
|
||||
that's a different case.)
|
||||
|
||||
The per-part transform is in the **vertex-shader float constants**. For the ship
|
||||
shader (`vs=0xC7F781F4C1D58054`), constants `c0..c2` are the **WorldViewProjection**
|
||||
matrix rows:
|
||||
|
||||
- Their norms are `(sx, sy, 1)` = the projection x/y scales; `sy/sx ≈ 1.78 = 16:9`
|
||||
aspect. Dividing each row by its norm gives the rigid **WorldView** (verified:
|
||||
normalized rows orthonormal to 1e-4, `det = +1`).
|
||||
- The camera View cancels when expressing every part relative to a reference part:
|
||||
`rel_p = WV_ref⁻¹ · WV_p` = `(Rᵀ_ref·R_p , Rᵀ_ref·(T_p − T_ref))` — a pure
|
||||
ship-space rigid transform. Applying `rel_p` to part `p`'s local geometry
|
||||
assembles the ship exactly, in the reference part's frame.
|
||||
|
||||
(`c4..c14` also vary per part — likely a normal matrix / a second WVP variant /
|
||||
WorldView split; not needed, `c0..c2` suffice.)
|
||||
|
||||
## Capture instrumentation
|
||||
|
||||
Branch **`capture-ship-placement`** in the `xenia-canary-native` worktree (off the
|
||||
`instrument-current`-descended native branch, which already has GPU `log_draws`).
|
||||
|
||||
- **F10** in the emulator window → `xe::gpu::RequestShipCaptureFrame()`.
|
||||
- Dumps the next ≤8000 draws (de-duped by vertex-buffer address) to
|
||||
**`xenia_ship_capture.log`** in the binary's dir
|
||||
(`build/bin/Linux/Release/`). Per draw:
|
||||
```
|
||||
DRAW vbase=0x… stride=… vcount=… indices=… prim=… vs=0x…
|
||||
pos: (x,y,z) … up to 64 LOCAL vertex positions (== .xpr)
|
||||
vsconst base=N: c0=(x,y,z,w) c1=… … first 48 VS float4 constants
|
||||
```
|
||||
- Files: `src/xenia/gpu/command_processor.{cc,h}` (`CaptureShipDrawForRE`,
|
||||
`RequestShipCaptureFrame`), `src/xenia/app/emulator_window.cc` (F10 key).
|
||||
- Run: `run-canary-native.sh` (HW Vulkan, interactive). Play into the mission,
|
||||
frame the ship side-on, press F10.
|
||||
|
||||
## Correlator (now a library module)
|
||||
|
||||
The correlation math lives in **`sylpheed-formats::ship_capture`** (unit-tested with
|
||||
synthetic captures): `parse_capture` → `CapturedDraw`s, `correlate(id, draws,
|
||||
parts, ref_sub)` → a `ShipPlacement` (each part in the reference frame), and
|
||||
`serialize_table`/`parse_table` for the checked-in text table.
|
||||
|
||||
Two capture formats are accepted (auto-detected): the F10 ship-capture snapshot
|
||||
([`parse_capture`]) and the **draw-logger** format `mission_draws.log`/
|
||||
`xenia_re_draws.log` (`parse_drawlog` — groups the ship shader `SHIP_VS_HASH`'s
|
||||
draws by vertex-buffer `base`, `vcount = size_words/stride_words`). So a capital
|
||||
ship seen in a normal instrumented run can be baked without a dedicated F10 pass.
|
||||
|
||||
### Matching rules (learned from the real 2026-07-26 capture)
|
||||
|
||||
- **LOD-aware**: a distant ship draws its `_m`/`_l` copies — same part, same
|
||||
local frame, different vcount. Each part tries every variant vcount.
|
||||
- **Position-validated**: a vcount hit alone can be a coincidence (a foreign
|
||||
51-vert mesh nearly hijacked the bridge slot). Every candidate draw's dumped
|
||||
positions must be found in the part's decoded position set or it is rejected.
|
||||
Validation is **set-based** (buffer order ≠ decode order) against the **union**
|
||||
of the part's variants — the real capture had a draw whose `vcount` equalled
|
||||
the `_m` count while its buffer held the FULL-detail geometry.
|
||||
- **Runtime mirror**: a port/starboard pair shares one file geometry; the engine
|
||||
uploads the second instance **X-reflected**. A draw that validates only under
|
||||
X-negation is accepted as the mirror, and the placement bakes `diag(−1,1,1)`
|
||||
(the viewer reverses triangle winding for det < 0).
|
||||
- The mission ship shader can be a different hash per lighting variant
|
||||
(`0x3A0829CC71516789` in this capture) — the F10 path doesn't filter by hash,
|
||||
it validates by geometry instead.
|
||||
|
||||
`examples/correlate_capture.rs` is the CLI wrapper:
|
||||
```
|
||||
SYLPHEED_ISO=… cargo run --release --example correlate_capture -- \
|
||||
<capture.log> <Stage_SNN> <ship_id> [ref_part_substr] [--emit]
|
||||
```
|
||||
Decodes the ship's base parts (for their vertex counts = the match key), correlates,
|
||||
prints each part's ship-relative transform, and with `--emit` prints the `ship …`
|
||||
block to paste into the placement table.
|
||||
|
||||
## Baked table + viewer preference
|
||||
|
||||
`crates/sylpheed-formats/data/ship_placements.txt` is the checked-in placement
|
||||
table (embedded via `ship_capture::embedded_placement`). The viewer's
|
||||
`build_ship_model` uses a ship's captured entry when present, else falls back to
|
||||
the static `assemble_ship` (`external` toggle). **The table is currently empty** —
|
||||
a real F10 capture log is needed to bake in `e106` (and others); paste the
|
||||
`--emit` block into that file and rebuild.
|
||||
|
||||
## Validated result — `e106` ADAN Destroyer (Mission 1 / Stage_S01, side view)
|
||||
|
||||
Vertex-count → part map (all matched exactly): bdy_01/02 = 1261, bdy_03 = 815,
|
||||
bdy_04 = 1633, eng_01 = 583, eng_02 = 491, wep_02_01 = 1002, brg_01 = 202.
|
||||
|
||||
Ship-relative placement (reference = `bdy_04`, aft hull):
|
||||
|
||||
| part | T (ship-relative) | note |
|
||||
|---|---|---|
|
||||
| bdy_04 | (0, 0, 0) | reference, aft hull |
|
||||
| eng_01 | (131, −133, −132) | **aft** (−Z), starboard |
|
||||
| eng_02 | (0, −49, −140) | aft, centre |
|
||||
| bdy_01 | (**−264**, −150, 1165) | **port** hull, forward |
|
||||
| bdy_02 | (**+264**, −150, 1165) | **starboard** hull, forward |
|
||||
| bdy_03 | (0, −35, 1076) | forward keel/spine |
|
||||
| wep_02_01 | (0, 49, 1009) | forward weapon |
|
||||
|
||||
Assembled extent **872 × 670 × 2181** (a coherent ~2181-long destroyer).
|
||||
|
||||
**Key wins vs static:** `bdy_01`/`bdy_02` are a **port/starboard pair** (X = ∓264),
|
||||
which static had overlapping at one point; engines land correctly aft; the ship is
|
||||
not the 1894-tall tower the static Y put out.
|
||||
|
||||
**Missing:** `brg_01` (bridge, vcount 202) was **culled/occluded** at that camera
|
||||
angle (0 draws) — needs a second capture framing the superstructure.
|
||||
|
||||
## What the static assembler gets wrong (measured, `e106` in Stage_S01)
|
||||
|
||||
Decoding the real container (`examples/ship_dump.rs`) shows the static
|
||||
`assemble_ship` is **incomplete** — the capture is required to fix all of:
|
||||
|
||||
- **`bdy_01` / `bdy_02` overlap**: both get the *same* composite transform
|
||||
(T = (−116, 0, 857)); the real ship is a **port/starboard pair** at X = ∓264
|
||||
(the mirror is applied at runtime, like the DeltaSaber fins in `saber_measured`).
|
||||
- **`eng_02` and `wep_02_01` are never placed**: they aren't `rou_` hull nodes and
|
||||
aren't in the external category list, so they drop out entirely.
|
||||
- Only `brg_01` + `eng_01` get the approximate `GN_*`-frame treatment.
|
||||
|
||||
So even the *hull* tier is not fully correct, and no static signal supplies the
|
||||
missing offsets (verified: the part vertex buffers are pure local coords). The
|
||||
capture-driven table is the only path to correctness — there is nothing more to
|
||||
squeeze statically.
|
||||
|
||||
> Offline status: the draw logs on this box are the **player fighter**, not a
|
||||
> capital ship, so no capital-ship table can be baked here yet. Capture `e106`
|
||||
> (Stage_S01, side-on) on the emulator box — F10 **or** just save
|
||||
> `mission_draws.log` with the ship on screen — then `correlate_capture … --emit`.
|
||||
|
||||
## Next steps
|
||||
|
||||
1. ~~**Bake:** promote the correlator to a module + checked-in table + viewer
|
||||
preference.~~ **DONE** (`ship_capture` module, `data/ship_placements.txt`,
|
||||
`build_ship_model` prefers it). Remaining: run the captures below and paste the
|
||||
`--emit` blocks in — needs the emulator (F10), can't be done offline.
|
||||
2. **e106 + bridge:** re-capture `e106` (Stage_S01) framing the superstructure so
|
||||
`brg_01` (culled last time) is included, then `--emit` → bake.
|
||||
3. **Other ships:** one side-on F10 capture each for the cruiser (`e105`,
|
||||
Stage_S02), ACROPOLIS (`f101`), TCAF cruiser/destroyer (`f105`/`f106`).
|
||||
4. **Turrets:** the shared `e3NN`/`e4NN` gun models appear as their own draws in the
|
||||
capture too — correlate them to place turrets (static never resolved these).
|
||||
@@ -1,174 +0,0 @@
|
||||
# Movie subtitles & the movie ↔ mission ↔ text chain
|
||||
|
||||
Reverse-engineered 2026-07-19 (static, from the extracted disc). The full chain
|
||||
that links a cutscene movie to its on-screen subtitle text is now closed.
|
||||
|
||||
## Files involved
|
||||
|
||||
- `dat/movie/*.wmv` — the cutscene videos. **Named by mission** (see below).
|
||||
- `dat/movie/<lang>.pak` + `<lang>.p00` — per-language **subtitle timing tracks**
|
||||
(`eng`, `jpn`, `deu`, `fra`, `esp`, `ita`) plus the caption font.
|
||||
- `dat/GP_MAIN_GAME_<L>.pak` + `.p00` — per-language **caption TEXT**
|
||||
(`E`=Eng, `J`=Jpn, `D`=Deu, `F`=Fra, `I`=Ita, `S`=Esp).
|
||||
- `dat/tables.pak` entry `ADVERTISE_MOVIE` (hash `0x5B983A08`) — the master
|
||||
**movie manifest**: all 101 `.wmv` names in mission-progression order, each
|
||||
bound to its subtitle track and (optionally) its **voice bank** (see below).
|
||||
|
||||
## Movie filename → mission
|
||||
|
||||
Purely from the filename:
|
||||
|
||||
| Pattern | Meaning |
|
||||
|---------|---------|
|
||||
| `S<NN><P>.wmv` | Stage `NN` **story** cutscene, part `P` (A/B/C…) — e.g. `S02C` = stage 2, 3rd story scene |
|
||||
| `RT<NN><P>.wmv` | Stage `NN` **radio / briefing** transmission, part `P` (`_1`/`_2` = split clips) |
|
||||
| `hokyu_<LS\|DS>_s<NN><P>.wmv` | Stage `NN` **resupply** scene (`hokyu` = 補給). `LS`/`DS` = the two resupply-ship variants |
|
||||
| `ADV.wmv` | Intro / title movie |
|
||||
|
||||
97 movies total: 27 story, 50 radio, 19 resupply, 1 intro. (Some referenced
|
||||
stages — s24, s27, RT16 — exist as keys but the .wmv isn't in this extract.)
|
||||
|
||||
## Subtitle timing track — `<lang>.pak`
|
||||
|
||||
IPFB archive (`IPFB`, BE-u32 count, 16-byte header; TOC of
|
||||
`[name_hash u32][offset u32][size u32]` triples, sorted by hash, into `.p00`).
|
||||
|
||||
- **Track key = `name_hash("subtitle_<movie_basename>.tbl")`** (the hash
|
||||
lowercases internally, so basename case is irrelevant). This is the movie→track
|
||||
link. Verified: `subtitle_S00A.tbl` → `0x6F2D9663`, `subtitle_hokyu_DS_s02A.tbl`
|
||||
→ `0x3662B1F8`, `subtitle_RT01C_1.tbl` → `0x756F69FB`.
|
||||
- The archive also holds **RATC** pre-rendered title-card / number textures
|
||||
(`pwterop_s01a1.t32`, `pwrt_rt01_str.t32`, `pwnum0-9.t32`) + one TrueType font.
|
||||
- **Each track data block is `Z1`+zlib**: bytes `5A 31` ("Z1"), a small header,
|
||||
then a raw zlib stream (`78 DA`/`78 9C`). `zlib.decompress(blob[blob.find(b"\x78\xda"):])`.
|
||||
- Decompressed = an **IXUD** container. Payload (UTF-16LE) is the timing sheet:
|
||||
`SUBTITLE MSG_DEMO_<demo> <mm:ss.cc> MSG_DEMO_<demo> <mm:ss.cc> …`.
|
||||
So the track says *which* demo-message shows *when*, not the text itself.
|
||||
|
||||
## Caption text — `GP_MAIN_GAME_<L>.pak`
|
||||
|
||||
Same IPFB+`.p00`. Among its ~1119 entries, **32 blocks are `Z1`+zlib → IXUD**
|
||||
string containers holding the movie caption text. Layout: `IXUD`, u32 version,
|
||||
hash@0x08, count@0x14, then `(recordhash,offset,len)` triples, then a UTF-16LE
|
||||
string region where **each line is stored as `text` immediately followed by its
|
||||
key** `MSG_DEMO_<demo>_<page>_<line>` (captions wrap across `_00`,`_01`, …).
|
||||
537 English lines recovered. Entries 1 & 19 are the IDXD *schema* records
|
||||
(`ID`, `PageCount`, `Character`=speaker e.g. `TCAFSUPPLY`, `Face`, line refs) —
|
||||
no text, just structure.
|
||||
|
||||
## Movie → voice track: the manifest binding (`ADVERTISE_MOVIE`)
|
||||
|
||||
The `ADVERTISE_MOVIE` manifest is **also the authoritative movie→voice index**.
|
||||
Its string pool emits, per movie, a run led by `<movie>.wmv` optionally followed
|
||||
by `<pak>+….prt` (overlay art), `<pak>+SUBTITLE_<movie>.tbl`, and a bare
|
||||
`VOICE_<token>`. Grouping the pool on `.wmv` (records are emitted in order)
|
||||
recovers `movie → Option<voice_token>` without decoding the IDXD record binary
|
||||
(`crate::movie_manifest`).
|
||||
|
||||
The voice token is **not** always `VOICE_<movie>`, so the manifest is required —
|
||||
guessing both misses real bindings and invents tracks for silent movies:
|
||||
|
||||
- **83 / 101 movies have a voice token.** Story/radio movies use `VOICE_<movie>`
|
||||
in `<lang>\Movie\`.
|
||||
- **5 `hokyu_*` resupply movies bind to in-mission radio clips** — e.g.
|
||||
`hokyu_LS_s02A → VOICE_D_450`, which lives in `<lang>\etc\`, *not* `Movie`.
|
||||
A `VOICE_<movie>` guess would never find these.
|
||||
- **18 movies have no direct voice token** = 4 boot logos + 1 HD test pattern +
|
||||
**13 `hokyu_*` movies** (incl. `hokyu_DS_s13A`). Only the manifest's **direct**
|
||||
bindings are trusted for playback.
|
||||
|
||||
### Shared resupply voice — UNRESOLVED for unbound movies
|
||||
|
||||
The manifest directly binds only **5** resupply movies, each to a shared
|
||||
`VOICE_D_45x` clip in `<lang>\etc\`:
|
||||
|
||||
| bound movie | subtitle demo | clip |
|
||||
|-------------|---------------|------|
|
||||
| `hokyu_LS_s02A` | 600 | `VOICE_D_450` |
|
||||
| `hokyu_LS_s09A` | 601 | `VOICE_D_451` |
|
||||
| `hokyu_DS_s02A` | 602 | `VOICE_D_452` |
|
||||
| `hokyu_LS_s02H` | 603 | `VOICE_D_453` |
|
||||
| `hokyu_DS_s07H` | 604 | `VOICE_D_454` |
|
||||
|
||||
The resupply cutscenes clearly **share** voice recordings (only the video varies
|
||||
per mission), so the 13 unbound `hokyu_*` movies must reuse one of these — but
|
||||
the **correct join key is not yet known**:
|
||||
|
||||
- Keying by subtitle **demo id** (so `hokyu_DS_s13A`, demo 602 → `VOICE_D_452`)
|
||||
was tried and is **WRONG** — it plays the wrong recording in-game. Do not use.
|
||||
- Only `VOICE_D_450..454` exist (no 44x/45x neighbours). Decoded durations are
|
||||
suspicious — `450`=2.8s, `451`=1.6s, `452`=2.2s, but `453`=**0.14s**,
|
||||
`454`=**0.43s** — far too short for the spoken line, so these `.slb` banks are
|
||||
likely **multi-subwave / not cleanly sliced** by the current extractor (same
|
||||
class as the deferred B/C banks).
|
||||
|
||||
⇒ The unbound-hokyu voice mapping is **open** (needs either the real join key
|
||||
from mission data, or a proper multi-subwave `.slb` decode + audio verification).
|
||||
`hokyu_LS_s24A`/`s27A` have no subtitle track at all (stages absent from this
|
||||
extract).
|
||||
|
||||
The token's `sound.pak` **subdirectory is not fixed** (`Movie` / `etc` / `Voice`),
|
||||
so resolve it via `sounds.tbl` (which lists the full `<lang>\…\<token>.slb` path)
|
||||
rather than assuming a directory. `movie_manifest::resolve_voice_entry` does the
|
||||
full chain. Verified: all 83 resolved entries exist in `sound.pak`.
|
||||
|
||||
## Caption packing quirks (parser must handle)
|
||||
|
||||
- **Multi-line captions are split into consecutive text tokens** that share one
|
||||
trailing timing, e.g. S13A stores `"Look at it father"` + `"& beautiful isn't
|
||||
it"` before `01:14.80-01:17.60`. Accumulate every text token since the last
|
||||
timing and join with `\n`; pairing strictly 1:1 silently drops all but the last
|
||||
line.
|
||||
- **Overlapping spans**: some tracks show two captions at once (an open-ended
|
||||
radio line still up when the next range line starts). The viewer stacks every
|
||||
cue active at `t` (`MovieSubtitles::active_cues`) instead of showing only the
|
||||
first.
|
||||
|
||||
## The full join
|
||||
|
||||
```
|
||||
tables.pak / ADVERTISE_MOVIE → list of movies (mission order)
|
||||
<movie> ─ nh("subtitle_<movie>.tbl") ─→ <lang>.pak track
|
||||
track (IXUD) → [ (MSG_DEMO_<d>, timecode), … ]
|
||||
MSG_DEMO_<d> → GP_MAIN_GAME_<L> → "the localized caption line(s)"
|
||||
```
|
||||
|
||||
## Coverage
|
||||
|
||||
- 92 / 97 movies have a subtitle track.
|
||||
- **66 movies carry timed `MSG_DEMO` captions** — the **radio (`RT*`)** and
|
||||
**resupply (`hokyu_*`)** movies. These fully decode to timed text.
|
||||
- The **27 story (`S*`) movies have a track but 0 timed captions** — their text
|
||||
is delivered as the **pre-rendered title-card textures** (`pwterop_*`, burned
|
||||
styling), not MSG_DEMO lines.
|
||||
|
||||
## Worked examples (English)
|
||||
|
||||
```
|
||||
RT01C_1.wmv (Stage 1 radio, part C):
|
||||
00:00.50 [14] We did it! Okay, all pilots follow my lead!
|
||||
00:06.80 [15] Rhino Leader to ACROPOLIS. We made it through and we're coming
|
||||
home. Roger. It's good to see you're all safe.
|
||||
00:19.30 [17] Yeah, but Brandon ... Damn. There's only seven of us. …
|
||||
|
||||
hokyu_DS_s02A.wmv (Stage 2 resupply):
|
||||
00:00.00 [602] Resupply complete. You are cleared for take-off!
|
||||
```
|
||||
|
||||
## Reusable extractor
|
||||
|
||||
`tools/extract_movie_subtitles.py` — parses `<lang>.pak`, resolves each movie's
|
||||
track, cross-references `GP_MAIN_GAME_<L>` text, and prints per-movie timed
|
||||
transcripts + the movie→mission table.
|
||||
|
||||
## In-mission dialogue (future work)
|
||||
|
||||
`GP_MAIN_GAME_<L>.pak` is the **global** message store, not just movie captions:
|
||||
its `MSG_DEMO_*` table also holds the in-mission radio/dialogue lines (same demo
|
||||
id space). So the *text* of gameplay dialogue is already decodable with
|
||||
[`crate::movie_subtitle::build_demo_text`]. What's missing is the **trigger** —
|
||||
which demo id fires at which mission event — and that lives in the **mission
|
||||
data** (mission scripts / `GP_MAIN_GAME` IDXD tables), not in the text pack. When
|
||||
reversing mission data, look for demo-id references there to bind dialogue to
|
||||
events; the IDXD "Message" schema records also carry `Character` (speaker) and
|
||||
`Face` (portrait) per line.
|
||||
@@ -1,62 +0,0 @@
|
||||
# Sound bank audio — `sound.pak` / `.slb` / XMA1
|
||||
|
||||
Reverse-engineered 2026-07-19 (static). `dat/sound.pak` (+ `sound.p00..p04`,
|
||||
~1.08 GB) is the game's entire audio bank: **9519** IPFB entries, each an XACT
|
||||
`.slb` sound bank wrapping **XMA1** audio.
|
||||
|
||||
## Names
|
||||
|
||||
Entry keys are `name_hash(<string>)` of filenames stored verbatim in the IDXD
|
||||
string pools of `tables.pak` → `eng\sounds.tbl` (entry 39) and `jpn\sounds.tbl`
|
||||
(entry 45). All 9519 recovered. Families:
|
||||
|
||||
- `<lang>\Voice\VOICE_<SPK>_<NNN>.slb` — per-line character voice (SPK = ADAN,
|
||||
TCAF, RHIN, ADPL, BIRD, ACRO, ZZZZ…). Only `eng`/`jpn` voice exists.
|
||||
- `<lang>\etc\VOICE_{A,B,C,D}_<NNN>.slb`, `<lang>\Briefing\BR<n>_<m>.slb`.
|
||||
- **`<lang>\Movie\VOICE_<movie>.slb`** — the continuous voice track for cutscene
|
||||
`<movie>.wmv` (e.g. `eng\Movie\VOICE_RT07A.slb`). Played from the video start.
|
||||
- `BGM_###.slb` (32) — music. `Static.slb`, `JNGL_###` — SFX/ambience.
|
||||
|
||||
Only English and Japanese have voice; subtitles cover more languages, voice does
|
||||
not. See [`crate::slb::movie_voice_name`].
|
||||
|
||||
## Codec
|
||||
|
||||
XMA1: RIFF `fmt ` tag **0x0165**, a 32-byte `XMAWAVEFORMAT`, **48000 Hz**. The
|
||||
content is **mono** — some clips carry it in the **left channel only** (right is
|
||||
silence), others are **dual-mono** (L = R). Downmix to mono by taking the left
|
||||
channel (it always holds the full signal).
|
||||
|
||||
`XMAWAVEFORMAT` (one stream, 32-byte `fmt `): SampleRate @ fmt+16 (u32 LE),
|
||||
Channels @ fmt+29 (u8), ChannelMask @ fmt+30 (u16). Movie voices report 2
|
||||
channels / mask 0x2 despite the mono content.
|
||||
|
||||
## `.slb` layouts → decodable RIFF
|
||||
|
||||
Two on-disc layouts (`sound.pak` movie voices split ≈ 63 RIFF / 15 headerless):
|
||||
|
||||
- **RIFF present** — a `RIFF/WAVE` sits inside the bank; its 32-byte `fmt ` is
|
||||
the real header. The XMA packets are **everything after that RIFF's `data`
|
||||
chunk header** (`slb[data_pos+8..]`); the declared `data` size is unreliable
|
||||
(sometimes half the real length), so take to end and clamp to the media length
|
||||
downstream. Some banks have trailing bank data past the real audio — always
|
||||
beyond the video length, so clamping to the video duration drops it.
|
||||
- **Headerless** — no `RIFF` anywhere; a fixed **1392-byte** header precedes raw
|
||||
XMA1 packets (48 kHz, 2 channels). Data = `slb[1392..]`.
|
||||
|
||||
[`crate::slb::to_xma_riff`] rebuilds a standalone XMA1 `RIFF/WAVE` for either
|
||||
layout, ready for FFmpeg's `xma1` decoder.
|
||||
|
||||
## Decode (FFmpeg)
|
||||
|
||||
`ffmpeg -i rebuilt.riff -af "pan=mono|c0=c0" -t <media_len> out.wav` — the RIFF
|
||||
is fed to the `xma1` decoder, downmixed to the left channel, clamped to length.
|
||||
Verified: `VOICE_S00A` → 93.9 s == `S00A.wmv` 93.87 s; `VOICE_ADV` → 137.3 s ==
|
||||
137.7 s; `VOICE_RT07A` → 49 s ≈ 50 s.
|
||||
|
||||
## Reading one entry cheaply
|
||||
|
||||
`sound.pak` is ~1 GB. Use [`crate::PakArchive::parse_toc`] on the small `.pak`
|
||||
index, binary-search the name-hash, then read just `[offset, offset+size)` from
|
||||
the `.pNN` segments (the viewer's `read_segment_range` seeks into the right
|
||||
segment) instead of loading the whole archive.
|
||||
@@ -178,77 +178,6 @@ mission* (where `DeltaSaber` renders) would hand over its exact declaration dire
|
||||
resource by strict index+triangle validation. **5662 sub-models decode across 22 stages** (S07
|
||||
366/378), incl. the previously-declined main bodies `e005` (2566 v) and weapons — ≤2 s on 70 MB.
|
||||
Parser `Xbg7Model::stage_models`, tests `stage_models_{decode,sweep,quality_audit}`.
|
||||
- 2026-07-17 — **triangle-LIST re-confirmed; a strip interlude refuted; winding-consistency gate
|
||||
added.** A 2026-07 change had briefly re-read the index buffers as triangle *strips* (to "fill
|
||||
holes"). Refuted objectively with a new `XVERIFY` diagnostic that compares both readings by
|
||||
**stored-normal agreement** (each triangle's cross-product face normal vs the sum of its vertices'
|
||||
stored normals): the LIST reading gives agreement **1.000** on every clean weapon (`wep_00/03/04/19`
|
||||
= only possible with correct topology + winding), the STRIP reading **~0.49** (random). The strip
|
||||
reading also over-generated ~2.5× the triangles (wep_00: 938 vs 364) — a hole-filling garbage soup.
|
||||
Reverted to LIST in both paths (`from_xpr2`, `read_pool_mesh`), matching the `prim=4` GPU capture.
|
||||
Added an objective **winding-consistency gate** `max(na, 1-na)`: a correct carve is internally
|
||||
consistent (agreement ≈1.0, or ≈0.0 for inverted-but-consistent winding — a real single-sided
|
||||
mesh), a mis-carve scatters to the ≈0.5 middle. `from_xpr2` declines sub-meshes below 0.90 (e.g.
|
||||
`wep_23` na=0.398 → declined instead of a spike-mess); the single-model **content-anchor fallback**
|
||||
gates at 0.85; the large multi-resource **stage** path stays ungated (its enemy meshes span a
|
||||
continuous 0.5–1.0 consistency range — a hard gate there dropped ~48/314 legit S07 blocks).
|
||||
**Routing fixed:** `decode_models` (CLI) and the viewer now route by `count_xbg7` (1 → validated
|
||||
records-based list decode, fallback to strict-gated anchor; >1 → stage anchor) instead of the old
|
||||
"whichever decoder yields more verts" rule — that rule let stage content-anchoring win on
|
||||
single-model weapon files and fabricate **phantom** blocks (a `wep_00` clone appearing inside
|
||||
`wep_19`), duplicates, and spike-mess anchors. Weapons now: 33 clean-decode / 26 declined (declined
|
||||
= genuinely multi-stream or un-carvable, shown as nothing rather than garbage); stage coverage
|
||||
unchanged (S07 314). `expand_triangle_strip` retained as an `XVERIFY`-only diagnostic.
|
||||
- 2026-07-12 — `DeltaSaber_A.xpr` body: data does **not** begin with indices; plain-`f32×3` runs
|
||||
with ship-scale extent (span ≈27–34, matching bbox 30.0) found only at high offsets
|
||||
(`data+0x28634C`, …) → multi-stream, **undecoded**.
|
||||
- 2026-07-18 — **GROUPED-POOL layout cracked → the hero ship (Delta Saber) fully decodes.** The
|
||||
detailed models (`DeltaSaber_*.xpr` + ~100 others) were declined for **location**, not format —
|
||||
their vertex format is the standard stride-24 triangle list. A resource's *several* sub-meshes
|
||||
don't interleave `[idx][vtx]` per block; they share **two grouped pools**: an **index pool**
|
||||
(buffers concatenated in descriptor-marker order, each **4-byte aligned**) followed by a **vertex
|
||||
pool** (each sub-pool `vtx_count × stride`, same order), with the index pool ending **exactly**
|
||||
where the vertex pool begins. So the whole resource pivots on one unknown, the first vertex-pool
|
||||
start `vb0` (= index-pool end, found by the unit-normal vertex-run scan); everything else is
|
||||
derived: `ib0 = vb0 − span`, `ib[i] = align4(ib[i-1] + idx_count[i-1]·2)`,
|
||||
`vb[i] = vb[i-1] + vtx_count[i-1]·stride`. Reversed statically from `DeltaSaber_T.xpr` and
|
||||
**cross-checked against a Canary GPU draw-log capture** (mission ship = `DeltaSaber_T.xpr`, found
|
||||
via the `--log_file_io` kernel hook): `f001` = body (idx@`data+0xC` = 0x5500C, vtx@0x61ACC, 10891 v
|
||||
/ 8187 t) + **7 detail parts** (fins/cockpit/wingtips, markers at descriptor 0x3BEC…0x58FC) =
|
||||
**8650 tris**, and **every sub-mesh decodes at 0 degenerate / full coverage / winding-agreement
|
||||
1.000**. This is the layout the per-block adjacency anchor (`ib = vb − idx_bytes`) rendered as a
|
||||
**spiky phantom** (it read 24561 indices starting 2782 B too late, agree 0.64, 1277 degenerate).
|
||||
Insight: a single index marker reduces the grouped model to `index_end = vb0`, i.e. the existing
|
||||
adjacency `ib = vb − idx_bytes` — so grouped **generalises** the single-block anchor (n=1 is
|
||||
identical). Implemented as `anchor_grouped_meshes` (mesh.rs): `anchor_models` routes resources with
|
||||
>1 index marker to it (validated per sub-mesh; on failure falls back to the old first-marker
|
||||
adjacency anchor so stage coverage never regresses); single-marker stages/props keep the exact
|
||||
prior path. The shared acceptance test is factored into `validate_block` (the connectivity
|
||||
heuristic is relaxed for *derived* grouped parts, which are pinned by in-range + consistency, so
|
||||
small flat fins aren't mis-rejected). Render self-check: `sylpheed-cli mesh render DeltaSaber_T.xpr
|
||||
--only f001` (exact-name match excludes the `_rou_f001_mnv*` animation poses) → clean complete
|
||||
fighter. Test `hero_ship_grouped_pool_decodes`. Colours/UVs still pending the running-game oracle.
|
||||
- 2026-07-18 (refinement) — **4-byte vertex-pool alignment + weapon recovery.** The grouped-pool
|
||||
rule "index pool ends exactly where the vertex pool begins" is really "the vertex pool is **4-byte
|
||||
aligned** after the index pool": `vb0 = align4(ib0 + span)`, so 0..=3 bytes of padding can sit
|
||||
between them. DeltaSaber's index pool ended already-aligned (pad 0), which hid this; **19
|
||||
weapon/`*_hangar` models** (single- and multi-marker: `wep_08/11/34/58/62/69/81/83…`) have pad 2
|
||||
and so decoded to *nothing* — the viewer then showed them as a flat 2D texture instead of a model.
|
||||
Fix: both anchors try `pad ∈ 0..=3` (`ib = vb − idx_bytes − pad` for the single-block adjacency
|
||||
anchor; `ib0 = vb0 − span − pad` for the grouped pivot), validated — a wrong pad reads shifted
|
||||
indices → agreement collapses < 0.85, so only the true pad passes. pad>0 in the ungated stage path
|
||||
is gated at a strict 0.85 to avoid a false anchor; pad 0 keeps its exact prior behaviour (stages
|
||||
unchanged). Result: all 19 now decode as clean models (e.g. `wep_34` 1243 v / 1233 t, a
|
||||
long-barrelled gun-pod; `wep_08` 3 sub-meshes / 478 t). Viewer routing already falls through
|
||||
`from_xpr2` → `anchor_models(0.85)` for single-XBG7 files, so the recovered grouped/padded weapons
|
||||
now preview as meshes.
|
||||
- 2026-07-18 (refinement 2) — **pivot on the largest sub-mesh; all 19 recovered.** Three weapons
|
||||
(`wep_81`, `wep_81_hangar`, `wep_30_hangar`) still declined because the grouped pivot validated
|
||||
`markers[0]`, which for these is a tiny *elongated* lead bracket that fails the connectivity gate
|
||||
even when perfectly placed. Fixed by pivoting the alignment check on the **largest** marker (max
|
||||
index count) — the sub-mesh whose triangle-quality/connectivity signature most reliably confirms
|
||||
`(ib0, vb0)`. Once the pivot validates, markers up to it are read unconditionally (a legitimately
|
||||
tiny/flat lead part may fail the quality gates yet still be real), and markers after it stay
|
||||
validated so a stray trailing marker ends the chain. Result: **all 19 previously-declined weapons
|
||||
decode** (`wep_81` 460 t missile w/ tail fins; `wep_30_hangar` 334 t). DeltaSaber unchanged (its
|
||||
body IS the largest marker → same pivot). 7/7 disc tests green, stage quality audit unchanged.
|
||||
|
||||
@@ -1,126 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Recover each ship part's runtime WORLD transform from a Canary draw log.
|
||||
|
||||
The draw logger (branch capture-drawlog) now dumps, per distinct draw:
|
||||
- the first ~8 object-space vertex positions (pre-transform), and
|
||||
- the vertex-shader float constants c0..c31 (which hold the transform matrices).
|
||||
|
||||
The game bakes each part's WORLD matrix into the constants, so the shader's
|
||||
World*View*Proj (WVP) for a part is VP * part_World. The body (bdy_01) is drawn
|
||||
with an identity world, so body_WVP = VP. Hence for any part drawn in the SAME
|
||||
frame (the ship's parts always are):
|
||||
|
||||
part_World = inv(body_WVP) * part_WVP (View/Proj cancel)
|
||||
|
||||
We don't know a-priori which 4 consecutive constants form the WVP, so we try every
|
||||
block c[i..i+3] and keep the one for which inv(body_WVP)*part_WVP is a RIGID
|
||||
transform (orthonormal 3x3 + translation) for the parts — that uniquely identifies
|
||||
the matrix block. The translation column of each part's world matrix is the
|
||||
placement we want (esp. the ±X nacelle offset the static XBG7 graph lacks).
|
||||
|
||||
Usage: analyze_drawlog_wvp.py xenia_re_draws.log
|
||||
Identify the body draw via --body-indices (the draw with the most indices) or by
|
||||
matching object-space positions to our decoded sub-meshes.
|
||||
"""
|
||||
import sys, re
|
||||
import numpy as np
|
||||
|
||||
def parse(path):
|
||||
draws = []
|
||||
cur = None
|
||||
consts = {}
|
||||
mode = None
|
||||
for line in open(path):
|
||||
if line.startswith("DRAW "):
|
||||
if cur is not None:
|
||||
cur["consts"] = consts
|
||||
draws.append(cur)
|
||||
cur = {"header": line.strip(), "positions": [], "textures": [],
|
||||
"size_words": 0}
|
||||
consts = {}
|
||||
mode = None
|
||||
m = re.search(r"index\[base=0x([0-9A-Fa-f]+) count=(\d+)", line)
|
||||
cur["idx_base"] = int(m.group(1), 16) if m else None
|
||||
cur["idx_count"] = int(m.group(2)) if m else None
|
||||
m = re.search(r"indices=(\d+)", line)
|
||||
cur["indices"] = int(m.group(1)) if m else None
|
||||
elif cur is not None and line.strip().startswith("stream "):
|
||||
# Largest vertex buffer (size_words) = the hull (body, identity world).
|
||||
m = re.search(r"size_words=(\d+)", line)
|
||||
if m:
|
||||
cur["size_words"] = max(cur["size_words"], int(m.group(1)))
|
||||
elif cur is None:
|
||||
continue
|
||||
elif line.strip().startswith("positions:"):
|
||||
cur["positions"] = [tuple(map(float, t.split(",")))
|
||||
for t in re.findall(r"\(([^)]+)\)", line)]
|
||||
elif line.strip().startswith("textures:"):
|
||||
cur["textures"] = re.findall(r"base=0x([0-9A-Fa-f]+)", line)
|
||||
elif line.strip().startswith("vsconst"):
|
||||
mode = "vsconst"
|
||||
elif mode == "vsconst":
|
||||
m = re.match(r"\s*c(\d+)\s+(-?[\d.]+)\s+(-?[\d.]+)\s+(-?[\d.]+)\s+(-?[\d.]+)", line)
|
||||
if m:
|
||||
consts[int(m.group(1))] = np.array([float(m.group(i)) for i in range(2, 6)])
|
||||
else:
|
||||
mode = None
|
||||
if cur is not None:
|
||||
cur["consts"] = consts
|
||||
draws.append(cur)
|
||||
return draws
|
||||
|
||||
def wvp_from(consts, i):
|
||||
"""4x4 from constants c[i..i+3] as rows."""
|
||||
if not all(k in consts for k in (i, i+1, i+2, i+3)):
|
||||
return None
|
||||
return np.array([consts[i], consts[i+1], consts[i+2], consts[i+3]])
|
||||
|
||||
def is_rigid(M):
|
||||
"""3x3 upper-left orthonormal (rotation/reflection), within tolerance."""
|
||||
R = M[:3, :3]
|
||||
if not np.all(np.isfinite(R)):
|
||||
return False
|
||||
G = R @ R.T
|
||||
return np.allclose(G, np.eye(3), atol=1e-2) or np.allclose(G / (np.trace(G)/3), np.eye(3), atol=1e-2)
|
||||
|
||||
def main():
|
||||
if len(sys.argv) < 2:
|
||||
print(__doc__); return
|
||||
draws = parse(sys.argv[1])
|
||||
print(f"parsed {len(draws)} draws")
|
||||
# Body = the draw with the largest vertex buffer (the ~10891-vert hull, drawn
|
||||
# with an identity world). idx_count is unreliable (the hull's 9 material
|
||||
# groups dedup to the first group's partial count).
|
||||
body = max(draws, key=lambda d: d.get("size_words") or 0)
|
||||
print(f"body draw: {body['header'][:90]} size_words={body['size_words']}")
|
||||
# Try every constant block; report the one giving rigid part transforms.
|
||||
for i in range(0, 29):
|
||||
bwvp = wvp_from(body["consts"], i)
|
||||
if bwvp is None:
|
||||
continue
|
||||
try:
|
||||
binv = np.linalg.inv(bwvp)
|
||||
except np.linalg.LinAlgError:
|
||||
continue
|
||||
worlds = []
|
||||
rigid = 0
|
||||
for d in draws:
|
||||
pw = wvp_from(d["consts"], i)
|
||||
if pw is None:
|
||||
continue
|
||||
W = binv @ pw # column-vector convention; may need transpose
|
||||
worlds.append((d, W))
|
||||
if is_rigid(W) or is_rigid(W.T):
|
||||
rigid += 1
|
||||
if rigid >= max(2, len(worlds)//2):
|
||||
print(f"\n=== WVP block c{i}..c{i+3}: {rigid}/{len(worlds)} rigid ===")
|
||||
for d, W in worlds:
|
||||
# translation is the last column (or last row, convention-dependent)
|
||||
tcol = W[:3, 3]
|
||||
trow = W[3, :3]
|
||||
print(f" idx={d['idx_count']:>6} base={d['idx_base'] and hex(d['idx_base'])}"
|
||||
f" t_col=({tcol[0]:+.2f},{tcol[1]:+.2f},{tcol[2]:+.2f})"
|
||||
f" t_row=({trow[0]:+.2f},{trow[1]:+.2f},{trow[2]:+.2f})")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,88 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
import struct, zlib, re, os
|
||||
MOD=0x00FFF9D7; RECIP=0x80031493
|
||||
def rol(v,n,b=32):
|
||||
v&=(1<<b)-1; return ((v<<n)|(v>>(b-n)))&((1<<b)-1)
|
||||
def nh(name):
|
||||
bs=bytearray(name.encode('latin-1'))
|
||||
for i,b in enumerate(bs):
|
||||
if 0x41<=b<=0x5A: bs[i]=b+0x20
|
||||
a=0;bb=0
|
||||
for byte in bs:
|
||||
c=(byte if byte<0x80 else byte-0x100)&0xFFFFFFFF
|
||||
a=((rol(a,8)&0xFFFFFF00)+c)&0xFFFFFFFF
|
||||
bb=(bb+c)&0xFFFFFFFF
|
||||
hi=((a*RECIP)>>32)&0xFFFFFFFF; q=rol(hi,9)&0x1FF
|
||||
a=(a-(q*MOD))&0xFFFFFFFF
|
||||
return (((bb<<24)&0xFF000000)|(a&0xFFFFFF))&0xFFFFFFFF
|
||||
|
||||
EX="/home/fabi/RE Project Sylpheed/sylph_extract"
|
||||
def load_pak(base):
|
||||
"""base like dat/movie/eng ; returns list of (hash,off,size), data bytes"""
|
||||
pak=open(f"{EX}/{base}.pak","rb").read()
|
||||
n=struct.unpack(">I",pak[4:8])[0]
|
||||
es=[struct.unpack(">III",pak[16+12*i:28+12*i]) for i in range(n)]
|
||||
p00=f"{EX}/{base}.p00"
|
||||
data=open(p00,"rb").read() if os.path.exists(p00) else pak
|
||||
return es, data
|
||||
def unz(blob):
|
||||
if blob[:2]==b'Z1':
|
||||
zi=blob.find(b'\x78\xda');
|
||||
if zi<0: zi=blob.find(b'\x78\x9c')
|
||||
return zlib.decompress(blob[zi:])
|
||||
return blob
|
||||
|
||||
# --- verify the track key scheme ---
|
||||
es,data=load_pak("dat/movie/eng")
|
||||
keys={h for h,_,_ in es}
|
||||
for mv,exp in [("S00A",0x6F2D9663),("hokyu_DS_s02A",0x3662B1F8),("RT01C_1",0x756F69FB),("S16A",0xEEB85377)]:
|
||||
k=nh(f"subtitle_{mv}.tbl")
|
||||
print(f"subtitle_{mv}.tbl -> {k:08X} expect {exp:08X} inpak={k in keys} {'OK' if k==exp else 'MISMATCH'}")
|
||||
|
||||
# --- build MSG_DEMO text table from GP_MAIN_GAME_E ---
|
||||
es2,data2=load_pak("dat/GP_MAIN_GAME_E")
|
||||
text={} # 'MSG_DEMO_ddd_ppp_ll' -> string
|
||||
keyrx=re.compile(r'^MSG_DEMO_\d+(_\d+)*$')
|
||||
for h,o,s in es2:
|
||||
dec=unz(data2[o:o+s])
|
||||
if dec[:4]!=b'IXUD': continue
|
||||
# walk null-terminated utf-16le strings in the whole block
|
||||
toks=re.findall(rb'(?:[\x20-\x7e]\x00){2,}', dec)
|
||||
toks=[t.decode('utf-16-le') for t in toks]
|
||||
# pair: text followed by its key
|
||||
for i in range(len(toks)-1):
|
||||
if keyrx.match(toks[i+1]) and not keyrx.match(toks[i]):
|
||||
text[toks[i+1]]=toks[i]
|
||||
print(f"\nMSG_DEMO text lines loaded: {len(text)}")
|
||||
|
||||
# --- render a movie's subtitle transcript ---
|
||||
def track_for(mv):
|
||||
k=nh(f"subtitle_{mv}.tbl")
|
||||
for h,o,s in es:
|
||||
if h==k: return unz(data[o:o+s])
|
||||
return None
|
||||
# index text by integer demo id -> ordered list of lines
|
||||
bydemo={}
|
||||
for k,v in text.items():
|
||||
m=re.match(r'MSG_DEMO_(\d+)_',k)
|
||||
if m: bydemo.setdefault(int(m.group(1)),[]).append((k,v))
|
||||
for d in bydemo: bydemo[d].sort()
|
||||
|
||||
def transcript(mv):
|
||||
dec=track_for(mv)
|
||||
if not dec: return f"[no track for {mv}]"
|
||||
toks=re.findall(rb'(?:[\x20-\x7e]\x00){2,}', dec)
|
||||
toks=[t.decode('utf-16-le') for t in toks]
|
||||
out=[f"=== {mv}.wmv ==="]
|
||||
# collect all MSG_DEMO ids and timecodes in order; pair positionally
|
||||
seq=[('id',int(re.match(r'MSG_DEMO_(\d+)$',t).group(1))) if re.match(r'MSG_DEMO_(\d+)$',t)
|
||||
else ('tc',t) if re.match(r'\d\d:\d\d\.\d\d$',t) else ('x',t) for t in toks]
|
||||
ids=[v for k,v in seq if k=='id']; tcs=[v for k,v in seq if k=='tc']
|
||||
for j,demo in enumerate(ids):
|
||||
tc=tcs[j] if j<len(tcs) else "--:--.--"
|
||||
lines=[v for _,v in bydemo.get(demo,[])]
|
||||
out.append(f" {tc} [{demo:3d}] "+(" ".join(lines) if lines else "(no text on disc)"))
|
||||
return "\n".join(out)
|
||||
|
||||
for mv in ["S00A","S16A","hokyu_DS_s02A"]:
|
||||
print(); print(transcript(mv))
|
||||
Reference in New Issue
Block a user