53f834562a
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
59 lines
3.2 KiB
Rust
59 lines
3.2 KiB
Rust
//! Which keyless primitives have their paint position FORCED by occlusion?
|
|
//!
|
|
//! An opaque full-screen quad must sort below every element visible at any
|
|
//! instant it is opaque. Where that set is *every* other element, its position is
|
|
//! forced to first — derived from the file, not analogised from a neighbour.
|
|
//!
|
|
//! Controls, both measured in the running game and both reproduced here:
|
|
//! * `palogo_eff0.prm` is measured painting FIRST — and comes out forced first.
|
|
//! * `pteff00.prm` is measured painting LAST — and is forced below only a
|
|
//! handful, so the constraint permits it on top.
|
|
//!
|
|
//! ⚠️ Assumes straight alpha-over blending. Blend mode is ❔ in
|
|
//! `ui-prm-primitives.md`; an additive quad at alpha 255 would not occlude.
|
|
use sylpheed_formats::{pak, ratc, ui_layout};
|
|
|
|
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();
|
|
let (mut forced, mut partial, mut free) = (0usize, 0usize, 0usize);
|
|
let mut names: std::collections::BTreeMap<String, (usize, usize)> = Default::default();
|
|
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 };
|
|
let tmax = b.elements.iter().flat_map(|el| el.keyframes.iter().filter_map(|k| k.time))
|
|
.max().unwrap_or(0);
|
|
if tmax == 0 { continue }
|
|
for el in &b.elements {
|
|
if ui_layout::sprite_layer_key(&b, &by, el).is_some() { continue }
|
|
// full-screen only: a quad that does not cover cannot occlude
|
|
if el.pivot_x * 2 < 1280 || el.pivot_y * 2 < 720 { continue }
|
|
let op: Vec<u32> = (0..=tmax)
|
|
.filter(|&t| el.pose_at(t).map(|k| k.fade >> 24) == Some(255)).collect();
|
|
if op.is_empty() { continue }
|
|
let others: Vec<&ui_layout::Element> =
|
|
b.elements.iter().filter(|o| o.index != el.index).collect();
|
|
if others.is_empty() { continue }
|
|
let below = others.iter().filter(|o|
|
|
op.iter().any(|&t| o.pose_at(t).map(|k| k.fade >> 24).unwrap_or(0) > 0)).count();
|
|
let ent = names.entry(el.name.clone()).or_default();
|
|
ent.1 += 1;
|
|
if below == others.len() { forced += 1; ent.0 += 1 }
|
|
else if below > 0 { partial += 1 } else { free += 1 }
|
|
}
|
|
}
|
|
}
|
|
println!("keyless FULL-SCREEN primitives with an opaque interval:");
|
|
println!(" position FORCED FIRST (below every other element) : {forced}");
|
|
println!(" forced below SOME but not all : {partial}");
|
|
println!(" occludes nothing : {free}");
|
|
println!("\nby name — instances forced first / total:");
|
|
for (n, (f, t)) in &names { println!(" {n:>24} {f:>4} / {t}"); }
|
|
}
|