cfcda5501c
Partly closes ui-prm-primitives.md's standing blocker, "where an UNMEASURED
primitive paints". Raised by the port: build_12/build_15 composite to solid
black at every instant of their declared life, because pgloading_eff00.prm -- a
full-screen opaque quad -- sorts last.
The rule is a constraint read off the file, not a preference: an element that
covers the screen and is fully opaque at some instant cannot paint above
anything visible at that instant. Where the elements visible during its opaque
span are ALL of them, its position is forced to first.
pgloading_eff00.prm is opaque for 39 instants and all 9 other elements are
visible inside that span -> forced first, 4/4 instances.
Two controls, both measured orders from the running game, and the rule has to
survive both:
* palogo_eff0.prm is measured painting FIRST -- opaque 211 instants, forced
below 6 of 6. It is NAMED like an overlay, so a name-based rule sorts it
wrong against a measured order. Occlusion gets it right.
* pteff00.prm is measured painting LAST -- opaque for 2 instants at its
screen's entry and exit, forced below only 3 of 23, so the constraint
permits it on top where it belongs.
Disc-wide: 80 instances forced first, 50 constrained but not forced, 0
unconstrained. The split runs almost exactly along the names -- every *base* is
forced, every *eff00* is not -- with three families crossing it, which is
exactly why the name is not the rule.
It also explains 36 builds the corpus had recorded as "coming out one colour"
with no cause: pzeff00.prm is forced first in 32 of 32 instances, so they were
wiped by our own sort rather than by the game.
The rule's real limit was found by its own disc-wide test failing. Applied to
any element it claimed 22 .t32 SPRITES must sort first against their own layer
keys -- pneff01.t32 (key 0xd850, #8 of 13) and pbfriendly.t32 (0x9230, #17 of
49). A sprite's ELEMENT alpha says nothing about whether its TEXTURE covers the
screen, so forced_backdrop is now restricted to untextured primitives, which is
also the only case derived_paint_order consults it for.
Reach stated: assumes straight alpha-over (blend mode is still open, and an
additive quad at alpha 255 would not occlude); it is a lower bound, not an
ordering; and there is no new oracle measurement -- both controls are prior
ones, and a loading screen is not reachable from the title path.
3 new disc tests; the 13 paint-order tests are green, including
the_derived_order_matches_the_measured_ones_up_to_ties.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QsEPXWVaEpyfudtR6re1Pd
51 lines
2.5 KiB
Rust
51 lines
2.5 KiB
Rust
//! Does a primitive's alpha AT t=0 predict the layer it paints on?
|
|
//!
|
|
//! `implied_layer_key` is a measured per-name table. The four entries in it, read
|
|
//! against their own keyframes, suggest a rule derived from the file instead:
|
|
//!
|
|
//! * `palogo_eff0.prm` measured FIRST (0x0000) -- alpha at t=0 = ?
|
|
//! * `pfbase.tbm` measured FIRST (0x0000) -- alpha at t=0 = ?
|
|
//! * `pteff02.prm` measured MIDDLE (0x8030) -- alpha at t=0 = ?
|
|
//! * `pteff00.prm` measured LAST -- alpha at t=0 = ?
|
|
//!
|
|
//! ⚠️ The rule was invented AFTER seeing three of those answers, so it is fitted
|
|
//! on them and only `pfbase.tbm` is out of sample. This prints all four plus a
|
|
//! disc-wide census, so the fit and its reach are visible together.
|
|
use sylpheed_formats::{pak, ratc, ui_layout};
|
|
use std::collections::BTreeMap;
|
|
|
|
fn main() {
|
|
let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
|
|
let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat")).expect("dat/")
|
|
.flatten().map(|e| e.path())
|
|
.filter(|p| p.extension().and_then(|s| s.to_str()) == Some("pak")).collect();
|
|
paks.sort();
|
|
// name -> (count, set of t=0 alphas, set of "starts at max" flags)
|
|
let mut byname: BTreeMap<String, (usize, BTreeMap<u32, usize>)> = BTreeMap::new();
|
|
for p in &paks {
|
|
let Ok(ar) = pak::PakArchive::open(p) else { continue };
|
|
for e in ar.entries() {
|
|
let Ok(by) = ar.read(e) else { continue };
|
|
if !ratc::is_ratc(&by) { continue }
|
|
let Some(b) = ui_layout::parse_build(&by) else { continue };
|
|
for el in &b.elements {
|
|
// primitives and the keyless: anything with no layer key
|
|
if ui_layout::sprite_layer_key(&b, &by, el).is_some() { continue }
|
|
let Some(k0) = el.keyframes.first() else { continue };
|
|
let a0 = k0.fade >> 24;
|
|
let ent = byname.entry(el.name.clone()).or_default();
|
|
ent.0 += 1;
|
|
*ent.1.entry(a0).or_default() += 1;
|
|
}
|
|
}
|
|
}
|
|
println!("{:>28} {:>7} alpha at t=0 (count)", "keyless element", "n");
|
|
let known = ["palogo_eff0.prm", "pfbase.tbm", "pteff02.prm", "pteff00.prm"];
|
|
for (n, (c, a)) in &byname {
|
|
let tag = if known.contains(&n.as_str()) { " <- IN THE MEASURED TABLE" } else { "" };
|
|
if *c < 4 && tag.is_empty() { continue }
|
|
let al: Vec<String> = a.iter().map(|(k, v)| format!("{k}x{v}")).collect();
|
|
println!(" {n:>26} {c:>7} {}{tag}", al.join(" "));
|
|
}
|
|
}
|