From 658f50d8230130911c87cae081d069e551aa3eb6 Mon Sep 17 00:00:00 2001
From: pkuzic <p.kuzickins@gmail.com>
Date: Fri, 25 Sep 2026 02:53:01 +0100
Subject: [PATCH 1/7] MONKEY (skybox): LightSkybox reader for both layouts +
 zone_skyboxes walk

Reads the 1.12 two-field and the extended ID/Name/Flags/CelestialName table by
header field count; zone_skyboxes() runs the modern collector over the
sphere-weighted Light walk.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/benilla-formats/src/lib.rs          |   6 +-
 crates/benilla-formats/src/light.rs        |  34 ++-
 crates/benilla-formats/src/light/skybox.rs | 249 +++++++++++++++++++++
 3 files changed, 267 insertions(+), 22 deletions(-)
 create mode 100644 crates/benilla-formats/src/light/skybox.rs

diff --git a/crates/benilla-formats/src/lib.rs b/crates/benilla-formats/src/lib.rs
index ad87a31e..83813eda 100644
--- a/crates/benilla-formats/src/lib.rs
+++ b/crates/benilla-formats/src/lib.rs
@@ -127,7 +127,11 @@ pub use ground_effects::{
     GroundEffectCatalog, FRILL_DENSITY, FRILL_DENSITY_MAX,
 };
 mod light;
-pub use light::{Atmosphere, LightCatalog, Submersion, ZERO_KEY_COLOR, ZERO_KEY_SCALAR};
+// MONKEY (skybox): the skybox row and the zone walk's entries.
+pub use light::{
+    Atmosphere, LightCatalog, SkyboxDef, Submersion, ZoneSkybox, SKYBOX_FOG_BLEND, SKYBOX_FULL_DAY,
+    SKYBOX_KEEP_CELESTIAL, ZERO_KEY_COLOR, ZERO_KEY_SCALAR,
+};
 mod loading_screen;
 pub use loading_screen::{load_loading_screens, LoadingScreenCatalog};
 mod liquid;
diff --git a/crates/benilla-formats/src/light.rs b/crates/benilla-formats/src/light.rs
index 3edc847e..471e2ccf 100644
--- a/crates/benilla-formats/src/light.rs
+++ b/crates/benilla-formats/src/light.rs
@@ -7,13 +7,18 @@ use std::collections::HashMap;
 use anyhow::{Context, Result};
 use benilla_dbc::{FieldType, Schema, SchemaField};
 
-use crate::dbc::{f32_at, parse, str_at, u32_at};
+use crate::dbc::{f32_at, parse, u32_at};
 use crate::Chain;
 
 mod atmosphere;
+// MONKEY (skybox): the extended LightSkybox layout and the zone skybox walk.
+mod skybox;
 mod tables;
 
 pub use atmosphere::Atmosphere;
+pub use skybox::{
+    SkyboxDef, ZoneSkybox, SKYBOX_FOG_BLEND, SKYBOX_FULL_DAY, SKYBOX_KEEP_CELESTIAL,
+};
 use atmosphere::{
     FB_CLOUD_DENSITY, FB_FOG_END, FB_FOG_START_MULT, IB_AMBIENT, IB_CLOUD_GBASE, IB_CLOUD_SLOPE,
     IB_CLOUD_SUN, IB_DIFFUSE, IB_FOG_COLOR, IB_OCEAN_DEEP, IB_OCEAN_SHALLOW, IB_RIVER_DEEP,
@@ -171,9 +176,10 @@ pub struct LightCatalog {
     /// `LightParams` id → `lightSkyboxID` ([`LP_SKYBOX`]), for its non-zero rows only.
     light_params_skybox: HashMap<u32, u32>,
     /// `LightSkybox.dbc` id → model chain path, spelled as a WMO MOSB skybox is so one model never
-    /// builds twice. Only id 3 (`DeathClouds.mdx`) is reachable from `LightParams`; the other five
-    /// rows are MOSB skyboxes.
-    skyboxes: HashMap<u32, String>,
+    /// builds twice. Stock 1.12 reaches only id 3 (`DeathClouds.mdx`) from `LightParams`; the
+    /// other rows are MOSB skyboxes. MONKEY (skybox): flags and the celestial model ride along
+    /// ([`SkyboxDef`]), read from either table layout.
+    skyboxes: HashMap<u32, SkyboxDef>,
 }
 
 fn light_schema() -> Schema {
@@ -319,22 +325,8 @@ impl LightCatalog {
             }
             (glow, highlight, water_alpha, skybox)
         };
-        let skyboxes = {
-            let bytes = chain
-                .read_file(LIGHT_SKYBOX)
-                .with_context(|| format!("reading {LIGHT_SKYBOX}"))?;
-            let mut schema = Schema::new("LightSkybox");
-            schema.add_field(SchemaField::new("ID", FieldType::UInt32));
-            schema.add_field(SchemaField::new("Name", FieldType::String));
-            let rs = parse(&bytes, schema, "LightSkybox")?;
-            let mut m = HashMap::with_capacity(rs.records().len());
-            for r in rs.records() {
-                if let (Some(id), Some(path)) = (u32_at(r, 0), str_at(&rs, r, 1)) {
-                    m.insert(id, crate::models::model_path(&path));
-                }
-            }
-            m
-        };
+        // MONKEY (skybox): both layouts, keyed by the header's field count.
+        let skyboxes = skybox::load_skyboxes(chain, LIGHT_SKYBOX)?;
         Ok(LightCatalog {
             lights,
             int_bands,
@@ -438,7 +430,7 @@ impl LightCatalog {
     pub fn ghost_skybox(&self, map: u32, pos: [f32; 3]) -> Option<&str> {
         let light = self.pick_light(map, pos)?;
         let id = self.light_params_skybox.get(&light.params[SLOT_DEATH])?;
-        self.skyboxes.get(id).map(String::as_str)
+        self.skyboxes.get(id).map(|d| d.path.as_str())
     }
 
     /// The reference's area-light blend: from the map's global light, lerp toward each local
diff --git a/crates/benilla-formats/src/light/skybox.rs b/crates/benilla-formats/src/light/skybox.rs
new file mode 100644
index 00000000..70322687
--- /dev/null
+++ b/crates/benilla-formats/src/light/skybox.rs
@@ -0,0 +1,249 @@
+//! MONKEY (skybox): `LightSkybox.dbc` in both layouts and the zone skybox walk.
+//!
+//! The 1.12 table is `ID, Name` (8-byte records). The extended table the sky patch ships is the
+//! modern column set with paths in place of FileDataIDs: `ID, Name, Flags, CelestialName`
+//! (16-byte records). The layout is picked by the header's field count, so an unpatched data set
+//! loads with flags 0 and no celestial model.
+//!
+//! [`LightCatalog::zone_skyboxes`] is the modern client's skybox collector
+//! (`DayNightLightHolder::SkyBoxCollector::addSkyBox`) over the same global-then-farthest-first
+//! walk as [`LightCatalog::sample_blended`]: the same model keeps its largest alpha, and every
+//! other model collected so far is scaled by `1 − alpha`, so two skyboxes crossfade. A light whose
+//! param names no skybox leaves the list alone, as in the modern client.
+
+use std::collections::HashMap;
+
+use anyhow::{Context, Result};
+use benilla_dbc::{FieldType, Schema, SchemaField};
+
+use super::{blend_alpha, weather_slot, LightCatalog, Submersion, FALLBACK_LIGHT_ID, SLOT_CLEAR};
+use crate::dbc::{parse, str_at, u32_at};
+use crate::Chain;
+
+/// Flag `0x1`: the model's sequence 0 plays across the game day, `time = duration × day fraction`.
+pub const SKYBOX_FULL_DAY: u32 = 0x1;
+/// Flag `0x2`: the procedural sky (dome, sun, moons, stars, clouds) keeps drawing under the model.
+pub const SKYBOX_KEEP_CELESTIAL: u32 = 0x2;
+/// Flag `0x4`: an alpha cone in the final fog colour draws over the model's horizon.
+pub const SKYBOX_FOG_BLEND: u32 = 0x4;
+
+/// One `LightSkybox.dbc` row.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SkyboxDef {
+    /// The model's chain path, spelled as a WMO MOSB skybox is, so one model never builds twice.
+    pub path: String,
+    /// The modern flag word; 0 in the 1.12 layout.
+    pub flags: u32,
+    /// The second model the modern client names as the celestial layer; `None` when empty.
+    pub celestial: Option<String>,
+}
+
+/// One weighted skybox the zone walk collected.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ZoneSkybox {
+    pub id: u32,
+    pub weight: f32,
+}
+
+/// Read `LightSkybox.dbc`, choosing the schema by the header's field count.
+pub(super) fn load_skyboxes(chain: &mut Chain, file: &str) -> Result<HashMap<u32, SkyboxDef>> {
+    let bytes = chain
+        .read_file(file)
+        .with_context(|| format!("reading {file}"))?;
+    let fields = bytes
+        .get(8..12)
+        .map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]]))
+        .unwrap_or(2);
+    let extended = fields >= 4;
+    let mut schema = Schema::new("LightSkybox");
+    schema.add_field(SchemaField::new("ID", FieldType::UInt32));
+    schema.add_field(SchemaField::new("Name", FieldType::String));
+    if extended {
+        schema.add_field(SchemaField::new("Flags", FieldType::UInt32));
+        schema.add_field(SchemaField::new("CelestialName", FieldType::String));
+        // Columns past the four this client reads, if a later table carries them.
+        for i in 4..fields {
+            schema.add_field(SchemaField::new(format!("extra{i}"), FieldType::UInt32));
+        }
+    }
+    let rs = parse(&bytes, schema, "LightSkybox")?;
+    let mut m = HashMap::with_capacity(rs.records().len());
+    for r in rs.records() {
+        let (Some(id), Some(name)) = (u32_at(r, 0), str_at(&rs, r, 1)) else {
+            continue;
+        };
+        let (flags, celestial) = if extended {
+            (
+                u32_at(r, 2).unwrap_or(0),
+                str_at(&rs, r, 3)
+                    .filter(|c| !c.trim().is_empty())
+                    .map(|c| crate::models::model_path(&c)),
+            )
+        } else {
+            (0, None)
+        };
+        m.insert(
+            id,
+            SkyboxDef {
+                path: crate::models::model_path(&name),
+                flags,
+                celestial,
+            },
+        );
+    }
+    Ok(m)
+}
+
+/// The modern collector's step: dedupe by model with the larger alpha, then scale every other
+/// entry by `1 − alpha` (`addSkyBox` steps 1 and 4).
+pub(super) fn collect(list: &mut Vec<ZoneSkybox>, id: u32, alpha: f32) {
+    if alpha <= 0.0 {
+        return;
+    }
+    let (at, alpha) = match list.iter_mut().position(|e| e.id == id) {
+        Some(i) => {
+            let a = list[i].weight.max(alpha);
+            list[i].weight = a;
+            (i, a)
+        }
+        None => {
+            list.push(ZoneSkybox { id, weight: alpha });
+            (list.len() - 1, alpha)
+        }
+    };
+    for (i, e) in list.iter_mut().enumerate() {
+        if i != at {
+            e.weight *= 1.0 - alpha;
+        }
+    }
+}
+
+impl LightCatalog {
+    /// A `LightSkybox.dbc` row by id.
+    pub fn skybox_def(&self, id: u32) -> Option<&SkyboxDef> {
+        self.skyboxes.get(&id)
+    }
+
+    /// The row whose model is `path`, for a MOSB skybox the table also names.
+    pub fn skybox_def_by_path(&self, path: &str) -> Option<&SkyboxDef> {
+        self.skyboxes
+            .values()
+            .find(|d| d.path.eq_ignore_ascii_case(path))
+    }
+
+    /// The skybox the slot's param names; a weather slot without one falls back to the clear
+    /// slot's, because the sky patch authors the clear slot only.
+    fn light_skybox(&self, params: &[u32; 5], slot: usize) -> Option<u32> {
+        let of = |p: u32| self.light_params_skybox.get(&p).copied();
+        let param = match params[slot] {
+            0 => params[SLOT_CLEAR],
+            p => p,
+        };
+        of(param).or_else(|| (slot != SLOT_CLEAR).then(|| of(params[SLOT_CLEAR])).flatten())
+    }
+
+    /// The weighted skyboxes at `pos` for the living: the global (or fallback) light at alpha 1,
+    /// then each local sphere containing `pos` farthest first at its falloff alpha, through
+    /// [`collect`]. The slot is the lighting resolve's ([`weather_slot`]), ghost excluded: the
+    /// death sky is [`Self::ghost_skybox`].
+    pub fn zone_skyboxes(
+        &self,
+        map: u32,
+        pos: [f32; 3],
+        stormy: bool,
+        submersion: Submersion,
+    ) -> Vec<ZoneSkybox> {
+        let mut out = Vec::new();
+        if submersion.fixed_param().is_some() {
+            return out;
+        }
+        let slot = weather_slot(false, stormy, submersion.is_water());
+        let map_has_no_light = !self.lights.iter().any(|l| l.map == map);
+        let base = self
+            .lights
+            .iter()
+            .find(|l| l.map == map && l.global)
+            .or_else(|| {
+                map_has_no_light
+                    .then(|| self.lights.iter().find(|l| l.id == FALLBACK_LIGHT_ID))
+                    .flatten()
+            });
+        if let Some(sky) = base.and_then(|l| self.light_skybox(&l.params, slot)) {
+            collect(&mut out, sky, 1.0);
+        }
+        let mut locals: Vec<(f32, &super::Light)> = self
+            .lights
+            .iter()
+            .filter(|l| l.map == map && !l.global)
+            .filter_map(|l| {
+                let d = (0..3)
+                    .map(|i| (l.pos[i] - pos[i]).powi(2))
+                    .sum::<f32>()
+                    .sqrt();
+                (d <= l.falloff_end).then_some((d, l))
+            })
+            .collect();
+        locals.sort_by(|a, b| b.0.total_cmp(&a.0));
+        for (dist, l) in locals {
+            if let Some(sky) = self.light_skybox(&l.params, slot) {
+                collect(
+                    &mut out,
+                    sky,
+                    blend_alpha(dist, l.falloff_start, l.falloff_end),
+                );
+            }
+        }
+        out.retain(|e| e.weight > 0.0 && self.skyboxes.contains_key(&e.id));
+        out
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn w(list: &[ZoneSkybox], id: u32) -> f32 {
+        list.iter().find(|e| e.id == id).map_or(0.0, |e| e.weight)
+    }
+
+    #[test]
+    fn a_second_model_crossfades_the_first() {
+        let mut l = Vec::new();
+        collect(&mut l, 1, 1.0);
+        collect(&mut l, 2, 0.25);
+        assert!((w(&l, 1) - 0.75).abs() < 1e-6);
+        assert!((w(&l, 2) - 0.25).abs() < 1e-6);
+    }
+
+    #[test]
+    fn the_same_model_keeps_its_largest_alpha() {
+        let mut l = Vec::new();
+        collect(&mut l, 1, 0.5);
+        collect(&mut l, 2, 0.5);
+        collect(&mut l, 1, 0.8);
+        assert_eq!(l.len(), 2);
+        assert!((w(&l, 1) - 0.8).abs() < 1e-6);
+        assert!((w(&l, 2) - 0.5 * 0.2).abs() < 1e-6);
+    }
+
+    #[test]
+    fn a_zero_alpha_leaves_the_list_alone() {
+        let mut l = Vec::new();
+        collect(&mut l, 1, 1.0);
+        collect(&mut l, 2, 0.0);
+        assert_eq!(l, vec![ZoneSkybox { id: 1, weight: 1.0 }]);
+    }
+
+    /// The installed chain loads in either layout.
+    #[test]
+    fn the_installed_table_loads() {
+        let data = crate::wow_data_or_skip!();
+        let mut chain = crate::open_chain(&data).expect("open chain");
+        let m = load_skyboxes(&mut chain, super::super::LIGHT_SKYBOX).expect("LightSkybox");
+        assert_eq!(
+            m.get(&3).map(|d| d.path.as_str()),
+            Some(r"environments\stars\deathclouds.m2"),
+            "the ghost sky row"
+        );
+    }
+}

From 88ceb9d2c2fc283f3fff61f745aae914e5adf4a1 Mon Sep 17 00:00:00 2001
From: pkuzic <p.kuzickins@gmail.com>
Date: Fri, 25 Sep 2026 03:23:34 +0100
Subject: [PATCH 2/7] MONKEY (skybox): weighted zone skybox lane, flags,
 animated skybox rig

CameraSkybox becomes a weighted layer list (ghost > WMO > zone, modern
crossfade), flags 0x1 day cycle / 0x2 keep celestial / 0x4 fog cone, the
celestial model as a second layer, and a CPU rig + mat-anim rows so skybox
bones, texture transforms, colour and alpha tracks play.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/benilla-world/src/lib.rs               |   2 +
 .../benilla-world/src/model_render/batch.rs   |  46 +-
 crates/benilla-world/src/skybox.rs            | 845 ++++++++++++++----
 crates/benilla-world/src/skybox_anim.rs       | 527 +++++++++++
 crates/benilla-world/src/world_census.rs      |   5 +-
 5 files changed, 1260 insertions(+), 165 deletions(-)
 create mode 100644 crates/benilla-world/src/skybox_anim.rs

diff --git a/crates/benilla-world/src/lib.rs b/crates/benilla-world/src/lib.rs
index 02aef8e8..38281004 100644
--- a/crates/benilla-world/src/lib.rs
+++ b/crates/benilla-world/src/lib.rs
@@ -146,6 +146,8 @@ mod shaders;
 pub mod sky;
 pub mod sky_order;
 pub mod skybox;
+// MONKEY (skybox): the skybox rig and material loops.
+mod skybox_anim;
 pub mod static_gx;
 pub mod static_merge;
 pub mod straddle;
diff --git a/crates/benilla-world/src/model_render/batch.rs b/crates/benilla-world/src/model_render/batch.rs
index 9adc718e..eeeded74 100644
--- a/crates/benilla-world/src/model_render/batch.rs
+++ b/crates/benilla-world/src/model_render/batch.rs
@@ -110,11 +110,16 @@ impl M2BatchMaterials<'_> {
     /// (`[CM2Model+0x180]`, from the interior crossfade `[0xce9bdc]`) scales every batch's alpha,
     /// and `0 < A < 1` promotes a batch to SRC_ALPHA blending (`0x70c190`): `fade_blend` is that
     /// twin, or `steady` when the batch already blends.
+    ///
+    /// MONKEY (skybox): `uv` and `tint` are the batch's texture-transform and colour loops, the
+    /// material's seed and identity; [`crate::skybox_anim`] drives their rows.
     pub fn skybox(
         &mut self,
         sub: &benilla_formats::RenderSubmesh,
         texture: Option<Handle<Image>>,
         order: u16,
+        uv: Option<&std::sync::Arc<benilla_formats::UvAnim>>,
+        tint: Option<&std::sync::Arc<benilla_formats::RgbAnim>>,
     ) -> Option<SkyboxBatch> {
         let light = self.light.as_ref()?.0.clone();
         let torch = self.torch.binds()?;
@@ -136,10 +141,9 @@ impl M2BatchMaterials<'_> {
                 sub.env_map,
                 ShadeSel::Lit, // unread: every shipped skybox batch is UNLIT (0x01)
                 order,
-                // No texture-transform or colour loop: neither shipped skybox authors one. Wiring
-                // one needs the `M2Model` lane's `Arc`, which the material key identifies it by.
-                None,
-                None,
+                // MONKEY (skybox): the loops' `Arc`s, which the material key identifies them by.
+                uv,
+                tint,
                 None, // M2: no MOBA class, no SIDN, no WINDOW
                 None,
                 false,
@@ -161,6 +165,40 @@ impl M2BatchMaterials<'_> {
         Some(SkyboxBatch { steady, fade_blend })
     }
 
+    /// MONKEY (skybox): the flag `0x4` fog cone's material: an untextured, unlit, two-sided blend
+    /// on the sky lane, its colour the vertex colour times the tint row the skybox lane writes.
+    pub fn sky_fog_cone(&mut self, order: u16) -> Option<Handle<WowModelMaterial>> {
+        let light = self.light.as_ref()?.0.clone();
+        let torch = self.torch.binds()?;
+        Some(model_material(
+            &mut self.cache.0,
+            &mut self.materials,
+            None,
+            ModelBlend::Blend,
+            true,
+            false,
+            false,
+            true, // unlit
+            false,
+            false,
+            true,  // never writes depth
+            false, // …and always tests it
+            benilla_formats::FogPolicy::Off,
+            false,
+            ShadeSel::Lit,
+            order,
+            None,
+            None,
+            None,
+            None,
+            false,
+            true, // the sky lane
+            &light,
+            &torch,
+            None,
+        ))
+    }
+
     /// One steady material lit by a render target's own light buffer (a portrait booth, the model
     /// pane, char-select), which [`super::MatKey::light`] keys apart from the world. `rig` lights
     /// by the scene's authored M2 rig ([`ShadeSel::Rig`]) and plays the UV animation. `order` must
diff --git a/crates/benilla-world/src/skybox.rs b/crates/benilla-world/src/skybox.rs
index d4995c09..c7ab7add 100644
--- a/crates/benilla-world/src/skybox.rs
+++ b/crates/benilla-world/src/skybox.rs
@@ -14,31 +14,88 @@
 //! both moons, gradient band and cloud dome; below it they draw under the sky. The glare quads
 //! draw on their own path (`0x483740` → `0x6d48c0` → `0x7e57e0`), and the fog, ambient and
 //! diffuse are untouched.
+//!
+//! MONKEY (skybox): a third slot, the living player's zone skybox, behind the cvar
+//! `zoneSkyboxes` ([`ZoneSkyboxes`]). The 1.12 engine never draws a `LightParams` skybox for the
+//! living; the modern client does, weighted by the Light sphere falloff
+//! ([`benilla_formats::LightCatalog::zone_skyboxes`]). The backdrop is a weighted list
+//! ([`CameraSkybox`]): ghost > WMO > zone, the WMO sky crossfading the zone list by the modern
+//! collector's rule. `LightSkybox.dbc` flags from the extended table: `0x1` plays sequence 0 over
+//! the game day, `0x2` keeps the celestial pass, `0x4` draws a fog-colour cone over the horizon;
+//! a celestial model draws as a layer under its main model. Every batch animates
+//! ([`crate::skybox_anim`]): bones, texture transforms, colour and alpha tracks.
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
 
 use bevy::asset::RenderAssetUsages;
+use bevy::camera::visibility::NoFrustumCulling;
+use bevy::math::Affine3A;
 use bevy::mesh::{Indices, MeshTag, PrimitiveTopology};
 use bevy::prelude::*;
 
 use crate::model_render::M2BatchMaterials;
+use crate::skybox_anim::{SkyMatLane, SkyRig};
 use crate::view::WorldCamera;
 use benilla_assets::coords::{bevy_to_wow, wow_to_bevy};
 use benilla_assets::materials::WowModelMaterial;
 use benilla_assets::WmoModel;
 use benilla_assets::{LockRecover, WorldAssets};
+use benilla_formats::{SKYBOX_FOG_BLEND, SKYBOX_FULL_DAY, SKYBOX_KEEP_CELESTIAL};
 
 /// The MOGP/MOGI group flag asking for the root's MOSB sky; the loader keeps the MOGP copy in
 /// `WmoGroupNav::flags`.
 const SHOW_SKYBOX: u32 = 0x40000;
 
-/// The skybox model this frame asks for; `None` leaves the [`crate::sky`] gradient dome.
-#[derive(Resource, Default, PartialEq, Eq)]
-pub struct CameraSkybox(pub Option<String>);
+/// MONKEY (skybox): batch-order base of a main model's batches; a celestial layer takes `1..`, so
+/// it draws first, under the main model, and the fog cone takes [`FOG_CONE_ORDER`], last.
+const MAIN_ORDER_BASE: u16 = 24;
+/// MONKEY (skybox): the fog cone's batch order, the band's last distinct step.
+const FOG_CONE_ORDER: u16 = 56;
+
+/// MONKEY (skybox): cvar `zoneSkyboxes` (0/1, default 0): draw the living player's zone skybox
+/// from `LightParams`. Off leaves the reference's two slots only.
+#[derive(Resource, Default, Clone, Copy, PartialEq, Eq, Debug)]
+pub struct ZoneSkyboxes(pub bool);
+
+/// One skybox model the frame asks for, at its weight.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SkyboxLayer {
+    /// The model path, as the slot named it.
+    pub path: String,
+    /// The slot weight, `[0, 1]`; 0 fills the slot without drawing (`0x6d4afe`).
+    pub weight: f32,
+    /// `LightSkybox.dbc` flags, 0 without a row or in the 1.12 table.
+    pub flags: u32,
+    /// The celestial layer of another layer's row, drawn under it.
+    pub celestial: bool,
+}
+
+/// The skybox models this frame asks for; empty leaves the [`crate::sky`] gradient dome.
+#[derive(Resource, Default, PartialEq)]
+pub struct CameraSkybox(pub Vec<SkyboxLayer>);
+
+impl CameraSkybox {
+    /// The heaviest main layer, the one a readout names.
+    pub fn primary(&self) -> Option<&SkyboxLayer> {
+        self.0
+            .iter()
+            .filter(|l| !l.celestial)
+            .fold(None, |best: Option<&SkyboxLayer>, l| match best {
+                Some(b) if b.weight >= l.weight => Some(b),
+                _ => Some(l),
+            })
+    }
+
+    fn layer(&self, path: &str) -> Option<&SkyboxLayer> {
+        self.0.iter().find(|l| l.path == path)
+    }
+}
 
 /// The skybox slot's weight this frame: the interior crossfade [`crate::lighting::WmoCrossfade`]
 /// (±0.25/s, `[0x8115b0]`) for a WMO sky, 1.0 for the ghost sky (`0x6d2260`), and 0 when none
