SamandClaude Fable 5.1
c3555b4eea
- a size-less `<Model>` pane's rect is its file's box in layout units: the reference's geometry overrides (`0x76d080`/`0x76d0d0`) answer the bbox extent whenever no size is authored, `bboxExtent · 768·√(a²+1) · layoutScale` FrameXML units (`1280 · extent` at 4:3), written into the pane's layout input when the file's facts land, re-derived on an aspect change, and ended for good by any authored size; `SetPosition` is the same unit, which is how `0x4a7b20` centres the arrow at `½·GetWidth, ½·GetHeight` through the override — so the map arrow's sprite arm and its hand-sized 33.6 px footprint go (its rect is `0.0262 × 0.0263` layout units, 33.5 × 33.7 FrameXML units at 4:3, 41.0 × 41.2 at 16:9), and the stock `ItemAnim` pane plays the item push unadapted (`ReplaceIconTexture` on the type-14 batch, the 1000 ms clamp, the stock `OnAnimFinished`), `ContainerFrameAdapters.xml` losing 0887's Lua card and its hand-measured 42.41 × 124.72 rect — the implicit one at 16:9 — and keeping the keyring fork and the three bag verbs (2015); and the cooldown is the reference's own model: the texture-transform law `uv' = R_q((uv + t − p) ⊙ s) + p`, `p = (½, ½)`, the raw quaternion component-lerped and never normalised, is one function (`uv_transform`) with the shader's UV fold as its twin — rotation and scale tracks bake per file sequence slot beside the translation, the mat-anim table gains an affine row `[cos − 1, sin, sx − 1, sy − 1]` on `anim_slots.z` whose identity is the zero row so every static batch reads exactly what it did, and a UI tile clones the twin material per animated batch and writes both rows every frame off the pane's play head, never the world clock; the stock `Cooldown.xml` runs off the chain on 2007's two handlers, the file's four quadrant quads turned by their own rotation tracks (`0 → −90°` over each quadrant's 250 ms window, clockwise from 12 o'clock) and its alpha tracks revealing the star for the flash; retired: the native `Cooldown` widget and `SetCooldown` (an Era API 1.12 never had — `CreateFrame("Cooldown")` is the reference's unknown-type refusal now), the loader's `Model → Cooldown` substitution, the app's hand-built pie and star, and our `Cooldown.xml`; `assets/ui` is eight files (2019)
- `UpdateMapHighlight` gets its zone-level exits (B360): at zone zoom ours returned the nil tail for every cursor position, so hovering Deadwind Pass from Duskwood showed no label where 1.12 shows "Deadwind Pass"; the reference's `0x4a7fa0` runs two lookups at zone level and answers a NAME only — first the current zone's exploration-gated overlay list (the builder at `0x4a6ad9` gating on the explored byte), each row's HitRect scaled by 1/1002 and 1/668 against the normalized cursor, edges inclusive, the first hit naming its Area1, then the continent grid re-windowed through the displayed zone's own rect, naming the neighbouring zone or city and nothing for the displayed zone itself — and only the name-only tail is reachable from there, fileName nil and the six coords zero, so the stock frame hides the highlight quad, as the director's own 1.12 shot shows; and `SetVerticalScroll` stores the offset as given (B370, B363): the reference's `0x786db0` compares the new offset against the old and writes it to `[+0x328]` verbatim, `0x787100` re-anchors the scroll child off it, and the range at `[+0x320]` is never read on that path — every clamp the reference exhibits is FrameXML's, through the scroll bar's `[min, max]`; ours clamped into `[0, GetVerticalScrollRange()]`, the child's overflow past the FRAME, which is 40 px short of where `FauxScrollFrame_Update` sends the bar on the 220-tall skills list (three rows lost) and 15 px short on the 287-tall who list (one); the setter fires `OnVerticalScroll` only on a change, as the bytes do, `BenillaScroll_Step` bounds its wheel in Lua where the reference's handler does, and the ScrollFrame kind's prose stops calling its offset unpinned (2017)
- overdraw's cheap half, the sky first: since 0588 every sky element wrote `frag_depth = 0.0`, which costs a pipeline its early-Z, so on an outdoor frame every full-screen dome fragment under the ground and the buildings was shaded in full (the gradient's `asin`, `atan2` and eight table lookups at dawn and dusk) and thrown away; one shared `sky_vertex.wgsl` — bevy's mesh vertex verbatim plus `out.position.z = 0.0` — is now the vertex stage of the gradient dome, the cloud dome, the star patches and the celestial discs and glares, and the model lane's `WOW_SKY_DEPTH` branch moves from its fragment to its vertex, so no sky fragment declares `frag_depth` and the rasterizer rejects the covered screen before the shader runs; every sky `specialize` zeroes the rasterizer bias constant the `sky_order` rung had been leaking into `DepthBiasState::constant`, harmless only while the fragment overwrote its depth, and the prose beside the pin follows it; then the retained `static_gx` pass draws BEFORE bevy's opaque pass (`StartMainPass → static_gx → MainOpaquePass`) — buildings and doodads are the frame's best occluders and a terrain fragment its dearest, six samples a pixel — so walls reject the terrain behind them instead of the reverse, the pass taking the first-use clear with it and the dev depth probe ordered after it; measured on 16 capture scenarios: 14 bit-identical, `northshire-dusk` 1 px and `water-night` 11 px, attributed to exact depth ties on static/terrain silhouettes and last-bit interpolation noise; a depth prepass and near-to-far bins are declined until a journal says where the time goes (2016)
- the grass cut goes per pixel because of a quarter-mip: `0x6813d0` sets `D3DSAMP_MIPMAPLODBIAS = +0.25` on stage 0 (`0x6813f4`) once per frame before the detail-doodad pass — capture-confirmed on all 29 doodad batches, and outside the `[0x6b1000, 0x6b3200)` scan 2004 had called complete; it decides the whole look because the `clutter_cut` probe finds 6 of 31 shipped detail atlases carry a BINARY alpha pyramid (mip 0 has DXT3's 16 levels, every level below exactly two, both starting zones among them), so `a × ramp` degenerates to a global on/off and every texel of a leaf crosses at the same depth — Elwynn's survivor coverage is flat at 47.6 % across the whole 52.5–61.1 yd band, then 0.0 %, while the probe's box-filtered control erodes 47.7 → 20.9 over the same band, so the art has the gradient the shipped pyramid threw away, and `clutter_size` puts the median tuft at 0.92 yd tall, 1.03 yd deep, a full yard for the boundary plane to sweep; the escape is bilinear: full alpha needs a 2×2 all-opaque texel neighbourhood, and those run out between mip 2 and 3 (179/56/10/0/0/0 on the dominant Elwynn cell), so the reference's λ ≈ 2.9–3.3 sits past the cliff and the tuft erodes continuously — 2.2 % of a tuft's pixels leave in the last half-yard with the bias, 11.6 % without, 24.2 % one mip sharper; wgpu has no sampler LOD bias, so the clutter lane re-samples base colour at `view.mip_bias + 0.25`, keeping the sampler every other model batch shares at the reference's 0; ruled out on the way: our BLP decoder (all nine uploaded levels byte-identical against the archive's 52 793 BLP2s), mip regeneration, the `has_mipmaps` byte's value 2 (a plain boolean, an authoring marker), anisotropy and geometry; what it does not fix is resolution-dependent, and so is the reference's own look — λ with the bias is 3.22 at the capture's 648p but 2.48 at 1080p and 1.48 at 2160p, so at a modern resolution the reference itself pops leaf by leaf, and scaling the bias with the viewport is one reversible line left for a look call (2021)
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
88 lines
4.8 KiB
Rust
88 lines
4.8 KiB
Rust
//! **The engine's WGSL, compiled into the binary** (decision 1175).
|
|
//!
|
|
//! The seven shaders under `src/shaders/` are the *engine's* — 1171's line, unchanged: the game's
|
|
//! five live in `benilla-app`, and `embedded_asset!` is per-crate by construction, so the seam
|
|
//! costs nothing to keep.
|
|
//!
|
|
//! Until 1175 these were served from a file asset root that `boot.rs` baked as
|
|
//! `concat!(env!("CARGO_MANIFEST_DIR"), "/assets")` — an absolute path into the *build* machine's
|
|
//! source tree. On any other machine it resolves to nothing and the world renders with no shaders
|
|
//! at all: the "silently-no-shaders trap" `capture/mod.rs`'s header already named. Embedding is
|
|
//! what makes the binary answer for its own content; `benilla-assets` has done it for its four
|
|
//! since it had them, and this is the same move for the other twelve.
|
|
//!
|
|
//! **Why these calls live in a file directly under `src/`.** `embedded_asset!` derives the served
|
|
//! path by stripping everything up to and including the crate's `src/` from `file!()`, then
|
|
//! re-prefixing the crate name — and it does **not** normalize the result. Called from
|
|
//! `src/sun/materials.rs` the shader would land at `embedded://benilla_world/sun/…`, and reaching
|
|
//! back out with `"../shaders/x.wgsl"` would bake a literal `..` component into the virtual
|
|
//! directory. One registration point at the root of `src/` is what keeps every path
|
|
//! `embedded://benilla_world/shaders/<name>.wgsl`.
|
|
|
|
use bevy::prelude::*;
|
|
|
|
/// Compile the engine's seven WGSL files in and register them under
|
|
/// `embedded://benilla_world/shaders/…`.
|
|
///
|
|
/// Added as the first member of [`crate::world_plugins::WorldPlugins`] rather than exposed as a
|
|
/// free function a composition root must remember to call: a shader that fails to register is
|
|
/// invisible until something tries to draw with it, which is the exact failure mode this record
|
|
/// closes. `Plugin::build` runs at `add_plugins` time, and both binaries add `DefaultPlugins`
|
|
/// (which creates the registry these calls fill) before `WorldPlugins`.
|
|
pub(crate) fn plugin(app: &mut App) {
|
|
bevy::asset::embedded_asset!(app, "shaders/sky_vertex.wgsl");
|
|
bevy::asset::embedded_asset!(app, "shaders/sky.wgsl");
|
|
bevy::asset::embedded_asset!(app, "shaders/star.wgsl");
|
|
bevy::asset::embedded_asset!(app, "shaders/cloud.wgsl");
|
|
bevy::asset::embedded_asset!(app, "shaders/celestial.wgsl");
|
|
bevy::asset::embedded_asset!(app, "shaders/ffx_glow.wgsl");
|
|
bevy::asset::embedded_asset!(app, "shaders/wow_effect.wgsl");
|
|
bevy::asset::embedded_asset!(app, "shaders/static_gx.wgsl");
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use bevy::asset::io::AssetSourceId;
|
|
use bevy::prelude::*;
|
|
|
|
/// Every `.wgsl` under `src/shaders/` answers at `embedded://benilla_world/shaders/<name>`.
|
|
///
|
|
/// `embedded_asset!` derives that path from `file!()` and does **not** normalize it, so it is
|
|
/// not something to reason about — this reads the bytes back through the same source a
|
|
/// material's `ShaderRef` goes through. Driving the loop off the *directory listing* is the
|
|
/// other half: a shader added without a registration line, or registered from a submodule
|
|
/// (which silently prefixes that module's directory), fails here instead of drawing nothing.
|
|
#[test]
|
|
fn every_engine_shader_answers_at_its_embedded_path() {
|
|
let mut app = App::new();
|
|
app.add_plugins(bevy::asset::AssetPlugin::default());
|
|
app.add_plugins(super::plugin);
|
|
let server = app.world().resource::<AssetServer>();
|
|
let source = server.get_source(AssetSourceId::from("embedded")).unwrap();
|
|
|
|
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/src/shaders");
|
|
let mut found = 0;
|
|
for entry in std::fs::read_dir(dir).unwrap() {
|
|
let name = entry.unwrap().file_name().to_string_lossy().into_owned();
|
|
if !name.ends_with(".wgsl") {
|
|
continue;
|
|
}
|
|
found += 1;
|
|
let path = format!("benilla_world/shaders/{name}");
|
|
let read = bevy::tasks::block_on(async {
|
|
source.reader().read(std::path::Path::new(&path)).await
|
|
});
|
|
assert!(
|
|
read.is_ok(),
|
|
"embedded://{path} does not resolve — {name} is on disk but not registered in \
|
|
`shaders::plugin`, or was registered from a file that is not directly under src/"
|
|
);
|
|
}
|
|
// 6 since decision 1264 retired `skybox.wgsl` (a WMO skybox draws on the shared
|
|
// model lane, whose forced-far-depth branch lives in `benilla_assets`'
|
|
// `wow_model.wgsl`); 7 since 1429 added `static_gx.wgsl` (the B1 retained pass);
|
|
// 8 since 2016 added `sky_vertex.wgsl` (the sky's shared far-depth vertex stage).
|
|
assert_eq!(found, 8, "the engine's shader set changed size");
|
|
}
|
|
}
|