-/// resolves.
+/// resolves. MONKEY (skybox): the heaviest layer that does not keep the celestial pass (flag
+/// `0x2`), so a combining zone sky never stands the procedural sky down.
 #[derive(Resource, Default, PartialEq)]
 pub struct SkyboxWeight(pub f32);
 
@@ -60,22 +117,55 @@ struct SkyboxPart {
     /// The blend-promotion twin for `0 < weight < 1` (`0x811fe0`); `steady` itself when the batch
     /// already blends.
     fade_blend: Handle<WowModelMaterial>,
+    /// MONKEY (skybox): the batch's colour-alpha × transparency loops (`0x707680`).
+    alpha: Option<benilla_formats::AlphaAnim>,
+    /// MONKEY (skybox): the last sampled alpha factor.
+    anim_alpha: f32,
+    /// MONKEY (skybox): the batch's texture-transform and colour rows.
+    lane: SkyMatLane,
+    /// MONKEY (skybox): how the rig moves the batch.
+    pose: PartPose,
 }
 
-/// A batch wholly weighted to one parentless rotation-only bone, so it spins rigidly about the
-/// bone's pivot ([`benilla_formats::BoneSpin`]) with no joint children, which would lag the
-/// post-propagation anchor a frame. Only `CavernsOfTimeSky.m2`'s four asteroid belts spin.
-#[derive(Component)]
-struct SkyboxSpin {
-    /// The bone's pivot, in the same (Bevy) space the batch's vertices were baked into.
-    pivot: Vec3,
-    spin: benilla_formats::BoneSpin,
+/// MONKEY (skybox): how a batch follows its model's rig.
+enum PartPose {
+    /// No moving bone under the batch.
+    Static,
+    /// Wholly weighted to one bone: the bone's matrix is the batch's transform.
+    Rigid(u16),
+    /// Spread over moving bones: skinned on the CPU into its mesh.
+    Skinned {
+        mesh: Handle<Mesh>,
+        base: Vec<Vec3>,
+        joints: Vec<[u16; 4]>,
+        weights: Vec<[f32; 4]>,
+    },
 }
 
+/// MONKEY (skybox): the batch's model-space pose this frame, composed with the eye in
+/// [`follow_camera`].
+#[derive(Component, Default)]
+struct SkyboxLocal(Affine3A);
+
 /// Skybox paths built this session, failed loads included, so a failure is not retried per frame.
 #[derive(Resource, Default)]
 struct BuiltSkyboxes(HashSet<String>);
 
+/// MONKEY (skybox): each built model's rig, by path.
+#[derive(Resource, Default)]
+struct SkyRigs(HashMap<String, Arc<SkyRig>>);
+
+/// MONKEY (skybox): the flag `0x4` fog cone: its entity and its tint row.
+#[derive(Resource, Default)]
+struct FogCone {
+    entity: Option<Entity>,
+    slot: Option<u16>,
+}
+
+/// MONKEY (skybox): marks the fog cone's entity.
+#[derive(Component)]
+struct FogConePart;
+
 /// [`CameraSkybox`] is settled after this set; the dome's gate runs after it, so the two backdrops
 /// agree within a frame.
 #[derive(SystemSet, Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -89,9 +179,17 @@ impl Plugin for SkyboxPlugin {
         app.init_resource::<CameraSkybox>()
             .init_resource::<SkyboxWeight>()
             .init_resource::<BuiltSkyboxes>()
+            .init_resource::<ZoneSkyboxes>()
+            .init_resource::<SkyRigs>()
+            .init_resource::<FogCone>()
             .add_systems(
                 Update,
-                (resolve_camera_skybox, build_skybox, apply_skybox_visibility)
+                (
+                    resolve_camera_skybox,
+                    build_skybox,
+                    animate_skyboxes,
+                    apply_skybox_visibility,
+                )
                     .chain()
                     // After the PVS pass, whose flood this reads the same frame.
                     .after(crate::wmo_portal::WmoPvsSet)
@@ -108,9 +206,49 @@ impl Plugin for SkyboxPlugin {
     }
 }
 
+/// MONKEY (skybox): a path as `model_path` spells it, for comparing a MOSB name with a DBC one.
+fn norm(path: &str) -> String {
+    let lower = path.to_ascii_lowercase();
+    match lower
+        .strip_suffix(".mdx")
+        .or_else(|| lower.strip_suffix(".mdl"))
+    {
+        Some(stem) => format!("{stem}.m2"),
+        None => lower,
+    }
+}
+
+/// MONKEY (skybox): the modern collector's step on layers (`addSkyBox`): the same model keeps the
+/// larger weight and every other layer is scaled by `1 − weight`.
+fn collect_layer(layers: &mut Vec<SkyboxLayer>, path: &str, weight: f32, flags: u32) {
+    let key = norm(path);
+    let at = match layers.iter().position(|l| norm(&l.path) == key) {
+        Some(i) => {
+            layers[i].weight = layers[i].weight.max(weight);
+            i
+        }
+        None => {
+            layers.push(SkyboxLayer {
+                path: path.to_owned(),
+                weight,
+                flags,
+                celestial: false,
+            });
+            layers.len() - 1
+        }
+    };
+    let w = layers[at].weight;
+    for (i, l) in layers.iter_mut().enumerate() {
+        if i != at {
+            l.weight *= 1.0 - w;
+        }
+    }
+}
+
 /// Resolve the wanted skybox and its weight. A WMO sky needs a group of the placement's flood PVS,
 /// not the camera's own group, to carry [`SHOW_SKYBOX`] (`0x6b42e0`, `ebx` the group visited) and
 /// its root to name a MOSB; the weight rides the down-ray claim's crossfade, a separate resolver.
+#[allow(clippy::too_many_arguments)]
 fn resolve_camera_skybox(
     instances: Query<&crate::wmo_portal::WmoPortalInstance>,
     wmos: Res<Assets<WmoModel>>,
@@ -119,71 +257,158 @@ fn resolve_camera_skybox(
     current_map: Option<Res<crate::world_map::CurrentMap>>,
     cam: Query<&GlobalTransform, With<WorldCamera>>,
     crossfade: Res<crate::lighting::WmoCrossfade>,
+    zone: Res<ZoneSkyboxes>,
+    weather: Option<Res<crate::weather::WeatherState>>,
+    eye_liquid: crate::liquid::EyeLiquid,
     mut want: ResMut<CameraSkybox>,
     mut weight: ResMut<SkyboxWeight>,
 ) {
+    let pos = cam.single().ok().map(|t| bevy_to_wow(t.translation()));
+    let map = current_map.as_ref().map_or(0, |m| m.0);
+    let catalog = sampler.as_ref().map(|s| &s.0);
+    let flags_of = |path: &str| {
+        catalog
+            .and_then(|c| c.skybox_def_by_path(&norm(path)))
+            .map_or(0, |d| d.flags)
+    };
+    let mut layers: Vec<SkyboxLayer> = Vec::new();
+
     // The ghost sky first, as its slot skips the WMO one. Resolved from the atmosphere's map and
     // camera position, off the same ghost flag (`PLAYER_FLAGS` 0x10), so the two switch together.
-    if viewer.ghost {
-        let ghost_sky = sampler.as_ref().and_then(|s| {
-            let pos = bevy_to_wow(cam.single().ok()?.translation());
-            let map = current_map.as_ref().map_or(0, |m| m.0);
-            s.0.ghost_skybox(map, pos)
+    let ghost_sky = viewer
+        .ghost
+        .then(|| catalog.zip(pos).and_then(|(c, p)| c.ghost_skybox(map, p)))
+        .flatten();
+    if let Some(sky) = ghost_sky {
+        // The DBC slot's weight is 1.0 whenever filled (`0x6d26cb`/`0x6d26d0`): it pops in.
+        layers.push(SkyboxLayer {
+            path: sky.to_owned(),
+            weight: 1.0,
+            flags: flags_of(sky),
+            celestial: false,
         });
-        if let Some(sky) = ghost_sky {
-            if want.0.as_deref() != Some(sky) {
-                want.0 = Some(sky.to_owned());
+    } else {
+        // MONKEY (skybox): the zone list, under the WMO slot. Hidden submerged, as the celestial
+        // pass is; a storm lerps the storm slot's list over the clear one, as the atmosphere does.
+        if zone.0 && !eye_liquid.submersion().any() {
+            if let (Some(c), Some(p)) = (catalog, pos) {
+                let storm = weather
+                    .as_ref()
+                    .map_or(0.0, |w| crate::weather::storm_blend(w.sky_density));
+                let mut acc: Vec<(u32, f32)> = c
+                    .zone_skyboxes(map, p, false, benilla_formats::Submersion::Dry)
+                    .into_iter()
+                    .map(|e| (e.id, e.weight * (1.0 - storm)))
+                    .collect();
+                if storm > 0.0 {
+                    for e in c.zone_skyboxes(map, p, true, benilla_formats::Submersion::Dry) {
+                        match acc.iter_mut().find(|a| a.0 == e.id) {
+                            Some(a) => a.1 += e.weight * storm,
+                            None => acc.push((e.id, e.weight * storm)),
+                        }
+                    }
+                }
+                for (id, w) in acc {
+                    let Some(def) = c.skybox_def(id) else {
+                        continue;
+                    };
+                    if w <= 0.0 {
+                        continue;
+                    }
+                    match layers.iter_mut().find(|l| norm(&l.path) == def.path) {
+                        Some(l) => l.weight = l.weight.max(w),
+                        None => layers.push(SkyboxLayer {
+                            path: def.path.clone(),
+                            weight: w,
+                            flags: def.flags,
+                            celestial: false,
+                        }),
+                    }
+                }
+            }
+        }
+        // `min()`, not the first match: query order is unstable across frames, and two
+        // overlapping Caverns of Time shells both qualify.
+        let resolved = instances
+            .iter()
+            .filter_map(|inst| {
+                let model = wmos.get(&inst.handle)?;
+                // The MOSB test first: 810 of the game's 815 WMO roots name no skybox.
+                let sky = model.skybox.as_deref()?;
+                model
+                    .group_nav
+                    .iter()
+                    .enumerate()
+                    .any(|(i, nav)| {
+                        // Fail closed, unlike the cull: a lookup miss here would paint a sky over
+                        // the whole world.
+                        nav.flags & SHOW_SKYBOX != 0
+                            && inst.visible.get(i).copied().unwrap_or(false)
+                    })
+                    .then(|| sky.to_owned())
+            })
+            .min();
+        // The WMO slot's weight is the interior crossfade `[0xce9bdc]`; a name seen through a
+        // doorway at weight 0 fills the slot, which `0x6d4afe` declines to draw.
+        if let Some(sky) = resolved {
+            let t = crossfade.t();
+            let flags = flags_of(&sky);
+            if t > 0.0 {
+                collect_layer(&mut layers, &sky, t, flags);
+            } else if !layers.iter().any(|l| norm(&l.path) == norm(&sky)) {
+                layers.push(SkyboxLayer {
+                    path: sky,
+                    weight: 0.0,
+                    flags,
+                    celestial: false,
+                });
             }
-            // The DBC slot's weight is 1.0 whenever filled (`0x6d26cb`/`0x6d26d0`): it pops in.
-            weight.set_if_neq(SkyboxWeight(1.0));
-            return;
         }
     }
-    // `min()`, not the first match: query order is unstable across frames, and two overlapping
-    // Caverns of Time shells both qualify.
-    let resolved = instances
+    // MONKEY (skybox): each row's celestial model, a layer at its main model's weight and flags.
+    let celestial: Vec<SkyboxLayer> = layers
         .iter()
-        .filter_map(|inst| {
-            let model = wmos.get(&inst.handle)?;
-            // The MOSB test first: 810 of the game's 815 WMO roots name no skybox.
-            let sky = model.skybox.as_deref()?;
-            model
-                .group_nav
-                .iter()
-                .enumerate()
-                .any(|(i, nav)| {
-                    // Fail closed, unlike the cull: a lookup miss here would paint a sky over the
-                    // whole world.
-                    nav.flags & SHOW_SKYBOX != 0 && inst.visible.get(i).copied().unwrap_or(false)
-                })
-                .then(|| sky.to_owned())
+        .filter_map(|l| {
+            let path = catalog?
+                .skybox_def_by_path(&norm(&l.path))?
+                .celestial
+                .clone()?;
+            Some(SkyboxLayer {
+                path,
+                weight: l.weight,
+                flags: l.flags,
+                celestial: true,
+            })
         })
-        .min();
-    if want.0 != resolved {
-        want.0 = resolved;
+        .collect();
+    layers.extend(celestial);
+    if want.0 != layers {
+        want.0 = layers;
     }
-    // The WMO slot's weight is the interior crossfade `[0xce9bdc]`; a name seen through a doorway
-    // at weight 0 fills the slot, which `0x6d4afe` declines to draw.
-    weight.set_if_neq(SkyboxWeight(match want.0 {
-        Some(_) => crossfade.t(),
-        None => 0.0,
-    }));
+    let stand_down = want
+        .0
+        .iter()
+        .filter(|l| l.flags & SKYBOX_KEEP_CELESTIAL == 0)
+        .map(|l| l.weight)
+        .fold(0.0, f32::max);
+    weight.set_if_neq(SkyboxWeight(stand_down));
 }
 
-/// Build the wanted skybox on first request; the models are small and few, so it stays built.
+/// Build the wanted skyboxes on first request; the models are small and few, so they stay built.
+#[allow(clippy::too_many_arguments)]
 fn build_skybox(
     mut commands: Commands,
     want: Res<CameraSkybox>,
     mut built: ResMut<BuiltSkyboxes>,
+    mut rigs: ResMut<SkyRigs>,
+    mut cone: ResMut<FogCone>,
     world_assets: Option<ResMut<WorldAssets>>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut images: ResMut<Assets<Image>>,
+    mut table: ResMut<crate::mat_anim_table::MatAnimTable>,
     mut mats: M2BatchMaterials,
 ) {
-    let Some(path) = want.0.as_deref() else {
-        return;
-    };
-    if built.0.contains(path) {
+    if want.0.is_empty() {
         return;
     }
     // Before the shared light buffer exists: retry, without latching `built`.
@@ -193,84 +418,213 @@ fn build_skybox(
     let Some(mut world_assets) = world_assets else {
         return; // assetless run: the gradient dome stays the backdrop
     };
-    // The model's rigid spins by bone; none under a deterministic run, which keeps bind poses.
-    let spins = if crate::dev_state::deterministic_run() {
-        Default::default()
-    } else {
-        benilla_formats::load_m2_bone_spins(&mut world_assets.chain.lock_recover(), path)
-            .unwrap_or_default()
-    };
-    let subs = benilla_formats::load_m2_mesh(&mut world_assets.chain.lock_recover(), path);
-    let subs = match subs {
-        Ok(subs) if !subs.is_empty() => subs,
-        Ok(_) => {
-            warn!("skybox '{path}' has no render batches — keeping the gradient dome");
-            built.0.insert(path.to_string());
-            return;
+    if cone.entity.is_none() && want.0.iter().any(|l| l.flags & SKYBOX_FOG_BLEND != 0) {
+        build_fog_cone(&mut commands, &mut cone, &mut meshes, &mut table, &mut mats);
+    }
+    for layer in &want.0 {
+        let path = layer.path.as_str();
+        if built.0.contains(path) {
+            continue;
         }
-        Err(e) => {
-            warn!("skybox '{path}' failed to load, keeping the gradient dome: {e:#}");
-            built.0.insert(path.to_string());
-            return;
-        }
-    };
-    for (i, sub) in subs.iter().enumerate() {
-        let mut mesh = Mesh::new(
-            PrimitiveTopology::TriangleList,
-            RenderAssetUsages::default(),
-        );
-        let positions: Vec<[f32; 3]> = sub
-            .positions
-            .iter()
-            .map(|p| wow_to_bevy(*p).to_array())
-            .collect();
-        mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
-        // Unread by the unlit sky, but the shared shader's vertex layout needs it.
-        mesh.insert_attribute(
-            Mesh::ATTRIBUTE_NORMAL,
-            sub.normals
-                .iter()
-                .map(|n| wow_to_bevy(*n).to_array())
-                .collect::<Vec<_>>(),
+        // MONKEY (skybox): the rig, off the same bytes the batches come from.
+        let bytes = world_assets
+            .chain
+            .lock_recover()
+            .read_file(&norm(path))
+            .ok();
+        let rig = Arc::new(
+            bytes
+                .as_deref()
+                .map(SkyRig::from_bytes)
+                .unwrap_or_default(),
         );
-        mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, sub.uvs.clone());
-        mesh.insert_indices(Indices::U32(sub.indices.clone()));
-        // The batch's authored address mode: Caverns of Time's belts wrap their UVs.
-        let texture = sub
-            .texture
-            .as_deref()
-            .and_then(|t| world_assets.texture(t, (sub.wrap_x, sub.wrap_y), &mut images));
-        // `i + 1`, the authored batch order (0 is unordered): every batch shares one sort distance.
-        let Some(pair) = mats.skybox(sub, texture, u16::try_from(i + 1).unwrap_or(0)) else {
-            return; // light buffer vanished mid-build; `built` is unlatched, so we retry
+        let subs = benilla_formats::load_m2_mesh(&mut world_assets.chain.lock_recover(), path);
+        let subs = match subs {
+            Ok(subs) if !subs.is_empty() => subs,
+            Ok(_) => {
+                warn!("skybox '{path}' has no render batches — keeping the gradient dome");
+                built.0.insert(path.to_string());
+                continue;
+            }
+            Err(e) => {
+                warn!("skybox '{path}' failed to load, keeping the gradient dome: {e:#}");
+                built.0.insert(path.to_string());
+                continue;
+            }
         };
-        let part = commands
-            .spawn((
-                Mesh3d(meshes.add(mesh)),
-                MeshMaterial3d(pair.steady.clone()),
-                Transform::default(),
-                Visibility::Hidden, // `apply_skybox_visibility` turns on exactly the wanted one
-                // The crossfade's alpha (bits 0..=5), written only by `apply_skybox_visibility`.
-                MeshTag(crate::mesh_tag::spawn_tag(0, 1.0)),
-                SkyboxPart {
-                    path: path.to_string(),
-                    steady: pair.steady,
-                    fade_blend: pair.fade_blend,
+        let base = if layer.celestial { 0 } else { MAIN_ORDER_BASE };
+        for (i, sub) in subs.iter().enumerate() {
+            let mut mesh = Mesh::new(
+                PrimitiveTopology::TriangleList,
+                RenderAssetUsages::default(),
+            );
+            let positions: Vec<Vec3> = sub.positions.iter().map(|p| wow_to_bevy(*p)).collect();
+            mesh.insert_attribute(
+                Mesh::ATTRIBUTE_POSITION,
+                positions.iter().map(|p| p.to_array()).collect::<Vec<_>>(),
+            );
+            // Unread by the unlit sky, but the shared shader's vertex layout needs it.
+            mesh.insert_attribute(
+                Mesh::ATTRIBUTE_NORMAL,
+                sub.normals
+                    .iter()
+                    .map(|n| wow_to_bevy(*n).to_array())
+                    .collect::<Vec<_>>(),
+            );
+            mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, sub.uvs.clone());
+            // MONKEY (skybox): the constant M2Color, when the batch has one that is not white.
+            if sub.vertex_colors.len() == sub.positions.len()
+                && sub
+                    .vertex_colors
+                    .iter()
+                    .any(|c| c.iter().any(|v| (v - 1.0).abs() > 1e-3))
+            {
+                mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, sub.vertex_colors.clone());
+            }
+            mesh.insert_indices(Indices::U32(sub.indices.clone()));
+            // The batch's authored address mode: Caverns of Time's belts wrap their UVs.
+            let texture = sub
+                .texture
+                .as_deref()
+                .and_then(|t| world_assets.texture(t, (sub.wrap_x, sub.wrap_y), &mut images));
+            // MONKEY (skybox): the texture transform and colour loops as material identities.
+            let uv = sub.uv_anim.clone().map(Arc::new);
+            let tint = sub.rgb_anim.clone().map(Arc::new);
+            // The authored batch order after the layer's base (0 is unordered): every batch shares
+            // one sort distance.
+            let order = base + u16::try_from(i + 1).unwrap_or(0);
+            let Some(pair) = mats.skybox(sub, texture, order, uv.as_ref(), tint.as_ref()) else {
+                return; // light buffer vanished mid-build; `built` is unlatched, so we retry
+            };
+            let lane = SkyMatLane::register(
+                sub,
+                uv,
+                tint,
+                &mut table,
+                mats.materials(),
+                &[pair.steady.id(), pair.fade_blend.id()],
+            );
+            let mesh = meshes.add(mesh);
+            let pose = match sole_bone(sub) {
+                Some(b) if rig.bone_moves(b) => PartPose::Rigid(b),
+                Some(_) => PartPose::Static,
+                None if rig.animates() && !sub.joints.is_empty() => PartPose::Skinned {
+                    mesh: mesh.clone(),
+                    base: positions,
+                    joints: sub.joints.clone(),
+                    weights: sub.weights.clone(),
                 },
-            ))
-            .id();
-        if let Some(spin) = sole_bone(sub).and_then(|b| spins.get(&b)) {
-            commands.entity(part).insert(SkyboxSpin {
-                pivot: wow_to_bevy(spin.pivot),
-                spin: spin.clone(),
-            });
+                None => PartPose::Static,
+            };
+            let skinned = matches!(pose, PartPose::Skinned { .. });
+            let part = commands
+                .spawn((
+                    Mesh3d(mesh),
+                    MeshMaterial3d(pair.steady.clone()),
+                    Transform::default(),
+                    Visibility::Hidden, // `apply_skybox_visibility` turns on exactly the wanted one
+                    // The crossfade's alpha (bits 0..=5), written only by `apply_skybox_visibility`.
+                    MeshTag(crate::mesh_tag::spawn_tag(0, 1.0)),
+                    SkyboxLocal::default(),
+                    SkyboxPart {
+                        path: path.to_string(),
+                        steady: pair.steady,
+                        fade_blend: pair.fade_blend,
+                        alpha: sub.alpha_anim.clone(),
+                        anim_alpha: 1.0,
+                        lane,
+                        pose,
+                    },
+                ))
+                .id();
+            if skinned {
+                // The mesh moves under its bounds; the shell surrounds the eye anyway.
+                commands.entity(part).insert(NoFrustumCulling);
+            }
         }
+        rigs.0.insert(path.to_string(), rig);
+        built.0.insert(path.to_string());
     }
-    built.0.insert(path.to_string());
 }
 
-/// The bone every vertex of this batch is wholly weighted to, if any: the batch's half of
-/// [`benilla_formats::BoneSpin`]'s rigid condition.
+/// MONKEY (skybox): the flag `0x4` cone, the modern client's sky-cone draw in the final fog colour
+/// (`skyMesh0x4Sky`): a band around the eye, opaque at and below the horizon, fading out by 24°
+/// of elevation. White vertices carry the alpha; the fog colour rides its tint row.
+fn build_fog_cone(
+    commands: &mut Commands,
+    cone: &mut FogCone,
+    meshes: &mut Assets<Mesh>,
+    table: &mut crate::mat_anim_table::MatAnimTable,
+    mats: &mut M2BatchMaterials,
+) {
+    const SEGMENTS: usize = 32;
+    const RADIUS: f32 = 40.0;
+    // (elevation degrees, alpha), bottom to top.
+    const RINGS: [(f32, f32); 7] = [
+        (-60.0, 1.0),
+        (0.0, 1.0),
+        (4.0, 0.85),
+        (8.0, 0.6),
+        (12.0, 0.35),
+        (18.0, 0.12),
+        (24.0, 0.0),
+    ];
+    let mut positions = Vec::new();
+    let mut colors = Vec::new();
+    for (elev, alpha) in RINGS {
+        let (se, ce) = elev.to_radians().sin_cos();
+        for s in 0..=SEGMENTS {
+            let az = s as f32 / SEGMENTS as f32 * std::f32::consts::TAU;
+            positions.push([RADIUS * ce * az.cos(), RADIUS * se, RADIUS * ce * az.sin()]);
+            colors.push([1.0, 1.0, 1.0, alpha]);
+        }
+    }
+    let row = SEGMENTS as u32 + 1;
+    let mut indices = Vec::new();
+    for r in 0..(RINGS.len() as u32 - 1) {
+        for s in 0..SEGMENTS as u32 {
+            let a = r * row + s;
+            let b = a + row;
+            indices.extend_from_slice(&[a, b, a + 1, a + 1, b, b + 1]);
+        }
+    }
+    let n = positions.len();
+    let mut mesh = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    );
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+    mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 1.0, 0.0]; n]);
+    mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, vec![[0.0, 0.0]; n]);
+    mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, colors);
+    mesh.insert_indices(Indices::U32(indices));
+    let Some(material) = mats.sky_fog_cone(FOG_CONE_ORDER) else {
+        return;
+    };
+    let slot = table.alloc();
+    if let Some(slot) = slot {
+        crate::model_render::lazy::with_material_mut(mats.materials(), material.id(), |m| {
+            m.extension.anim_slots.y = f32::from(slot);
+        });
+    }
+    let entity = commands
+        .spawn((
+            Mesh3d(meshes.add(mesh)),
+            MeshMaterial3d(material),
+            Transform::default(),
+            Visibility::Hidden,
+            MeshTag(crate::mesh_tag::spawn_tag(0, 1.0)),
+            SkyboxLocal::default(),
+            FogConePart,
+            NoFrustumCulling,
+        ))
+        .id();
+    cone.entity = Some(entity);
+    cone.slot = slot;
+}
+
+/// The bone every vertex of this batch is wholly weighted to, if any: a rigid batch takes the
+/// bone's matrix whole, with no skinning.
 fn sole_bone(sub: &benilla_formats::RenderSubmesh) -> Option<u16> {
     let bone = sub.joints.first()?[0];
     (sub.weights.len() == sub.joints.len()
@@ -283,22 +637,145 @@ fn sole_bone(sub: &benilla_formats::RenderSubmesh) -> Option<u16> {
     .then_some(bone)
 }
 
-/// Show the wanted skybox at the slot weight and hide every other, the sole `Visibility`, material
-/// and `MeshTag` writer for these entities. As the reference: hidden at weight 0 (`0x6d4afe`), the
-/// weight in every batch's alpha (`0x710cb0` → `[CM2Model+0x180]`), and below 1 the batch
-/// promoted to SRC_ALPHA blending whatever its mode (`0x811fe0`).
+/// MONKEY (skybox): one model's clock and pose this frame.
+struct ModelClock {
+    band_t: f32,
+    gseq: f64,
+    live: bool,
+    pose: Vec<Affine3A>,
+}
+
+/// MONKEY (skybox): pose every shown skybox and run its material loops on the model's clock:
+/// sequence 0 at `duration × day fraction` under flag `0x1`, else the scene clock. A capture keeps
+/// the bind pose and the seeds, as the shared lanes freeze, unless the day drives the clock.
+#[allow(clippy::too_many_arguments)]
+fn animate_skyboxes(
+    time: Res<Time>,
+    clock: Res<crate::lighting::GameClock>,
+    want: Res<CameraSkybox>,
+    rigs: Res<SkyRigs>,
+    mut table: ResMut<crate::mat_anim_table::MatAnimTable>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut parts: Query<(&mut SkyboxPart, &mut SkyboxLocal)>,
+    mut clocks: Local<HashMap<String, ModelClock>>,
+) {
+    if want.0.is_empty() {
+        return;
+    }
+    let deterministic = crate::dev_state::deterministic_run();
+    let now = time.elapsed_secs();
+    let day = clock.minute.min(1439) as f32 / 1440.0;
+    clocks.clear();
+    for layer in want.0.iter().filter(|l| l.weight > 0.0) {
+        let Some(rig) = rigs.0.get(&layer.path) else {
+            continue;
+        };
+        let (band_t, gseq, live) = if layer.flags & SKYBOX_FULL_DAY != 0 {
+            let g = if deterministic { 0.0 } else { f64::from(now) };
+            (rig.duration * day, g, true)
+        } else if deterministic {
+            (0.0, 0.0, false)
+        } else {
+            (now, f64::from(now), true)
+        };
+        let pose = if live && rig.animates() {
+            rig.pose(rig.band_time(band_t), gseq)
+        } else {
+            Vec::new()
+        };
+        clocks.insert(
+            layer.path.clone(),
+            ModelClock {
+                band_t,
+                gseq,
+                live,
+                pose,
+            },
+        );
+    }
+    for (mut part, mut local) in &mut parts {
+        let Some(c) = clocks.get(&part.path) else {
+            continue;
+        };
+        let seq = rigs.0.get(&part.path).and_then(|r| r.seq_slot);
+        let a = part
+            .alpha
+            .as_ref()
+            .map_or(1.0, |a| a.sample(seq, c.band_t, c.gseq).clamp(0.0, 1.0));
+        if part.anim_alpha != a {
+            part.anim_alpha = a;
+        }
+        if c.live && part.lane.any() {
+            part.lane.tick(c.band_t, c.gseq, &mut table);
+        }
+        let bone = |b: u16| {
+            c.pose
+                .get(usize::from(b))
+                .copied()
+                .unwrap_or(Affine3A::IDENTITY)
+        };
+        match &part.pose {
+            PartPose::Static => {}
+            PartPose::Rigid(b) => {
+                let m = bone(*b);
+                if local.0 != m {
+                    local.0 = m;
+                }
+            }
+            PartPose::Skinned {
+                mesh,
+                base,
+                joints,
+                weights,
+            } => {
+                if c.pose.is_empty() {
+                    continue;
+                }
+                let skinned: Vec<[f32; 3]> = base
+                    .iter()
+                    .zip(joints.iter().zip(weights))
+                    .map(|(p, (j, w))| {
+                        let mut out = Vec3::ZERO;
+                        for k in 0..4 {
+                            if w[k] > 0.0 {
+                                out += bone(j[k]).transform_point3(*p) * w[k];
+                            }
+                        }
+                        out.to_array()
+                    })
+                    .collect();
+                if let Some(m) = meshes.get_mut(mesh) {
+                    m.insert_attribute(Mesh::ATTRIBUTE_POSITION, skinned);
+                }
+            }
+        }
+    }
+}
+
+/// Show the wanted skyboxes at their layer weights and hide every other, the sole `Visibility`,
+/// material and `MeshTag` writer for these entities. As the reference: hidden at weight 0
+/// (`0x6d4afe`), the weight in every batch's alpha (`0x710cb0` → `[CM2Model+0x180]`), and below 1
+/// the batch promoted to SRC_ALPHA blending whatever its mode (`0x811fe0`). MONKEY (skybox): the
+/// weight carries the batch's alpha tracks too, and a layer that keeps the celestial pass draws
+/// its batches blended, so they sort over the procedural sky as the modern client orders them.
+#[allow(clippy::type_complexity)]
 fn apply_skybox_visibility(
     want: Res<CameraSkybox>,
-    weight: Res<SkyboxWeight>,
+    lighting: Res<crate::lighting::WowLighting>,
+    cone: Res<FogCone>,
+    mut table: ResMut<crate::mat_anim_table::MatAnimTable>,
     mut parts: Query<(
         &SkyboxPart,
         &mut Visibility,
         &mut MeshMaterial3d<WowModelMaterial>,
         &mut MeshTag,
     )>,
+    mut cones: Query<(&mut Visibility, &mut MeshTag), (With<FogConePart>, Without<SkyboxPart>)>,
 ) {
     for (part, mut vis, mut mat, mut tag) in &mut parts {
-        let show = weight.0 > 0.0 && want.0.as_deref() == Some(part.path.as_str());
+        let layer = want.layer(&part.path);
+        let w = layer.map_or(0.0, |l| l.weight) * part.anim_alpha;
+        let show = w > 0.0;
         let target = if show {
             Visibility::Visible
         } else {
@@ -310,7 +787,8 @@ fn apply_skybox_visibility(
         if !show {
             continue;
         }
-        let handle = if weight.0 < 1.0 {
+        let keep = layer.is_some_and(|l| l.flags & SKYBOX_KEEP_CELESTIAL != 0);
+        let handle = if w < 1.0 || keep {
             &part.fade_blend
         } else {
             &part.steady
@@ -318,44 +796,62 @@ fn apply_skybox_visibility(
         if mat.0 != *handle {
             mat.0 = handle.clone();
         }
-        let bits = crate::mesh_tag::with_alpha(tag.0, weight.0);
+        let bits = crate::mesh_tag::with_alpha(tag.0, w);
         if tag.0 != bits {
             tag.0 = bits;
         }
     }
+    // MONKEY (skybox): the fog cone at the heaviest fog-blending layer's weight, in the fog colour.
+    let Some(entity) = cone.entity else {
+        return;
+    };
+    let w = want
+        .0
+        .iter()
+        .filter(|l| l.flags & SKYBOX_FOG_BLEND != 0 && !l.celestial)
+        .map(|l| l.weight)
+        .fold(0.0, f32::max);
+    if let Ok((mut vis, mut tag)) = cones.get_mut(entity) {
+        let target = if w > 0.0 {
+            Visibility::Visible
+        } else {
+            Visibility::Hidden
+        };
+        if *vis != target {
+            *vis = target;
+        }
+        let bits = crate::mesh_tag::with_alpha(tag.0, w);
+        if tag.0 != bits {
+            tag.0 = bits;
+        }
+    }
+    if let (Some(slot), true) = (cone.slot, w > 0.0) {
+        let c = benilla_assets::quant255(lighting.fog_color);
+        table.set(slot, [c[0] - 1.0, c[1] - 1.0, c[2] - 1.0, 0.0]);
+    }
 }
 
 /// Pin the box to the camera, world-aligned and at authored scale, the model's origin at the eye as
 /// the reference places it (`0x707680` given a zeroed recentre vector, `0x6d4b3a`–`0x6d4b48`):
-/// `StratholmeSkybox` is authored off-centre, so recentring it would be wrong. A spinning batch
-/// turns about its bone's pivot inside the anchor, `T(eye) · T(pivot) · R(t) · T(−pivot)`, on the
-/// scene clock; the reference's phase starts at load, which a 66.7 s ring does not show.
+/// `StratholmeSkybox` is authored off-centre, so recentring it would be wrong. MONKEY (skybox): a
+/// posed batch rides its bone's matrix inside the anchor, `T(eye) · M(bone)`.
 #[allow(clippy::type_complexity)]
 fn follow_camera(
-    time: Res<Time>,
     cam: Query<&GlobalTransform, With<WorldCamera>>,
     mut parts: Query<
-        (&mut Transform, &mut GlobalTransform, Option<&SkyboxSpin>),
-        (With<SkyboxPart>, Without<WorldCamera>),
+        (&mut Transform, &mut GlobalTransform, &SkyboxLocal),
+        Without<WorldCamera>,
     >,
 ) {
     let Some(cam_gt) = cam.iter().next() else {
         return;
     };
-    let now = time.elapsed_secs();
-    for (mut tf, mut gt, spin) in &mut parts {
-        let (rot, pivot) = match spin {
-            Some(s) => (
-                benilla_assets::coords::wow_rotation_to_bevy(s.spin.sample(now)),
-                s.pivot,
-            ),
-            None => (Quat::IDENTITY, Vec3::ZERO),
-        };
-        tf.translation = cam_gt.translation() + pivot - rot * pivot;
-        tf.rotation = rot;
-        tf.scale = Vec3::ONE;
+    let eye = cam_gt.translation();
+    for (mut tf, mut gt, local) in &mut parts {
+        let m = Affine3A::from_translation(eye) * local.0;
+        *tf = Transform::from_matrix(m.into());
         // Propagation already ran this frame: the direct global write is what renders.
-        *gt = GlobalTransform::from(*tf);
+        *gt = GlobalTransform::from(m);
     }
 }
 
@@ -365,12 +861,13 @@ mod tests {
 
     /// On the real art: the seventeen other batches are wholly on bone 0, which has no track.
     #[test]
-    fn only_the_belt_batches_of_the_caverns_sky_resolve_to_a_spinning_bone() {
+    fn only_the_belt_batches_of_the_caverns_sky_resolve_to_a_moving_bone() {
         let data = benilla_formats::wow_data_or_skip!();
         let mut chain = benilla_formats::Chain::open(&data).expect("open vanilla patch chain");
         const SKY: &str = "Environments\\Stars\\CavernsOfTimeSky.m2";
         let subs = benilla_formats::load_m2_mesh(&mut chain, SKY).expect("load the sky");
-        let spins = benilla_formats::load_m2_bone_spins(&mut chain, SKY).expect("its spins");
+        let bytes = chain.read_file(SKY).expect("read the sky");
+        let rig = SkyRig::from_bytes(&bytes);
 
         let bones: Vec<Option<u16>> = subs.iter().map(sole_bone).collect();
         assert_eq!(bones.len(), 21, "21 authored batches");
@@ -388,11 +885,41 @@ mod tests {
                 .all(|(_, b)| *b == Some(0)),
             "every non-belt batch is wholly on bone 0: {bones:?}"
         );
-
-        let spinning = bones
+        let moving = bones
             .iter()
-            .filter(|b| b.and_then(|b| spins.get(&b)).is_some())
+            .filter(|b| b.is_some_and(|b| rig.bone_moves(b)))
             .count();
-        assert_eq!(spinning, 4, "exactly the four belt batches turn");
+        assert_eq!(moving, 4, "exactly the four belt batches turn");
+    }
+
+    fn layer(path: &str, weight: f32) -> SkyboxLayer {
+        SkyboxLayer {
+            path: path.into(),
+            weight,
+            flags: 0,
+            celestial: false,
+        }
+    }
+
+    #[test]
+    fn a_wmo_sky_crossfades_the_zone_sky() {
+        let mut layers = vec![layer("a.m2", 1.0)];
+        collect_layer(&mut layers, "B.MDX", 0.25, 0);
+        assert!((layers[0].weight - 0.75).abs() < 1e-6);
+        assert!((layers[1].weight - 0.25).abs() < 1e-6);
+        // The same model under another spelling merges.
+        collect_layer(&mut layers, "b.m2", 1.0, 0);
+        assert_eq!(layers.len(), 2);
+        assert_eq!(layers[0].weight, 0.0);
+    }
+
+    #[test]
+    fn the_primary_layer_is_the_heaviest_main_one() {
+        let mut sky = CameraSkybox(vec![layer("a", 0.4), layer("b", 0.6)]);
+        sky.0.push(SkyboxLayer {
+            celestial: true,
+            ..layer("c", 1.0)
+        });
+        assert_eq!(sky.primary().map(|l| l.path.as_str()), Some("b"));
     }
 }
diff --git a/crates/benilla-world/src/skybox_anim.rs b/crates/benilla-world/src/skybox_anim.rs
new file mode 100644
index 00000000..9f835f40
--- /dev/null
+++ b/crates/benilla-world/src/skybox_anim.rs
@@ -0,0 +1,527 @@
+//! MONKEY (skybox): the animated half of the skybox lane. A skybox draws camera-anchored at the far
+//! depth ([`crate::skybox`]), so it cannot ride the joint-entity rig: its anchor is written after
+//! transform propagation. Its bones are posed here on the CPU instead, each frame, from the armed
+//! sequence (animation id 0) and the global sequences, as `0x714260` composes them:
+//! `M = parent · T(pivot) · T(t) · R(q) · S(s) · T(−pivot)`. A batch wholly on one bone takes that
+//! bone's matrix as its transform; a batch spread over several moving bones is skinned on the CPU
+//! (skyboxes are a few thousand vertices).
+//!
+//! Its texture-transform, colour and alpha tracks run on the same clock through the shared
+//! mat-anim table ([`crate::mat_anim_table`]), in rows this module owns, so a skybox flagged
+//! `0x1` (sequence 0 across the game day) drives every channel from the day fraction.
+
+use std::sync::Arc;
+
+use bevy::math::Affine3A;
+use bevy::prelude::*;
+
+use benilla_assets::coords::{wow_rotation_to_bevy, wow_to_bevy};
+
+/// A key list for one channel: `(seconds, value)` time-ascending, and whether it interpolates.
+#[derive(Clone, Debug, Default)]
+struct Channel<V> {
+    keys: Vec<(f32, V)>,
+    linear: bool,
+}
+
+impl<V: Copy> Channel<V> {
+    /// The value at `t` (seconds inside the channel's own span): held before the first key and past
+    /// the last, stepped or blended between, as the reference's key search clamps.
+    fn sample(&self, t: f32, blend: impl Fn(V, V, f32) -> V) -> Option<V> {
+        let (&(t0, v0), rest) = self.keys.split_first()?;
+        if rest.is_empty() || t <= t0 {
+            return Some(v0);
+        }
+        let mut k = 0;
+        while k + 1 < self.keys.len() && self.keys[k + 1].0 <= t {
+            k += 1;
+        }
+        let (ta, va) = self.keys[k];
+        if !self.linear || k + 1 >= self.keys.len() {
+            return Some(va);
+        }
+        let (tb, vb) = self.keys[k + 1];
+        let f = if tb > ta { (t - ta) / (tb - ta) } else { 0.0 };
+        Some(blend(va, vb, f))
+    }
+}
+
+/// A global-sequence channel: keys in seconds over `period`, sampled at the free clock mod it.
+#[derive(Clone, Debug, Default)]
+struct GlobalChannel<V> {
+    period: f32,
+    channel: Channel<V>,
+}
+
+/// One bone's channels, Bevy space. A global-sequence channel replaces the sequence one.
+#[derive(Clone, Debug, Default)]
+struct BoneTracks {
+    translation: Channel<Vec3>,
+    rotation: Channel<Quat>,
+    scale: Channel<Vec3>,
+    g_translation: Option<GlobalChannel<Vec3>>,
+    g_rotation: Option<GlobalChannel<Quat>>,
+    g_scale: Option<GlobalChannel<Vec3>>,
+}
+
+impl BoneTracks {
+    fn moves(&self) -> bool {
+        !self.translation.keys.is_empty()
+            || !self.rotation.keys.is_empty()
+            || !self.scale.keys.is_empty()
+            || self.g_translation.is_some()
+            || self.g_rotation.is_some()
+            || self.g_scale.is_some()
+    }
+}
+
+/// A skybox model's rig: the bone tree and the armed sequence's tracks, Bevy space.
+#[derive(Debug, Default)]
+pub(crate) struct SkyRig {
+    parents: Vec<i16>,
+    pivots: Vec<Vec3>,
+    tracks: Vec<BoneTracks>,
+    /// The armed sequence's length in seconds and its file slot (the alpha bake's slot index).
+    pub(crate) duration: f32,
+    pub(crate) seq_slot: Option<usize>,
+    looping: bool,
+}
+
+fn lerp3(a: Vec3, b: Vec3, f: f32) -> Vec3 {
+    a.lerp(b, f)
+}
+
+fn slerp(a: Quat, b: Quat, f: f32) -> Quat {
+    a.slerp(b, f)
+}
+
+/// The interpolation flag of the `M2Track` at `track` (`interp_type != 0`), linear when unreadable.
+fn track_linear(bytes: &[u8], track: usize) -> bool {
+    bytes
+        .get(track..track + 2)
+        .is_none_or(|b| u16::from_le_bytes([b[0], b[1]]) != 0)
+}
+
+/// WoW-space scale to Bevy space: [`wow_to_bevy`] permutes the axes, so a scale permutes too.
+fn scale_to_bevy(s: [f32; 3]) -> Vec3 {
+    Vec3::new(s[1], s[2], s[0])
+}
+
+impl SkyRig {
+    /// Parse the rig out of the model bytes; an unparsable or boneless model has an empty rig.
+    pub(crate) fn from_bytes(bytes: &[u8]) -> Self {
+        let Ok(skeleton) = benilla_formats::parse_m2_skeleton(bytes) else {
+            return Self::default();
+        };
+        let n = skeleton.bones.len();
+        let mut rig = SkyRig {
+            parents: skeleton.bones.iter().map(|b| b.parent).collect(),
+            pivots: skeleton.bones.iter().map(|b| wow_to_bevy(b.pivot)).collect(),
+            tracks: vec![BoneTracks::default(); n],
+            duration: 0.0,
+            seq_slot: None,
+            looping: true,
+        };
+        let bone_ofs = bytes
+            .get(0x38..0x3c)
+            .map_or(0, |b| u32::from_le_bytes([b[0], b[1], b[2], b[3]]) as usize);
+        let rec = |i: usize| bone_ofs + i * 0x6c;
+        // The armed sequence: animation id 0 (`0x70ebd0`), else the file's first.
+        let anims = benilla_formats::parse_m2_animations(bytes);
+        if let Some(seq) = anims
+            .iter()
+            .find(|a| a.anim_id == 0)
+            .or_else(|| anims.first())
+        {
+            rig.duration = seq.duration;
+            rig.seq_slot = Some(seq.seq_index);
+            rig.looping = seq.looping;
+            for keys in &seq.bones {
+                let i = usize::from(keys.bone);
+                let Some(t) = rig.tracks.get_mut(i) else {
+                    continue;
+                };
+                t.translation = Channel {
+                    keys: keys
+                        .translation
+                        .iter()
+                        .map(|&(s, v)| (s, wow_to_bevy(v)))
+                        .collect(),
+                    linear: track_linear(bytes, rec(i) + 0x0c),
+                };
+                t.rotation = Channel {
+                    keys: keys
+                        .rotation
+                        .iter()
+                        .map(|&(s, q)| (s, wow_rotation_to_bevy(q)))
+                        .collect(),
+                    linear: track_linear(bytes, rec(i) + 0x28),
+                };
+                t.scale = Channel {
+                    keys: keys
+                        .scale
+                        .iter()
+                        .map(|&(s, v)| (s, scale_to_bevy(v)))
+                        .collect(),
+                    linear: track_linear(bytes, rec(i) + 0x44),
+                };
+            }
+        }
+        fn global<T, V>(
+            c: &Option<benilla_formats::GlobalSeqChannel<T>>,
+            linear: bool,
+            conv: impl Fn(T) -> V,
+        ) -> Option<GlobalChannel<V>>
+        where
+            T: Copy,
+        {
+            let c = c.as_ref()?;
+            Some(GlobalChannel {
+                period: c.period_ms as f32 / 1000.0,
+                channel: Channel {
+                    keys: c
+                        .keys
+                        .iter()
+                        .map(|&(ms, v)| (ms as f32 / 1000.0, conv(v)))
+                        .collect(),
+                    linear,
+                },
+            })
+        }
+        for g in benilla_formats::parse_m2_global_sequence_bones(bytes) {
+            let i = usize::from(g.bone);
+            let Some(t) = rig.tracks.get_mut(i) else {
+                continue;
+            };
+            t.g_translation = global(&g.translation, track_linear(bytes, rec(i) + 0x0c), |v| {
+                wow_to_bevy(v)
+            });
+            t.g_rotation = global(&g.rotation, track_linear(bytes, rec(i) + 0x28), |q| {
+                wow_rotation_to_bevy(q)
+            });
+            t.g_scale = global(&g.scale, track_linear(bytes, rec(i) + 0x44), scale_to_bevy);
+        }
+        rig
+    }
+
+    /// Whether any bone has a channel, i.e. posing can move a vertex.
+    pub(crate) fn animates(&self) -> bool {
+        self.tracks.iter().any(BoneTracks::moves)
+    }
+
+    /// Whether `bone` or any bone above it has a channel.
+    pub(crate) fn bone_moves(&self, bone: u16) -> bool {
+        let mut i = usize::from(bone);
+        for _ in 0..=self.parents.len() {
+            let Some(t) = self.tracks.get(i) else {
+                return false;
+            };
+            if t.moves() {
+                return true;
+            }
+            match usize::try_from(self.parents[i]) {
+                Ok(p) => i = p,
+                Err(_) => return false,
+            }
+        }
+        false
+    }
+
+    /// The sequence clock for `t` seconds on the scene or day clock: wrapped for a looping
+    /// sequence, clamped for a one-shot, as the band bake does.
+    pub(crate) fn band_time(&self, t: f32) -> f32 {
+        if self.duration <= 0.0 {
+            0.0
+        } else if self.looping {
+            t.rem_euclid(self.duration)
+        } else {
+            t.clamp(0.0, self.duration)
+        }
+    }
+
+    /// Every bone's model-space matrix at band time `band_t` and free clock `gseq_now` seconds.
+    pub(crate) fn pose(&self, band_t: f32, gseq_now: f64) -> Vec<Affine3A> {
+        let n = self.parents.len();
+        let mut out: Vec<Option<Affine3A>> = vec![None; n];
+        for i in 0..n {
+            self.resolve(i, band_t, gseq_now, &mut out, 0);
+        }
+        out.into_iter()
+            .map(|m| m.unwrap_or(Affine3A::IDENTITY))
+            .collect()
+    }
+
+    fn resolve(
+        &self,
+        i: usize,
+        band_t: f32,
+        gseq_now: f64,
+        out: &mut Vec<Option<Affine3A>>,
+        depth: usize,
+    ) -> Affine3A {
+        if let Some(m) = out[i] {
+            return m;
+        }
+        let local = self.local(i, band_t, gseq_now);
+        // Bounded by the bone count: the guard against a malformed parent cycle.
+        let m = match usize::try_from(self.parents[i]) {
+            Ok(p) if p < out.len() && p != i && depth < out.len() => {
+                self.resolve(p, band_t, gseq_now, out, depth + 1) * local
+            }
+            _ => local,
+        };
+        out[i] = Some(m);
+        m
+    }
+
+    fn local(&self, i: usize, band_t: f32, gseq_now: f64) -> Affine3A {
+        let t = &self.tracks[i];
+        if !t.moves() {
+            return Affine3A::IDENTITY;
+        }
+        fn at<V: Copy>(
+            g: &Option<GlobalChannel<V>>,
+            c: &Channel<V>,
+            band_t: f32,
+            gseq_now: f64,
+            blend: impl Fn(V, V, f32) -> V,
+        ) -> Option<V> {
+            match g {
+                Some(g) if g.period > 0.0 => {
+                    let tt = (gseq_now % f64::from(g.period)) as f32;
+                    g.channel.sample(tt, blend)
+                }
+                _ => c.sample(band_t, blend),
+            }
+        }
+        let tr = at(&t.g_translation, &t.translation, band_t, gseq_now, lerp3).unwrap_or(Vec3::ZERO);
+        let rot = at(&t.g_rotation, &t.rotation, band_t, gseq_now, slerp)
+            .unwrap_or(Quat::IDENTITY)
+            .normalize();
+        let sc = at(&t.g_scale, &t.scale, band_t, gseq_now, lerp3).unwrap_or(Vec3::ONE);
+        let pivot = self.pivots[i];
+        Affine3A::from_translation(pivot + tr)
+            * Affine3A::from_scale_rotation_translation(sc, rot, Vec3::ZERO)
+            * Affine3A::from_translation(-pivot)
+    }
+}
+
+/// The mat-anim rows a skybox batch owns: its texture transform (translation row, and an affine
+/// row for rotation/scale) and its colour track, each seeded at `t = 0` like the shared lane.
+#[derive(Default)]
+pub(crate) struct SkyMatLane {
+    pub(crate) uv: Option<(u16, [f32; 2], Arc<benilla_formats::UvAnim>)>,
+    pub(crate) affine: Option<(u16, AffineLoops)>,
+    pub(crate) tint: Option<(u16, [f32; 3], Arc<benilla_formats::RgbAnim>)>,
+}
+
+/// The rotation and scaling channels of a texture transform, slot 0's loops.
+pub(crate) struct AffineLoops {
+    pub(crate) rot: Option<benilla_formats::KeyAnim<[f32; 4]>>,
+    pub(crate) scale: Option<benilla_formats::KeyAnim<[f32; 2]>>,
+}
+
+impl SkyMatLane {
+    /// Allocate the rows for a batch and write their slots into every material it draws with
+    /// (`anim_slots.x` UV, `.y` tint, `.z` affine). A full table leaves the batch at its seed.
+    pub(crate) fn register(
+        sub: &benilla_formats::RenderSubmesh,
+        uv: Option<Arc<benilla_formats::UvAnim>>,
+        tint: Option<Arc<benilla_formats::RgbAnim>>,
+        table: &mut crate::mat_anim_table::MatAnimTable,
+        materials: &mut Assets<benilla_assets::materials::WowModelMaterial>,
+        mats: &[AssetId<benilla_assets::materials::WowModelMaterial>],
+    ) -> Self {
+        let mut lane = SkyMatLane::default();
+        let write = |materials: &mut Assets<benilla_assets::materials::WowModelMaterial>,
+                     f: &dyn Fn(&mut benilla_assets::materials::WowModelMaterial)| {
+            for id in mats {
+                crate::model_render::lazy::with_material_mut(materials, *id, |m| f(m));
+            }
+        };
+        if let Some(uv) = uv.filter(|a| a.period > 0.0) {
+            if let Some(slot) = table.alloc() {
+                let seed = mats
+                    .first()
+                    .and_then(|id| {
+                        crate::model_render::lazy::with_material_mut(materials, *id, |m| {
+                            [m.extension.sun_scale.z, m.extension.sun_scale.w]
+                        })
+                    })
+                    .unwrap_or([0.0, 0.0]);
+                write(materials, &|m| m.extension.anim_slots.x = f32::from(slot));
+                lane.uv = Some((slot, seed, uv));
+            }
+        }
+        let rot = sub
+            .uv_rot_seq
+            .as_ref()
+            .and_then(|s| s.seq(None))
+            .cloned();
+        let scale = sub
+            .uv_scale_seq
+            .as_ref()
+            .and_then(|s| s.seq(None))
+            .cloned();
+        if rot.is_some() || scale.is_some() {
+            if let Some(slot) = table.alloc() {
+                write(materials, &|m| m.extension.anim_slots.z = f32::from(slot));
+                lane.affine = Some((slot, AffineLoops { rot, scale }));
+            }
+        }
+        if let Some(tint) = tint {
+            if let Some(slot) = table.alloc() {
+                let seed = mats
+                    .first()
+                    .and_then(|id| {
+                        crate::model_render::lazy::with_material_mut(materials, *id, |m| {
+                            [m.extension.tint.x, m.extension.tint.y, m.extension.tint.z]
+                        })
+                    })
+                    .unwrap_or([1.0, 1.0, 1.0]);
+                write(materials, &|m| m.extension.anim_slots.y = f32::from(slot));
+                lane.tint = Some((slot, seed, tint));
+            }
+        }
+        lane
+    }
+
+    pub(crate) fn any(&self) -> bool {
+        self.uv.is_some() || self.affine.is_some() || self.tint.is_some()
+    }
+
+    /// Write this frame's rows: the delta from each seed, quantized as the shared lane does.
+    pub(crate) fn tick(
+        &self,
+        band_t: f32,
+        gseq_now: f64,
+        table: &mut crate::mat_anim_table::MatAnimTable,
+    ) {
+        if let Some((slot, seed, a)) = &self.uv {
+            let v = a.sample(a.clock(band_t, gseq_now));
+            table.set(
+                *slot,
+                [
+                    benilla_assets::quantize(v[0], 4096.0) - seed[0],
+                    benilla_assets::quantize(v[1], 4096.0) - seed[1],
+                    0.0,
+                    0.0,
+                ],
+            );
+        }
+        if let Some((slot, loops)) = &self.affine {
+            let q = loops
+                .rot
+                .as_ref()
+                .map_or([0.0, 0.0, 0.0, 1.0], |l| l.sample(l.clock(band_t, gseq_now)));
+            let s = loops
+                .scale
+                .as_ref()
+                .map_or([1.0, 1.0], |l| l.sample(l.clock(band_t, gseq_now)));
+            table.set(*slot, crate::mat_anim_table::affine_row(q, s));
+        }
+        if let Some((slot, seed, a)) = &self.tint {
+            let c = benilla_assets::quant255(a.sample(a.clock(band_t, gseq_now)));
+            table.set(
+                *slot,
+                [c[0] - seed[0], c[1] - seed[1], c[2] - seed[2], 0.0],
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn spin_rig() -> SkyRig {
+        // One parentless bone at pivot (1,0,0) turning about +Y over 4 s, linear.
+        SkyRig {
+            parents: vec![-1],
+            pivots: vec![Vec3::X],
+            tracks: vec![BoneTracks {
+                rotation: Channel {
+                    keys: vec![
+                        (0.0, Quat::IDENTITY),
+                        (4.0, Quat::from_rotation_y(std::f32::consts::PI)),
+                    ],
+                    linear: true,
+                },
+                ..Default::default()
+            }],
+            duration: 4.0,
+            seq_slot: Some(0),
+            looping: true,
+        }
+    }
+
+    #[test]
+    fn a_bone_turns_about_its_pivot() {
+        let rig = spin_rig();
+        let m = rig.pose(rig.band_time(4.0 + 2.0), 0.0)[0];
+        // Half way: a quarter turn about the pivot; the pivot itself stays put.
+        assert!(m.transform_point3(Vec3::X).abs_diff_eq(Vec3::X, 1e-5));
+        let p = m.transform_point3(Vec3::new(2.0, 0.0, 0.0));
+        assert!(p.abs_diff_eq(Vec3::new(1.0, 0.0, -1.0), 1e-5), "{p}");
+    }
+
+    #[test]
+    fn a_child_composes_onto_its_parent() {
+        let mut rig = spin_rig();
+        rig.parents.push(0);
+        rig.pivots.push(Vec3::new(2.0, 0.0, 0.0));
+        rig.tracks.push(BoneTracks {
+            translation: Channel {
+                keys: vec![(0.0, Vec3::Y)],
+                linear: true,
+            },
+            ..Default::default()
+        });
+        let pose = rig.pose(2.0, 0.0);
+        let p = pose[1].transform_point3(Vec3::new(2.0, 0.0, 0.0));
+        // Lifted by the child, then turned a quarter by the parent.
+        assert!(p.abs_diff_eq(Vec3::new(1.0, 1.0, -1.0), 1e-5), "{p}");
+        assert!(rig.bone_moves(1) && rig.animates());
+    }
+
+    #[test]
+    fn a_trackless_rig_is_the_bind_pose() {
+        let rig = SkyRig {
+            parents: vec![-1, 0],
+            pivots: vec![Vec3::ZERO, Vec3::ONE],
+            tracks: vec![BoneTracks::default(); 2],
+            ..Default::default()
+        };
+        assert!(!rig.animates());
+        assert!(rig
+            .pose(1.0, 1.0)
+            .iter()
+            .all(|m| *m == Affine3A::IDENTITY));
+    }
+
+    /// The Caverns of Time belts: the general rig reproduces the rigid spin the old lane drew.
+    #[test]
+    fn the_caverns_belts_spin_as_the_bone_spin_does() {
+        let data = benilla_formats::wow_data_or_skip!();
+        let mut chain = benilla_formats::Chain::open(&data).expect("open chain");
+        const SKY: &str = "Environments\\Stars\\CavernsOfTimeSky.m2";
+        let bytes = chain.read_file(SKY).expect("read the sky");
+        let rig = SkyRig::from_bytes(&bytes);
+        let spins = benilla_formats::m2_bone_spins(&bytes);
+        assert!(!spins.is_empty());
+        for t in [0.0f32, 3.3, 17.0, 50.0] {
+            let pose = rig.pose(rig.band_time(t), f64::from(t));
+            for (bone, spin) in &spins {
+                let pivot = wow_to_bevy(spin.pivot);
+                let rot = wow_rotation_to_bevy(spin.sample(t));
+                let old = Affine3A::from_translation(pivot)
+                    * Affine3A::from_quat(rot)
+                    * Affine3A::from_translation(-pivot);
+                let p = Vec3::new(10.0, 3.0, -7.0) + pivot;
+                let a = pose[usize::from(*bone)].transform_point3(p);
+                let b = old.transform_point3(p);
+                assert!(a.abs_diff_eq(b, 1e-2), "bone {bone} t {t}: {a} vs {b}");
+            }
+        }
+    }
+}
diff --git a/crates/benilla-world/src/world_census.rs b/crates/benilla-world/src/world_census.rs
index 3426e0a5..0ad4c49c 100644
--- a/crates/benilla-world/src/world_census.rs
+++ b/crates/benilla-world/src/world_census.rs
@@ -244,8 +244,9 @@ impl WorldCensus<'_, '_> {
         };
 
         let sky = self.skybox.as_ref().map(|s| {
-            s.0.as_deref()
-                .map_or_else(|| "dome".to_string(), str::to_ascii_lowercase)
+            // MONKEY (skybox): the heaviest layer of the weighted list.
+            s.primary()
+                .map_or_else(|| "dome".to_string(), |l| l.path.to_ascii_lowercase())
         });
 
         CensusReport {

From bd1c6de9f81d0167f8e270e8de71a64e4c5b02a3 Mon Sep 17 00:00:00 2001
From: pkuzic <p.kuzickins@gmail.com>
Date: Fri, 25 Sep 2026 03:23:35 +0100
Subject: [PATCH 3/7] MONKEY (skybox): zoneSkyboxes cvar, Advanced Graphics
 row, skybox- capture scenarios

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 LIGHTING.md                                   |  1 +
 crates/benilla-app/assets/ui/OptionsFrame.xml | 30 +++++++-
 crates/benilla-app/src/capture/scenarios.rs   | 77 +++++++++++++++++++
 crates/benilla-app/src/cvars.rs               |  6 ++
 crates/benilla-app/src/debug_panel/world.rs   | 10 ++-
 crates/benilla-app/src/game_plugins.rs        |  2 +
 crates/benilla-app/src/lib.rs                 |  2 +
 crates/benilla-app/src/zone_skybox.rs         | 45 +++++++++++
 8 files changed, 168 insertions(+), 5 deletions(-)
 create mode 100644 crates/benilla-app/src/zone_skybox.rs

diff --git a/LIGHTING.md b/LIGHTING.md
index 2122d3df..9a5644ba 100644
--- a/LIGHTING.md
+++ b/LIGHTING.md
@@ -24,6 +24,7 @@ behind each constant.
 | Moon shadows | at night the same shadow rig re-aims at the moon and casts a faint shadow; dims only the night sky term, never point lights | `moonShadowStrength` |
 | Ground-effect spells | Flamestrike, Rain of Fire, Consecration, Flare and fire traps light the ground for their duration; frost and nature areas stay dark | `spellLightGain` |
 | Volumetric fog | near-field haze that converges on the zone fog colour (clear within 10 yd, full by 150 yd; mistier at dawn and in bad weather, faint indoors) and sun/moon light shafts through gaps, sampled from the shadow map; own fullscreen pass after the main pass (`benilla-app/src/volumetric_fog.rs`) | Advanced Graphics → Volumetric Fog (Off/Low/High), cvar `volumetricFog`, env `WOW_VOLFOG=0\|1\|2` |
+| Zone skyboxes | the painted sky a zone's `LightParams` names (clear-weather slot, storm slot lerped by the storm blend) for the living, fading in by the Light sphere falloff with the modern client's crossfade (ghost > WMO > zone); extended `LightSkybox.dbc` flags `0x1` day cycle, `0x2` keep sun/moon/stars/clouds, `0x4` fog-colour horizon cone, plus a celestial second model; every skybox now plays its bones, texture transforms, colour and alpha tracks (`benilla-world/src/skybox.rs`, `skybox_anim.rs`, `benilla-formats/src/light/skybox.rs`) | Advanced Graphics → Zone Skyboxes, cvar `zoneSkyboxes` (0 Off default, 1 On; High = 1), env `WOW_ZONE_SKYBOXES=0\|1` |
 | Night and interior level | global dimming of the night sky term and of interior ambient | `nightGain`, `interiorGain`, `interiorBakeFloor` |
 
 Players reach all of it from **Options -> Advanced Graphics** (a Lighting Quality preset Off / Low / Medium / High plus the individual rows; Off is the original client look). The dev build has a panel for all of it: **Ctrl+Shift+D → Lighting & shadows**, with Dim / Default /
diff --git a/crates/benilla-app/assets/ui/OptionsFrame.xml b/crates/benilla-app/assets/ui/OptionsFrame.xml
index 71e19e82..59bd286d 100644
--- a/crates/benilla-app/assets/ui/OptionsFrame.xml
+++ b/crates/benilla-app/assets/ui/OptionsFrame.xml
@@ -495,6 +495,8 @@
                 -- MONKEY (volumetric fog): localised atmospheric quality row.
                 volumetricFog = "Volumetric Fog",
                 fogOff = "Off",
+                -- MONKEY (skybox): the zone skybox row.
+                zoneSkyboxes = "Zone Skyboxes",
                 waterQuality = "Water Quality",
                 waterClassic = "Classic",
                 waterEnhanced = "Enhanced",
@@ -534,6 +536,12 @@
                     -- MONKEY (volumetric fog): explain cost and the shadow-map dependency.
                     VOLUMETRIC_FOG =
                         "Off disables volumetric fog. Low adds nearby haze and sun or moon shafts with fewer steps; High uses more steps for smoother shafts. Mist is heavier at dawn and in bad weather, and subtle indoors. Shafts require shadows; with shadows off only haze remains.",
+                    -- MONKEY (skybox): what the zone skybox row changes.
+                    ZONE_SKYBOXES =
+                        "Draws the painted sky a zone's lighting names, as later expansions do: "
+                        .. "the volcanic sky of the Burning Steppes, the alien sky of the Blasted Lands "
+                        .. "and the starry night over Mount Hyjal, fading in at the zone's edge. "
+                        .. "Off keeps the original client's sky everywhere but ghost and dungeon skies. Nearly free.",
                     WATER_QUALITY =
                         "Classic is the original client's water. Enhanced adds soft shorelines, "
                         .. "animated foam around shores and objects, moving wave highlights, sky reflection "
@@ -619,6 +627,8 @@
                 -- MONKEY (volumetric fog): Russian atmospheric quality row.
                 volumetricFog = "Объёмный туман",
                 fogOff = "Выкл",
+                -- MONKEY (skybox): the zone skybox row.
+                zoneSkyboxes = "Небосводы зон",
                 waterQuality = "Качество воды",
                 waterClassic = "Классическое",
                 waterEnhanced = "Улучшенное",
@@ -660,6 +670,12 @@
                     -- MONKEY (volumetric fog): localised effect and cost explanation.
                     VOLUMETRIC_FOG =
                         "Выкл отключает объёмный туман. Низкое добавляет дымку вблизи и лучи солнца или луны с меньшим числом шагов; Высокое использует больше шагов для более плавных лучей. Туман гуще на рассвете и в непогоду, а в помещениях слабее. Для лучей нужны тени; без теней остаётся только дымка.",
+                    -- MONKEY (skybox): what the zone skybox row changes.
+                    ZONE_SKYBOXES =
+                        "Рисует нарисованное небо, заданное освещением зоны, как в поздних дополнениях: "
+                        .. "вулканическое небо Пылающих степей, чужое небо Выжженных земель "
+                        .. "и звёздную ночь над горой Хиджал, с плавным появлением на границе зоны. "
+                        .. "«Выкл.» оставляет небо оригинального клиента везде, кроме неба призрака и подземелий. Почти бесплатно.",
                     WATER_QUALITY =
                         "«Классическое» — вода оригинального клиента. «Улучшенное» добавляет плавные переходы у берегов, "
                         .. "анимированную пену у берегов и вокруг объектов, подвижные блики на волнах, отражение неба "
@@ -2602,11 +2618,23 @@
                                                 })
                                             </OnLoad></Scripts>
                                         </Frame>
-                                        <Frame name="$parentRowCharacterShadows" inherits="OptionsCheckboxRowTemplate">
+                                        <!-- MONKEY (skybox): the zone skybox switch. -->
+                                        <Frame name="$parentRowZoneSkyboxes" inherits="OptionsCheckboxRowTemplate">
                                             <Anchors>
                                                 <Anchor point="TOPLEFT" relativeTo="$parentRowVolumetricFog" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                                 <Anchor point="TOPRIGHT" relativeTo="$parentRowVolumetricFog" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                             </Anchors>
+                                            <Scripts><OnLoad>
+                                                OptionsRow_OnLoad(self, "zoneSkyboxes",
+                                                    BENILLA_ADVGFX.zoneSkyboxes,
+                                                    "BENILLA_TOOLTIP_ZONE_SKYBOXES")
+                                            </OnLoad></Scripts>
+                                        </Frame>
+                                        <Frame name="$parentRowCharacterShadows" inherits="OptionsCheckboxRowTemplate">
+                                            <Anchors>
+                                                <Anchor point="TOPLEFT" relativeTo="$parentRowZoneSkyboxes" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowZoneSkyboxes" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                            </Anchors>
                                             <Scripts><OnLoad>
                                                 OptionsRow_OnLoad(self, "characterShadows",
                                                     BENILLA_ADVGFX.characterShadows,
diff --git a/crates/benilla-app/src/capture/scenarios.rs b/crates/benilla-app/src/capture/scenarios.rs
index d970a9fd..07631c96 100644
--- a/crates/benilla-app/src/capture/scenarios.rs
+++ b/crates/benilla-app/src/capture/scenarios.rs
@@ -1378,6 +1378,72 @@ pub(super) const ON_DEMAND: &[Scenario] = &[
         look: LAVA_RIVER_LOOK,
         minute: 0,
         ui: None,
+    },    // MONKEY (skybox): zone skyboxes (run with `WOW_ZONE_SKYBOXES=1`) and the two stock skybox
+    // lanes. Karazahn40 (Turtle map 814) is the one stock sphere naming a clear-slot skybox
+    // (Light 553, HellfireSkyBox); the zone shots need the sky patch.
+    Scenario {
+        name: "skybox-karazhan-noon",
+        map: Some(814),
+        eye: SKYBOX_KZ_EYE,
+        look: SKYBOX_KZ_LOOK,
+        minute: 720,
+        ui: None,
+    },
+    Scenario {
+        name: "skybox-karazhan-night",
+        map: Some(814),
+        eye: SKYBOX_KZ_EYE,
+        look: SKYBOX_KZ_LOOK,
+        minute: 0,
+        ui: None,
+    },
+    Scenario {
+        name: "skybox-steppes-noon",
+        map: Some(MAP_AZEROTH),
+        eye: SKYBOX_STEPPES_EYE,
+        look: SKYBOX_STEPPES_LOOK,
+        minute: 720,
+        ui: None,
+    },
+    Scenario {
+        name: "skybox-steppes-night",
+        map: Some(MAP_AZEROTH),
+        eye: SKYBOX_STEPPES_EYE,
+        look: SKYBOX_STEPPES_LOOK,
+        minute: 0,
+        ui: None,
+    },
+    Scenario {
+        name: "skybox-blasted-noon",
+        map: Some(MAP_AZEROTH),
+        eye: SKYBOX_BLASTED_EYE,
+        look: SKYBOX_BLASTED_LOOK,
+        minute: 720,
+        ui: None,
+    },
+    Scenario {
+        name: "skybox-blasted-night",
+        map: Some(MAP_AZEROTH),
+        eye: SKYBOX_BLASTED_EYE,
+        look: SKYBOX_BLASTED_LOOK,
+        minute: 0,
+        ui: None,
+    },
+    Scenario {
+        name: "skybox-hyjal-noon",
+        map: Some(MAP_KALIMDOR),
+        eye: SKYBOX_HYJAL_EYE,
+        look: SKYBOX_HYJAL_LOOK,
+        minute: 720,
+        ui: None,
+    },
+    Scenario {
+        name: "skybox-hyjal-night",
+        map: Some(MAP_KALIMDOR),
+        eye: SKYBOX_HYJAL_EYE,
+        look: SKYBOX_HYJAL_LOOK,
+        minute: 0,
+        ui: None,
     },
 ];
 
@@ -1482,6 +1548,17 @@ pub(crate) fn ui_opted_in() -> bool {
     std::env::var("WOW_CAPTURE_UI").as_deref() == Ok("1") || scenario_declares_ui()
 }
 
+// MONKEY (skybox): the skybox shots, eye just above the ground at a sphere's centre, pitched up so
+// the upper frame is sky.
+const SKYBOX_KZ_EYE: [f32; 3] = [-6474.0, -2912.0, 40.0];
+const SKYBOX_KZ_LOOK: [f32; 3] = [-6300.0, -2800.0, 95.0];
+const SKYBOX_STEPPES_EYE: [f32; 3] = [-7979.0, -2571.0, 260.0];
+const SKYBOX_STEPPES_LOOK: [f32; 3] = [-7800.0, -2450.0, 320.0];
+const SKYBOX_BLASTED_EYE: [f32; 3] = [-11300.0, -3073.0, 30.0];
+const SKYBOX_BLASTED_LOOK: [f32; 3] = [-11120.0, -2960.0, 90.0];
+const SKYBOX_HYJAL_EYE: [f32; 3] = [4637.0, -4461.0, 1060.0];
+const SKYBOX_HYJAL_LOOK: [f32; 3] = [4800.0, -4350.0, 1120.0];
+
 #[cfg(test)]
 mod ui_opt_in_tests {
     use super::*;
diff --git a/crates/benilla-app/src/cvars.rs b/crates/benilla-app/src/cvars.rs
index 31a7eced..90e2fafb 100644
--- a/crates/benilla-app/src/cvars.rs
+++ b/crates/benilla-app/src/cvars.rs
@@ -921,6 +921,12 @@ pub(crate) const REGISTERED: &[Registered] = &[
     ),
     // MONKEY (volumetric fog): saved live tier; capture override stays session-only.
     ours("volumetricFog", "1", "benilla's own: near-field volumetric fog, 0 Off / 1 Low / 2 High"),
+    // MONKEY (skybox): the living player's zone skybox from `LightParams`; High sets 1.
+    ours(
+        "zoneSkyboxes",
+        "0",
+        "benilla's own: draw the zone skybox LightParams names for the living, 0 Off / 1 On; the          reference draws a DBC skybox only for the ghost",
+    ),
     ours(
         "waterQuality",
         "1",
diff --git a/crates/benilla-app/src/debug_panel/world.rs b/crates/benilla-app/src/debug_panel/world.rs
index b7d26a01..c673c2d5 100644
--- a/crates/benilla-app/src/debug_panel/world.rs
+++ b/crates/benilla-app/src/debug_panel/world.rs
@@ -105,12 +105,14 @@ pub(super) fn world_section(ui: &mut egui::Ui, world: &mut WorldReadout) {
         // 4-second crossfade (== the interior-fog blend, one number): `w 0.00` beside a name means
         // the flood published a skybox the crossfade hasn't engaged — faithful standing outside
         // the gate, not a resolve bug.
-        match world.skybox.0.as_deref() {
-            Some(path) => {
+        // MONKEY (skybox): the heaviest layer of the weighted list, at its own weight.
+        match world.skybox.primary() {
+            Some(layer) => {
+                let path = layer.path.as_str();
                 let leaf = path.rsplit('\\').next().unwrap_or(path);
                 line.push_str(&format!(
-                    "  ·  skybox {leaf} w {:.2}",
-                    world.skybox_weight.0
+                    "  ·  skybox {leaf} w {:.2} (stand-down {:.2})",
+                    layer.weight, world.skybox_weight.0
                 ));
             }
             None => line.push_str("  ·  sky gradient"),
diff --git a/crates/benilla-app/src/game_plugins.rs b/crates/benilla-app/src/game_plugins.rs
index adda66ec..db88690d 100644
--- a/crates/benilla-app/src/game_plugins.rs
+++ b/crates/benilla-app/src/game_plugins.rs
@@ -245,6 +245,8 @@ impl PluginGroup for GamePlugins {
             .add(crate::dynamic_interior::DynamicInteriorPlugin)
             // MONKEY (volumetric fog): bridge the live setting to Bevy.
             .add(crate::volumetric_fog::VolumetricFogPlugin)
+            // MONKEY (skybox): bridge the zone-skybox setting to the world lane.
+            .add(crate::zone_skybox::ZoneSkyboxPlugin)
             // The realmlist (decision 1667) — the logon address the login screen edits. Same reason as
             // VideoPlugin above: it is a CVar knob, so its resource has to exist before `load_config`.
             .add(crate::realmlist::RealmlistPlugin)
diff --git a/crates/benilla-app/src/lib.rs b/crates/benilla-app/src/lib.rs
index a7f9ac23..862b5fc1 100644
--- a/crates/benilla-app/src/lib.rs
+++ b/crates/benilla-app/src/lib.rs
@@ -74,6 +74,8 @@ mod doodad_events;
 /// MONKEY (dynamic interiors): the cvar → benilla-world bridge for the fixture-lit interior lane.
 // MONKEY (volumetric fog): optional near-field atmosphere plugin.
 mod volumetric_fog;
+// MONKEY (skybox): the zoneSkyboxes cvar bridge.
+mod zone_skybox;
 mod dynamic_interior;
 mod entities;
 mod fishing_line;
diff --git a/crates/benilla-app/src/zone_skybox.rs b/crates/benilla-app/src/zone_skybox.rs
new file mode 100644
index 00000000..ce4342cc
--- /dev/null
+++ b/crates/benilla-app/src/zone_skybox.rs
@@ -0,0 +1,45 @@
+//! MONKEY (skybox): the `zoneSkyboxes` cvar's bridge to [`benilla_world::skybox::ZoneSkyboxes`].
+//! `WOW_ZONE_SKYBOXES=0|1` overrides it for the session, which is how a hermetic capture (no config
+//! file, registry defaults) turns the lane on.
+
+use bevy::prelude::*;
+
+/// The session override, read once.
+#[derive(Resource, Clone, Copy)]
+struct ZoneSkyboxOverride(Option<bool>);
+
+pub(crate) struct ZoneSkyboxPlugin;
+
+impl Plugin for ZoneSkyboxPlugin {
+    fn build(&self, app: &mut App) {
+        let forced = std::env::var("WOW_ZONE_SKYBOXES")
+            .ok()
+            .and_then(|v| v.trim().parse::<u8>().ok())
+            .map(|v| v != 0);
+        app.insert_resource(ZoneSkyboxOverride(forced))
+            .add_observer(on_cvar)
+            .add_systems(Startup, apply_override);
+    }
+}
+
+fn apply_override(
+    forced: Res<ZoneSkyboxOverride>,
+    zone: Option<ResMut<benilla_world::skybox::ZoneSkyboxes>>,
+) {
+    if let (Some(on), Some(mut zone)) = (forced.0, zone) {
+        zone.set_if_neq(benilla_world::skybox::ZoneSkyboxes(on));
+    }
+}
+
+fn on_cvar(
+    ev: On<crate::cvars::CvarChanged>,
+    forced: Res<ZoneSkyboxOverride>,
+    zone: Option<ResMut<benilla_world::skybox::ZoneSkyboxes>>,
+) {
+    if !ev.is("zoneSkyboxes") || forced.0.is_some() {
+        return;
+    }
+    if let Some(mut zone) = zone {
+        zone.set_if_neq(benilla_world::skybox::ZoneSkyboxes(ev.flag()));
+    }
+}

From 7469caa2894f4748b66d2c296ed4ad0a800d77d8 Mon Sep 17 00:00:00 2001
From: pkuzic <p.kuzickins@gmail.com>
Date: Fri, 25 Sep 2026 12:31:47 +0100
Subject: [PATCH 4/7] MONKEY (skybox): Stratholme skybox scenario, rig test
 timing

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/benilla-app/src/capture/scenarios.rs | 11 +++++++++++
 crates/benilla-world/src/skybox_anim.rs     | 11 ++++++-----
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/crates/benilla-app/src/capture/scenarios.rs b/crates/benilla-app/src/capture/scenarios.rs
index 07631c96..6b489dd9 100644
--- a/crates/benilla-app/src/capture/scenarios.rs
+++ b/crates/benilla-app/src/capture/scenarios.rs
@@ -1381,6 +1381,15 @@ pub(super) const ON_DEMAND: &[Scenario] = &[
     },    // MONKEY (skybox): zone skyboxes (run with `WOW_ZONE_SKYBOXES=1`) and the two stock skybox
     // lanes. Karazahn40 (Turtle map 814) is the one stock sphere naming a clear-slot skybox
     // (Light 553, HellfireSkyBox); the zone shots need the sky patch.
+    // The stock MOSB lane: Stratholme_B's groups flagged 0x40000, weight = the interior crossfade.
+    Scenario {
+        name: "skybox-stratholme-noon",
+        map: Some(329),
+        eye: SKYBOX_STRAT_EYE,
+        look: SKYBOX_STRAT_LOOK,
+        minute: 720,
+        ui: None,
+    },
     Scenario {
         name: "skybox-karazhan-noon",
         map: Some(814),
@@ -1550,6 +1559,8 @@ pub(crate) fn ui_opted_in() -> bool {
 
 // MONKEY (skybox): the skybox shots, eye just above the ground at a sphere's centre, pitched up so
 // the upper frame is sky.
+const SKYBOX_STRAT_EYE: [f32; 3] = [3450.0, -3380.0, 150.0];
+const SKYBOX_STRAT_LOOK: [f32; 3] = [3600.0, -3300.0, 200.0];
 const SKYBOX_KZ_EYE: [f32; 3] = [-6474.0, -2912.0, 40.0];
 const SKYBOX_KZ_LOOK: [f32; 3] = [-6300.0, -2800.0, 95.0];
 const SKYBOX_STEPPES_EYE: [f32; 3] = [-7979.0, -2571.0, 260.0];
diff --git a/crates/benilla-world/src/skybox_anim.rs b/crates/benilla-world/src/skybox_anim.rs
index 9f835f40..0ea157b7 100644
--- a/crates/benilla-world/src/skybox_anim.rs
+++ b/crates/benilla-world/src/skybox_anim.rs
@@ -435,7 +435,8 @@ mod tests {
     use super::*;
 
     fn spin_rig() -> SkyRig {
-        // One parentless bone at pivot (1,0,0) turning about +Y over 4 s, linear.
+        // One parentless bone at pivot (1,0,0) turning 135° about +Y over 4 s, linear; the quarter
+        // turn falls at 8/3 s.
         SkyRig {
             parents: vec![-1],
             pivots: vec![Vec3::X],
@@ -443,7 +444,7 @@ mod tests {
                 rotation: Channel {
                     keys: vec![
                         (0.0, Quat::IDENTITY),
-                        (4.0, Quat::from_rotation_y(std::f32::consts::PI)),
+                        (4.0, Quat::from_rotation_y(std::f32::consts::FRAC_PI_2 * 1.5)),
                     ],
                     linear: true,
                 },
@@ -458,8 +459,8 @@ mod tests {
     #[test]
     fn a_bone_turns_about_its_pivot() {
         let rig = spin_rig();
-        let m = rig.pose(rig.band_time(4.0 + 2.0), 0.0)[0];
-        // Half way: a quarter turn about the pivot; the pivot itself stays put.
+        let m = rig.pose(rig.band_time(4.0 + 8.0 / 3.0), 0.0)[0];
+        // A quarter turn about the pivot; the pivot itself stays put.
         assert!(m.transform_point3(Vec3::X).abs_diff_eq(Vec3::X, 1e-5));
         let p = m.transform_point3(Vec3::new(2.0, 0.0, 0.0));
         assert!(p.abs_diff_eq(Vec3::new(1.0, 0.0, -1.0), 1e-5), "{p}");
@@ -477,7 +478,7 @@ mod tests {
             },
             ..Default::default()
         });
-        let pose = rig.pose(2.0, 0.0);
+        let pose = rig.pose(8.0 / 3.0, 0.0);
         let p = pose[1].transform_point3(Vec3::new(2.0, 0.0, 0.0));
         // Lifted by the child, then turned a quarter by the parent.
         assert!(p.abs_diff_eq(Vec3::new(1.0, 1.0, -1.0), 1e-5), "{p}");

From c97ecc112384d5c49725a4ba8b406595ec6cd48b Mon Sep 17 00:00:00 2001
From: pkuzic <p.kuzickins@gmail.com>
Date: Fri, 25 Sep 2026 16:39:11 +0100
Subject: [PATCH 5/7] MONKEY (skybox): pose captures at t = 0, higher Hyjal
 viewpoint

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/benilla-app/src/capture/scenarios.rs | 4 ++--
 crates/benilla-world/src/skybox.rs          | 8 +++++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/crates/benilla-app/src/capture/scenarios.rs b/crates/benilla-app/src/capture/scenarios.rs
index 6b489dd9..35bcc6e8 100644
--- a/crates/benilla-app/src/capture/scenarios.rs
+++ b/crates/benilla-app/src/capture/scenarios.rs
@@ -1567,8 +1567,8 @@ const SKYBOX_STEPPES_EYE: [f32; 3] = [-7979.0, -2571.0, 260.0];
 const SKYBOX_STEPPES_LOOK: [f32; 3] = [-7800.0, -2450.0, 320.0];
 const SKYBOX_BLASTED_EYE: [f32; 3] = [-11300.0, -3073.0, 30.0];
 const SKYBOX_BLASTED_LOOK: [f32; 3] = [-11120.0, -2960.0, 90.0];
-const SKYBOX_HYJAL_EYE: [f32; 3] = [4637.0, -4461.0, 1060.0];
-const SKYBOX_HYJAL_LOOK: [f32; 3] = [4800.0, -4350.0, 1120.0];
+const SKYBOX_HYJAL_EYE: [f32; 3] = [4637.0, -4461.0, 1130.0];
+const SKYBOX_HYJAL_LOOK: [f32; 3] = [4800.0, -4350.0, 1230.0];
 
 #[cfg(test)]
 mod ui_opt_in_tests {
diff --git a/crates/benilla-world/src/skybox.rs b/crates/benilla-world/src/skybox.rs
index c7ab7add..5c190b49 100644
--- a/crates/benilla-world/src/skybox.rs
+++ b/crates/benilla-world/src/skybox.rs
@@ -646,8 +646,8 @@ struct ModelClock {
 }
 
 /// MONKEY (skybox): pose every shown skybox and run its material loops on the model's clock:
-/// sequence 0 at `duration × day fraction` under flag `0x1`, else the scene clock. A capture keeps
-/// the bind pose and the seeds, as the shared lanes freeze, unless the day drives the clock.
+/// sequence 0 at `duration × day fraction` under flag `0x1`, else the scene clock. A capture holds
+/// `t = 0` unless the day drives the clock.
 #[allow(clippy::too_many_arguments)]
 fn animate_skyboxes(
     time: Res<Time>,
@@ -670,11 +670,13 @@ fn animate_skyboxes(
         let Some(rig) = rigs.0.get(&layer.path) else {
             continue;
         };
+        // A capture poses at `t = 0`, not the bind pose: a converted skybox places its layers with
+        // bone keys, and every row at `t = 0` is its seed.
         let (band_t, gseq, live) = if layer.flags & SKYBOX_FULL_DAY != 0 {
             let g = if deterministic { 0.0 } else { f64::from(now) };
             (rig.duration * day, g, true)
         } else if deterministic {
-            (0.0, 0.0, false)
+            (0.0, 0.0, true)
         } else {
             (now, f64::from(now), true)
         };

From f13a7c9ead9559ad3d1f724487767bb43e1f831e Mon Sep 17 00:00:00 2001
From: pkuzic <p.kuzickins@gmail.com>
Date: Fri, 25 Sep 2026 16:48:19 +0100
Subject: [PATCH 6/7] MONKEY (skybox): WOW_SKYBOX_T capture clock for animated
 skies

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/benilla-world/src/skybox.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/crates/benilla-world/src/skybox.rs b/crates/benilla-world/src/skybox.rs
index 5c190b49..8ff00863 100644
--- a/crates/benilla-world/src/skybox.rs
+++ b/crates/benilla-world/src/skybox.rs
@@ -645,6 +645,19 @@ struct ModelClock {
     pose: Vec<Affine3A>,
 }
 
+/// MONKEY (skybox): `WOW_SKYBOX_T=<secs>` holds a capture's skybox clock there instead of 0, to
+/// photograph an animated sky mid-loop.
+fn capture_t() -> f32 {
+    static T: std::sync::OnceLock<f32> = std::sync::OnceLock::new();
+    *T.get_or_init(|| {
+        std::env::var("WOW_SKYBOX_T")
+            .ok()
+            .and_then(|v| v.trim().parse().ok())
+            .filter(|t: &f32| t.is_finite())
+            .unwrap_or(0.0)
+    })
+}
+
 /// MONKEY (skybox): pose every shown skybox and run its material loops on the model's clock:
 /// sequence 0 at `duration × day fraction` under flag `0x1`, else the scene clock. A capture holds
 /// `t = 0` unless the day drives the clock.
@@ -676,7 +689,7 @@ fn animate_skyboxes(
             let g = if deterministic { 0.0 } else { f64::from(now) };
             (rig.duration * day, g, true)
         } else if deterministic {
-            (0.0, 0.0, true)
+            (capture_t(), f64::from(capture_t()), true)
         } else {
             (now, f64::from(now), true)
         };

From 22d75ea613a5b2dd7791ca3851263a1dba292880 Mon Sep 17 00:00:00 2001
From: pkuzic <p.kuzickins@gmail.com>
Date: Fri, 25 Sep 2026 17:50:38 +0100
Subject: [PATCH 7/7] MONKEY (skybox): second texture stage for two-texture
 skybox batches

RenderSubmesh carries stage 1 (texture, UV set, transform, Mod/Mod2x) for
textureCount 2 batches; M2Vertex reads UV1. WowModelExt gains a stage1
uniform + texture binding 94/95 and the WOW_STAGE1 shader def, so every
one-texture batch compiles the old code. The skybox lane binds stage 1 on
its own material copies and drives its transform rows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/benilla-app/src/pipe_warm/menagerie.rs |  1 +
 crates/benilla-assets/src/materials.rs        | 18 +++++++
 .../benilla-assets/src/shaders/wow_model.wgsl | 22 ++++++++
 crates/benilla-assets/src/world_assets/mod.rs |  3 ++
 crates/benilla-formats/src/lib.rs             |  2 +-
 .../benilla-formats/src/models/m2_batches.rs  | 49 ++++++++++++++++-
 crates/benilla-formats/src/models/mod.rs      |  1 +
 crates/benilla-formats/src/models/types.rs    | 21 ++++++++
 crates/benilla-m2/src/lib.rs                  |  5 ++
 crates/benilla-m2/src/model.rs                |  4 +-
 crates/benilla-world/src/model_render.rs      |  6 +++
 crates/benilla-world/src/skybox.rs            | 38 ++++++++++++-
 crates/benilla-world/src/skybox_anim.rs       | 53 ++++++++++++++++++-
 13 files changed, 218 insertions(+), 5 deletions(-)

diff --git a/crates/benilla-app/src/pipe_warm/menagerie.rs b/crates/benilla-app/src/pipe_warm/menagerie.rs
index 079ee8ed..93339a2c 100644
--- a/crates/benilla-app/src/pipe_warm/menagerie.rs
+++ b/crates/benilla-app/src/pipe_warm/menagerie.rs
@@ -889,6 +889,7 @@ fn warm_quad(colors: bool, skinned: bool) -> RenderSubmesh {
         rgb_seq: None,
         wmo_batch: None,
         section: None,
+        stage1: None,
     }
 }
 
diff --git a/crates/benilla-assets/src/materials.rs b/crates/benilla-assets/src/materials.rs
index 18aa1682..ff171a45 100644
--- a/crates/benilla-assets/src/materials.rs
+++ b/crates/benilla-assets/src/materials.rs
@@ -71,6 +71,8 @@ pub struct WowModelKey {
     /// The WMO-skybox lane (`clutter_fade.z` bit 13, `model_render::SKY_DEPTH_MARKER`), a key axis
     /// because only this model's depth is pinned.
     sky_depth: bool,
+    /// MONKEY (skybox): a second texture stage (`stage1.x`), the `WOW_STAGE1` shader def.
+    stage1: bool,
     // The WMO batch order is deliberately not a key axis (a pipeline per batch index stalls a
     // city's first sight): the file-order layering (`0x6b4f10`/`0x6b5190`) rides `sun_scale.y`.
 }
@@ -89,6 +91,7 @@ impl From<&WowModelExt> for WowModelKey {
             zfill: markers & 0x200 != 0,
             far_side: markers & 0x800 != 0,
             sky_depth: markers & 0x2000 != 0,
+            stage1: e.stage1.x > 0.5,
         }
     }
 }
@@ -122,6 +125,14 @@ pub struct WowModelExt {
     /// tint, `z` = the texture-transform affine, `w` = the UI tile's cell clip.
     #[uniform(100)]
     pub anim_slots: Vec4,
+    /// MONKEY (skybox): a two-texture batch's stage 1: `x` = 0 none, 1 Mod, 2 Mod2x; `z`/`w` = the
+    /// `matanim` rows of its translation and affine, read on UV set B. `0` on every other batch.
+    #[uniform(100)]
+    pub stage1: Vec4,
+    /// MONKEY (skybox): stage 1's texture; `None` (the fallback image) unless `stage1.x > 0`.
+    #[texture(94)]
+    #[sampler(95)]
+    pub stage1_texture: Option<Handle<Image>>,
     /// The shared global light (`lighting::global_light`), updated in place once a frame; the
     /// vertex stage reads its point-light table, since Bevy's clusterable lights are fragment-only.
     #[storage(90, read_only, buffer, visibility(vertex, fragment))]
@@ -254,6 +265,13 @@ impl MaterialExtension for WowModelExt {
                 ds.bias.constant = 0;
             }
         }
+        // MONKEY (skybox): the second texture stage compiles only where a batch has one.
+        if key.bind_group_data.stage1 {
+            descriptor.vertex.shader_defs.push("WOW_STAGE1".into());
+            if let Some(fragment) = descriptor.fragment.as_mut() {
+                fragment.shader_defs.push("WOW_STAGE1".into());
+            }
+        }
         // The skybox pins clip z to 0, reverse-Z far, in the vertex stage; its bias is sort-only.
         if key.bind_group_data.sky_depth {
             descriptor.vertex.shader_defs.push("WOW_SKY_DEPTH".into());
diff --git a/crates/benilla-assets/src/shaders/wow_model.wgsl b/crates/benilla-assets/src/shaders/wow_model.wgsl
index 07705ba5..f5c8ea58 100644
--- a/crates/benilla-assets/src/shaders/wow_model.wgsl
+++ b/crates/benilla-assets/src/shaders/wow_model.wgsl
@@ -47,8 +47,14 @@ struct ModelParams {
     // Rows of `wow_light.matanim`, 0 = identity: x = UV scroll, y = tint, z = texture-transform
     // affine, w = the UI tile's cell clip.
     anim_slots: vec4<f32>,
+    // MONKEY (skybox): stage 1 of a two-texture batch: x = 0 none / 1 Mod / 2 Mod2x, z/w = the
+    // matanim rows of its translation and affine.
+    stage1: vec4<f32>,
 };
 @group(#{MATERIAL_BIND_GROUP}) @binding(100) var<uniform> m: ModelParams;
+// MONKEY (skybox): stage 1's texture, the fallback image off `WOW_STAGE1`.
+@group(#{MATERIAL_BIND_GROUP}) @binding(94) var stage1_texture: texture_2d<f32>;
+@group(#{MATERIAL_BIND_GROUP}) @binding(95) var stage1_sampler: sampler;
 
 // A fully covered character shadow retains 45% of the authored model lighting.
 const SHADOW_SUN_FLOOR: f32 = 0.45;
@@ -1286,6 +1292,22 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
         base_color.a = base_color.a * ramp;
     }
 
+    // MONKEY (skybox): stage 1 multiplies in on UV set B, moved by its own texture transform
+    // (the stage-0 law above): colour ×1 (Mod) or ×2 (Mod2x), alpha ×1.
+#ifdef WOW_STAGE1
+#ifdef VERTEX_UVS_B
+    {
+        let t1 = wow_light.matanim[u32(m.stage1.z)];
+        let a1 = wow_light.matanim[u32(m.stage1.w)];
+        let d1 = (in.uv_b + t1.xy - vec2<f32>(0.5, 0.5)) * vec2<f32>(1.0 + a1.z, 1.0 + a1.w);
+        let c1 = 1.0 + a1.x;
+        let uv1 = vec2<f32>(0.5 + d1.x * c1 - d1.y * a1.y, 0.5 + d1.x * a1.y + d1.y * c1);
+        let s1 = textureSampleBias(stage1_texture, stage1_sampler, uv1, view.mip_bias);
+        let k1 = select(1.0, 2.0, m.stage1.x > 1.5);
+        base_color = vec4<f32>(base_color.rgb * s1.rgb * k1, base_color.a * s1.a);
+    }
+#endif
+#endif
     // The MeshTag (mesh_tag.rs): bit 31 = highlight, bit 30 = interior fog; payload bits 0-5 = the
     // fade alpha (a zero payload is untagged, opaque), 19-29 = the rig slot, 6-13 = the ground
     // shade (0 lit, 255 MCSH-shadowed) or, on an interior-prop material, 6-18 = the SH-probe slot.
diff --git a/crates/benilla-assets/src/world_assets/mod.rs b/crates/benilla-assets/src/world_assets/mod.rs
index dba6e3e8..d94106c8 100644
--- a/crates/benilla-assets/src/world_assets/mod.rs
+++ b/crates/benilla-assets/src/world_assets/mod.rs
@@ -577,6 +577,9 @@ impl WorldAssets {
                 tint: Vec4::ONE, // clutter has no animated M2Color tint and is not a WMO batch
                 sidn: Vec4::ZERO, // clutter is never SIDN/WINDOW glass (WMO-only)
                 anim_slots: Vec4::ZERO,
+                // MONKEY (skybox): no second stage.
+                stage1: Vec4::ZERO,
+                stage1_texture: None,
                 light_buf: self.shared_light.clone(),
                 // MONKEY (torch shadows Phase 3A): the shared torch receiver bindings.
                 torch_depth: self.torch.depth.clone(),
diff --git a/crates/benilla-formats/src/lib.rs b/crates/benilla-formats/src/lib.rs
index 83813eda..141c3183 100644
--- a/crates/benilla-formats/src/lib.rs
+++ b/crates/benilla-formats/src/lib.rs
@@ -275,7 +275,7 @@ pub use models::{
     CoverageReader, EmitterBoneLink, EventMarker, FogPolicy, FootprintTris, GlobalSeqBone,
     GlobalSeqChannel, GroundQuad, KeyAnim, M2AnimSummary, M2Attachment, M2Bounds, M2CameraTracks,
     M2Light, M2PaneCamera, M2PortraitCamera, ModelAnimation, ModelBlend, ParentArm, ParentBasis,
-    PlayableAnim, RenderSubmesh, RgbAnim, ScalarAnim, SeqLoops, ShippedGlueScene, Skeleton,
+    PlayableAnim, RenderSubmesh, RgbAnim, StageTwo, ScalarAnim, SeqLoops, ShippedGlueScene, Skeleton,
     SkeletonBone, StringAnchors, UvAnim, UvRotAnim, WmoBatchClass, WmoDoodad, WmoDoodadSet, WmoFog,
     WmoGroupHeader, WmoGroupInfo, WmoLight, WmoPortalInfo, WmoPortalRef, WmoPortals, WmoRoot,
     ALPHA_KEY_REF, DEGENERATE_RING_FOOTPRINT, GLUE_AUTHORED_ASPECT, NO_GROUP_LIQUID,
diff --git a/crates/benilla-formats/src/models/m2_batches.rs b/crates/benilla-formats/src/models/m2_batches.rs
index 40043970..6cb13f03 100644
--- a/crates/benilla-formats/src/models/m2_batches.rs
+++ b/crates/benilla-formats/src/models/m2_batches.rs
@@ -17,7 +17,7 @@ use super::tex_anim;
 use super::{le_u16, le_u32, model_path, remap_submesh};
 use super::{
     AlphaAnim, Billboard, BillboardKind, BoneScaleAnim, CharSkinSlot, FogPolicy, ModelBlend,
-    RenderSubmesh,
+    RenderSubmesh, StageTwo,
 };
 
 fn parent_dir(path: &str) -> &str {
@@ -479,6 +479,33 @@ pub fn parse_m2_render_submeshes(
         let rgb_seq = rgb_track
             .and_then(|t| mat_anim::bake_rgb_seqs(t, &model.global_sequences, &seq_slots))
             .filter(|set| set.uniform().is_none());
+        // MONKEY (skybox): stage 1 of a two-texture batch; an env-mapped stage 1 is left out.
+        let stage1 = (batch.texture_count >= 2 && !model.stage_is_env_mapped(batch, 1))
+            .then(|| {
+                let rec = model
+                    .raw_data
+                    .texture_lookup_table
+                    .get(batch.texture_combo_index as usize + 1)
+                    .and_then(|&ti| model.textures.get(ti as usize))?;
+                let set = model
+                    .texture_unit_lookup
+                    .get(batch.texture_coord_combo_index as usize + 1)
+                    .copied()
+                    .unwrap_or(0);
+                let combo = batch.texture_transform_combo_index.wrapping_add(1);
+                Some((
+                    resolve_texture(rec, dir, skins).0,
+                    (rec.wrap_x, rec.wrap_y),
+                    set == 1,
+                    batch.shader_id & 0xf == 4,
+                    tex_anim::bake_uv_anim(model, combo, seq0_slot),
+                    tex_anim::bake_uv_rot_seqs(model, combo, &seq_slots)
+                        .and_then(|s| s.seq(None).cloned()),
+                    tex_anim::bake_uv_scale_seqs(model, combo, &seq_slots)
+                        .and_then(|s| s.seq(None).cloned()),
+                ))
+            })
+            .flatten();
         // The reference turns each billboard bone to the camera about its own pivot, and a batch
         // can hold cards on several bones (a candelabra's glows): one submesh per billboard bone.
         let make_billboard = |bone_idx: usize| -> Option<Billboard> {
@@ -591,6 +618,26 @@ pub fn parse_m2_render_submeshes(
             sub.uv_scale_seq = uv_scale_seq.clone();
             sub.rgb_anim = rgb_anim.clone();
             sub.rgb_seq = rgb_seq.clone();
+            // MONKEY (skybox): stage 1's UVs follow the submesh's own vertex order.
+            sub.stage1 = stage1.as_ref().map(
+                |(texture, (wrap_x, wrap_y), uv1, mod2x, uv_anim, uv_rot, uv_scale)| StageTwo {
+                    texture: texture.clone(),
+                    wrap_x: *wrap_x,
+                    wrap_y: *wrap_y,
+                    uvs: globals
+                        .iter()
+                        .map(|&g| {
+                            let v = &model.vertices[g as usize];
+                            let c = if *uv1 { &v.tex_coords2 } else { &v.tex_coords };
+                            [c.x, c.y]
+                        })
+                        .collect(),
+                    mod2x: *mod2x,
+                    uv_anim: uv_anim.clone(),
+                    uv_rot: uv_rot.clone(),
+                    uv_scale: uv_scale.clone(),
+                },
+            );
             out.push(sub);
         }
     }
diff --git a/crates/benilla-formats/src/models/mod.rs b/crates/benilla-formats/src/models/mod.rs
index 636b1b3c..ea0c07bf 100644
--- a/crates/benilla-formats/src/models/mod.rs
+++ b/crates/benilla-formats/src/models/mod.rs
@@ -100,6 +100,7 @@ fn remap_submesh(
             wmo_batch: None,
             env_map: false,
             section: None,
+            stage1: None,
         },
         globals,
     )
diff --git a/crates/benilla-formats/src/models/types.rs b/crates/benilla-formats/src/models/types.rs
index 154eb3a3..47c31cda 100644
--- a/crates/benilla-formats/src/models/types.rs
+++ b/crates/benilla-formats/src/models/types.rs
@@ -262,6 +262,24 @@ pub enum FogPolicy {
     Off = 4,
 }
 
+/// MONKEY (skybox): a two-texture batch's second stage (`textureCount 2`, which no stock 1.12
+/// model authors): texture `textureLookup[combo + 1]` on the UV set `texUnitLookup[coord + 1]`,
+/// moved by `texAnimLookup[transform + 1]`, multiplied into stage 0 (`Mod`, or `Mod2x` on the
+/// modern `0x4014` combiner).
+#[derive(Debug, Clone, Default)]
+pub struct StageTwo {
+    pub texture: Option<String>,
+    pub wrap_x: bool,
+    pub wrap_y: bool,
+    /// Per vertex, parallel to [`RenderSubmesh::positions`], from the stage's own UV set.
+    pub uvs: Vec<[f32; 2]>,
+    /// The stage's colour doubles (`Mod2x`).
+    pub mod2x: bool,
+    pub uv_anim: Option<UvAnim>,
+    pub uv_rot: Option<super::key_anim::KeyAnim<[f32; 4]>>,
+    pub uv_scale: Option<super::key_anim::KeyAnim<[f32; 2]>>,
+}
+
 /// One render batch: self-contained geometry and its material.
 #[derive(Debug, Clone)]
 pub struct RenderSubmesh {
@@ -346,6 +364,8 @@ pub struct RenderSubmesh {
     /// over its base); the reference draws both from one vertex array under LEQUAL, the later
     /// winning exactly (`0x70c190`), so consolidators refuse a section they cannot take whole.
     pub section: Option<u16>,
+    /// MONKEY (skybox): the second texture stage, `None` on every one-texture batch.
+    pub stage1: Option<StageTwo>,
     /// Texture coordinates generated as a view-space sphere map, not read from [`Self::uvs`]
     /// (`texture_unit_lookup[texCoordSet] > 2`): `uv = normalize(P − 2(P·N)N).xy · 0.5 + 0.5`.
     /// Such a mesh parks its UVs at one point (`GnomeSubwayGlass.m2`).
@@ -416,6 +436,7 @@ impl Default for RenderSubmesh {
             wmo_batch: None,
             env_map: false,
             section: None,
+            stage1: None,
         }
     }
 }
diff --git a/crates/benilla-m2/src/lib.rs b/crates/benilla-m2/src/lib.rs
index bc0214c2..010bb5d7 100644
--- a/crates/benilla-m2/src/lib.rs
+++ b/crates/benilla-m2/src/lib.rs
@@ -173,6 +173,11 @@ pub fn parse_m2(cursor: &mut Cursor<&[u8]>) -> Result<M2Format> {
                 x: v.f32_at(32).ok_or(Error::Truncated)?,
                 y: v.f32_at(36).ok_or(Error::Truncated)?,
             },
+            // MONKEY (skybox): the second UV set.
+            tex_coords2: C2 {
+                x: v.f32_at(40).ok_or(Error::Truncated)?,
+                y: v.f32_at(44).ok_or(Error::Truncated)?,
+            },
         });
     }
 
diff --git a/crates/benilla-m2/src/model.rs b/crates/benilla-m2/src/model.rs
index 6bc8a864..14f37477 100644
--- a/crates/benilla-m2/src/model.rs
+++ b/crates/benilla-m2/src/model.rs
@@ -106,7 +106,7 @@ impl M2Bone {
 }
 
 /// One M2 vertex, 48 bytes: position @0, weights @0x0c, indices @0x10, normal @0x14, UV @0x20,
-/// and an unread second UV @0x28.
+/// and a second UV @0x28.
 pub struct M2Vertex {
     pub position: C3,
     /// Per-vertex bone influence weights (`/255`), paired with [`Self::bone_indices`].
@@ -114,6 +114,8 @@ pub struct M2Vertex {
     pub bone_indices: [u8; 4],
     pub normal: C3,
     pub tex_coords: C2,
+    /// MONKEY (skybox): the second UV set, which a two-texture batch's stage 1 can read.
+    pub tex_coords2: C2,
 }
 
 /// The texture lookup table and the collision hull's raw bytes.
diff --git a/crates/benilla-world/src/model_render.rs b/crates/benilla-world/src/model_render.rs
index 7dc4bcfc..42b3951f 100644
--- a/crates/benilla-world/src/model_render.rs
+++ b/crates/benilla-world/src/model_render.rs
@@ -323,6 +323,9 @@ pub fn model_material(
                 },
                 // Zero until a sampler registers this material and bakes its table slot in once.
                 anim_slots: Vec4::ZERO,
+                // MONKEY (skybox): no second stage.
+                stage1: Vec4::ZERO,
+                stage1_texture: None,
                 light_buf: light.clone(),
                 // MONKEY (torch shadows Phase 3A): the shared torch receiver bindings.
                 torch_depth: torch.depth.clone(),
@@ -446,6 +449,9 @@ pub fn zfill_material(
                 tint: Vec4::new(1.0, 1.0, 1.0, 0.0),
                 sidn: Vec4::ZERO,
                 anim_slots: Vec4::ZERO,
+                // MONKEY (skybox): no second stage.
+                stage1: Vec4::ZERO,
+                stage1_texture: None,
                 light_buf: light.clone(),
                 // MONKEY (torch shadows Phase 3A): the shared torch receiver bindings.
                 torch_depth: torch.depth.clone(),
diff --git a/crates/benilla-world/src/skybox.rs b/crates/benilla-world/src/skybox.rs
index 8ff00863..bd750db4 100644
--- a/crates/benilla-world/src/skybox.rs
+++ b/crates/benilla-world/src/skybox.rs
@@ -481,6 +481,10 @@ fn build_skybox(
             {
                 mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, sub.vertex_colors.clone());
             }
+            // MONKEY (skybox): stage 1 reads UV set B.
+            if let Some(st) = sub.stage1.as_ref().filter(|s| s.uvs.len() == sub.positions.len()) {
+                mesh.insert_attribute(Mesh::ATTRIBUTE_UV_1, st.uvs.clone());
+            }
             mesh.insert_indices(Indices::U32(sub.indices.clone()));
             // The batch's authored address mode: Caverns of Time's belts wrap their UVs.
             let texture = sub
@@ -493,9 +497,41 @@ fn build_skybox(
             // The authored batch order after the layer's base (0 is unordered): every batch shares
             // one sort distance.
             let order = base + u16::try_from(i + 1).unwrap_or(0);
-            let Some(pair) = mats.skybox(sub, texture, order, uv.as_ref(), tint.as_ref()) else {
+            let Some(mut pair) = mats.skybox(sub, texture, order, uv.as_ref(), tint.as_ref())
+            else {
                 return; // light buffer vanished mid-build; `built` is unlatched, so we retry
             };
+            // MONKEY (skybox): a two-texture batch takes its own copies with stage 1 bound, so
+            // the deduped one-texture materials stay as they were.
+            if let Some(st) = sub.stage1.as_ref().filter(|s| s.uvs.len() == sub.positions.len()) {
+                let tex1 = st
+                    .texture
+                    .as_deref()
+                    .and_then(|t| world_assets.texture(t, (st.wrap_x, st.wrap_y), &mut images));
+                let mode = if st.mod2x { 2.0 } else { 1.0 };
+                let mut with_stage1 = |h: &Handle<WowModelMaterial>| {
+                    let mut m = crate::model_render::lazy::with_material_mut(
+                        mats.materials(),
+                        h.id(),
+                        |m| m.clone(),
+                    )?;
+                    m.extension.stage1 = Vec4::new(mode, 0.0, 0.0, 0.0);
+                    m.extension.stage1_texture = tex1.clone();
+                    Some(mats.materials().add(m))
+                };
+                let shared = pair.fade_blend == pair.steady;
+                if let Some(steady) = with_stage1(&pair.steady) {
+                    let fade = if shared {
+                        Some(steady.clone())
+                    } else {
+                        with_stage1(&pair.fade_blend)
+                    };
+                    if let Some(fade) = fade {
+                        pair.steady = steady;
+                        pair.fade_blend = fade;
+                    }
+                }
+            }
             let lane = SkyMatLane::register(
                 sub,
                 uv,
diff --git a/crates/benilla-world/src/skybox_anim.rs b/crates/benilla-world/src/skybox_anim.rs
index 0ea157b7..652fa163 100644
--- a/crates/benilla-world/src/skybox_anim.rs
+++ b/crates/benilla-world/src/skybox_anim.rs
@@ -313,6 +313,9 @@ pub(crate) struct SkyMatLane {
     pub(crate) uv: Option<(u16, [f32; 2], Arc<benilla_formats::UvAnim>)>,
     pub(crate) affine: Option<(u16, AffineLoops)>,
     pub(crate) tint: Option<(u16, [f32; 3], Arc<benilla_formats::RgbAnim>)>,
+    /// Stage 1's translation row (absolute, no seed) and affine row.
+    pub(crate) stage1_uv: Option<(u16, benilla_formats::UvAnim)>,
+    pub(crate) stage1_affine: Option<(u16, AffineLoops)>,
 }
 
 /// The rotation and scaling channels of a texture transform, slot 0's loops.
@@ -383,11 +386,36 @@ impl SkyMatLane {
                 lane.tint = Some((slot, seed, tint));
             }
         }
+        // Stage 1: rows only where it moves; row 0 is the identity.
+        if let Some(st) = &sub.stage1 {
+            if let Some(uv) = st.uv_anim.clone() {
+                if let Some(slot) = table.alloc() {
+                    write(materials, &|m| m.extension.stage1.z = f32::from(slot));
+                    lane.stage1_uv = Some((slot, uv));
+                }
+            }
+            if st.uv_rot.is_some() || st.uv_scale.is_some() {
+                if let Some(slot) = table.alloc() {
+                    write(materials, &|m| m.extension.stage1.w = f32::from(slot));
+                    lane.stage1_affine = Some((
+                        slot,
+                        AffineLoops {
+                            rot: st.uv_rot.clone(),
+                            scale: st.uv_scale.clone(),
+                        },
+                    ));
+                }
+            }
+        }
         lane
     }
 
     pub(crate) fn any(&self) -> bool {
-        self.uv.is_some() || self.affine.is_some() || self.tint.is_some()
+        self.uv.is_some()
+            || self.affine.is_some()
+            || self.tint.is_some()
+            || self.stage1_uv.is_some()
+            || self.stage1_affine.is_some()
     }
 
     /// Write this frame's rows: the delta from each seed, quantized as the shared lane does.
@@ -420,6 +448,29 @@ impl SkyMatLane {
                 .map_or([1.0, 1.0], |l| l.sample(l.clock(band_t, gseq_now)));
             table.set(*slot, crate::mat_anim_table::affine_row(q, s));
         }
+        if let Some((slot, a)) = &self.stage1_uv {
+            let v = a.sample(a.clock(band_t, gseq_now));
+            table.set(
+                *slot,
+                [
+                    benilla_assets::quantize(v[0], 4096.0),
+                    benilla_assets::quantize(v[1], 4096.0),
+                    0.0,
+                    0.0,
+                ],
+            );
+        }
+        if let Some((slot, loops)) = &self.stage1_affine {
+            let q = loops
+                .rot
+                .as_ref()
+                .map_or([0.0, 0.0, 0.0, 1.0], |l| l.sample(l.clock(band_t, gseq_now)));
+            let s = loops
+                .scale
+                .as_ref()
+                .map_or([1.0, 1.0], |l| l.sample(l.clock(band_t, gseq_now)));
+            table.set(*slot, crate::mat_anim_table::affine_row(q, s));
+        }
         if let Some((slot, seed, a)) = &self.tint {
             let c = benilla_assets::quant255(a.sample(a.clock(band_t, gseq_now)));
             table.set(