# Sky Decompile Hunt B — D3D Render-State Signature Trace

**Date:** 2026-04-23
**Hunter:** Hunt Agent B (render-state signatures)
**Status:** SIGNIFICANT FINDINGS — but NOT a "celestial-body iteration draw loop"

> **⚠ 2026-04-24 correction:** Any occurrences in this doc that call
> `DAT_00842778` the "ambient" colour are backwards. `DAT_00842778` =
> **DirColor** (directional / sun), `DAT_0084277c` = **AmbColor**,
> `DAT_00842780` = **AmbBright**. Cross-verified against
> `SkyTimeOfDay.Unpack` and `FUN_00501600`'s output mapping. Full
> re-analysis: `docs/research/2026-04-24-lambert-brightness-split.md`.

## TL;DR

The retail acclient does NOT appear to have a classical "sky dome + iterate
celestial meshes with per-mesh blend swaps" render function. Instead, sky
is implemented as:

1. **A per-frame keyframe sampler** (`FUN_005062e0`) that interpolates the
   current RegionDesc keyframe (sun angle, sun color, ambient color, fog
   color/near/far) and stashes results into globals.
2. **Per-mesh ambient color** pushed via `_DAT_008682bc/c0/c4` (RGB floats,
   no D3DRS_AMBIENT call).
3. **D3D fog state** (D3DRS_FOGCOLOR/FOGSTART/FOGEND) set via
   `FUN_005a41b0` — this is the ONLY sky-keyframe → D3D state write path.
4. **A "pre-world" pass** (`FUN_00507a50(0)`) that disables Zwrite and
   iterates weather volume objects (fog/rain/snow, NOT sun/moon/stars).

No "celestial body draw loop" found. No D3DRS_AMBIENT call found. No
matrix-translation-zero (camera-anchor) found. No lightning RNG found.
No huge far-plane constant found at the sky call site. This strongly
suggests retail AC is far simpler than modern sky demos assume — the
sun/moon/stars are either baked into the RegionDesc scene geometry
(treated as regular objects that happen to be positioned far away) or
do not exist as discrete draw calls at all, with "sun color" being
expressed purely via per-vertex lighting on world meshes.

## D3D Vtable Map

All state writes go through `pIDirect3DDevice` at `(param_1 + 0x468)`,
vtable offset `0xe4` = `SetRenderState`, offset `0xd4` = `SetTextureStageState`,
offset `0xc4` = `SetMaterial`, offset `0x1c` (of a PARENT wrapper object at
`DAT_0086734c`) = `SetPerspective/SetFrustum`.

Discovered D3D state wrappers in `chunk_005A0000.c`:

| Wrapper | Addr | D3DRS | Meaning | Cache offset |
|---|---|---|---|---|
| FUN_005a3ba0 | 0x005A3BA0 | 0x1b=27 | ALPHABLENDENABLE | +0x475 |
| FUN_005a3be0 | 0x005A3BE0 | 0x0f=15 | ALPHATESTENABLE | +0x476 |
| FUN_005a3c20 | 0x005A3C20 | 0x19=25 | ALPHAFUNC | +0x478 |
| FUN_005a3c60 | 0x005A3C60 | 0x18=24 | ALPHAREF | +0x47c |
| FUN_005a3ca0 | 0x005A3CA0 | 0x13=19 src, 0x14=20 dst, 0xab=171 op | blend state | +0x4f0/+0x49c |
| FUN_005a3d80 | 0x005A3D80 | 0x16=22 | CULLMODE | +0x488 |
| FUN_005a3dc0 | 0x005A3DC0 | 0xaf=175 | (fog-gated) | +0x48c |
| FUN_005a3e00 | 0x005A3E00 | 7 | ZENABLE | none (stateless) |
| FUN_005a3e20 | 0x005A3E20 | 0x17=23 (ZFUNC) + 0xe=14 (ZWRITE) | combined ZFunc+ZWrite | +0x494/+0x498 |
| FUN_005a3eb0 | 0x005A3EB0 | 0x8b=139 | **AMBIENT** | +0x4a0 |
| FUN_005a3ef0 | 0x005A3EF0 | 0x91=145 | COLORVERTEX | +0x4a8 |
| FUN_005a3f40 | 0x005A3F40 | 0x93=147 | ? | +0x4a4 |
| FUN_005a3f90 | 0x005A3F90 | 0x1c=28 | **FOGENABLE** | +0x4bc |
| FUN_005a4080 | 0x005A4080 | 0x22=34 (FOGCOLOR), 0x24=36 (FOGSTART), 0x25=37 (FOGEND) | fog triple | +0x4ac/+0x4c0/+0x4c4 |
| FUN_005a41b0 | 0x005A41B0 | wrapper → FUN_005a4080 | **SetFog(color, start, end)** | — |
| FUN_005a41f0 | 0x005A41F0 | 0x89=137 | **LIGHTING** | +0x4c8 |
| FUN_005a4280 | 0x005A4280 | 0x92=146 | LOCALVIEWER | +0x4d8 |
| FUN_005a4350 | 0x005A4350 | 0x3c=60 | ? | +0x4e0 |
| FUN_005a4390 | 0x005A4390 | 0x08 | SHADEMODE | +0x4e4 |
| FUN_005a4420 | 0x005A4420 | stages | SetTextureStageState blend args | — |
| FUN_005a4010 | 0x005A4010 | internal flag at +0x4be → re-calls FUN_005a3f90 | **fog-master-enable gate** | +0x4be |

**Device-reset-to-default** function: `FUN_005a10f0` at 0x005A10F0, lines
687-740 of chunk_005A0000.c. This is NOT the sky render; it is called
once on device init and full-state rebuild.

## AMBIENT (D3DRS=0x8b=139) — The Key Negative Finding

I searched every call to vtable `0xe4` with state `0x8b` across the
entire 688K-line decompile. Results:

- chunk_005A0000.c:3388 — `...0x8b,0`  — inside default-init reset
- chunk_005A0000.c:2772 — `...0x8b,param_2` — inside wrapper FUN_005a3eb0

External callers of `FUN_005a3eb0`:

```
chunk_005A0000.c:704:  FUN_005a3eb0(0);   // default-reset, ambient=black
```

**ONLY ONE CALLER.** The sky keyframe sampler (`FUN_005062e0`) does NOT
call `FUN_005a3eb0`. D3DRS_AMBIENT is set to 0 once and never changed.
**This falsifies the previous research hypothesis** (2026-04-22 doc) that
clouds are tinted by a per-keyframe D3DRS_AMBIENT write.

Sky color instead lives in `_DAT_008682bc/c0/c4` (three floats, RGB, set
from `DAT_00842950/54/58`). See below.

## Sky Keyframe Sampler — `FUN_005062e0` @ 0x005062E0

chunk_00500000.c, lines 6213-6333. Called each frame from the scene
renderer (`FUN_00455a50` path, around chunk_00450000.c:4341, 4468).

Stripped pseudocode:

```c
void FUN_005062e0(int worldRenderer) {
  if (worldRenderer.layerBits != 0 && worldRenderer.skyEnabled != 0)
  {
    FUN_00508010();  // advance sky timer
    double now = _DAT_008379a8;  // game-time seconds
    if (_DAT_00842798 <= now && currentRegionDesc != 0) {
      _DAT_00842798 = regionDesc[+0x50].nextKeyTime + now;  // reschedule

      float turbidity = (weatherSys ? weatherSys[+0x48] : _DAT_00795610);
      if (_DAT_008427a0 < now) {
        // ---- BLOCK 1: sample ambient/sun ----
        int ok = FUN_004ff440(turbidity,
                              &fogDensity,  // out float
                              &sunColor,    // out ARGB
                              sunDirVec,    // out float[3]
                              &ambientColor); // out ARGB
        if (ok) {
          if (fogDensity < DAT_0084295c) fogDensity = DAT_0084295c;
          // ---- WEATHER FOG BLEND (if weather active) ----
          if (DAT_008427a9 /* weatherFogEnabled */) {
            if (1.0f <= _DAT_008427b8 /* blendProgress */) {
              // blend complete; snap to weather values
              fogDensity = DAT_008427ac; // weather density
              sunColor   = DAT_00842788; // weather fog color
            } else {
              // lerp currentColor → weatherColor per channel (bytes),
              // lerp density toward DAT_008427ac
              // advance _DAT_008427b8 by _DAT_007c7208 (blend rate)
            }
          }
          FUN_00505f30(fogDensity, sunColor, sunDirVec, ambientColor);
        }
        _DAT_008427a0 = now + (currentRegionDesc ?
                               regionDesc[+0x50].keyInterval : _DAT_007c7200);
      }

      // ---- BLOCK 2: sample fog near/far/color ----
      FUN_005a4010(!DAT_0081dbf8);  // disable fog if master fog flag clear
      if (DAT_0081dbf8) {
        FUN_005a3f90(DAT_0081dbf8); // FOGENABLE = true
        int ok2 = FUN_004ff480(turbidity,
                               &fogNear,  // out float
                               &fogFar,   // out float
                               &fogColor);// out ARGB
        if (ok2) {
          if (DAT_008427a9 /* weatherFogEnabled */) {
            // blend fogNear, fogFar, fogColor toward weather values
            // identical lerp structure
          }
          FUN_005a41b0(&fogColor, fogNear, fogFar);
          // → SetRenderState(FOGCOLOR, ...), (FOGSTART, ...), (FOGEND, ...)
        }
      }
    }
  }
}
```

This is the ONLY per-frame writer of fog D3D state. Called by
`FUN_00455a50` (scene entry) via `FUN_00506270` etc.

## Block-1 Keyframe Layout — `FUN_00501600` @ 0x00501600

chunk_00500000.c, lines 1151-1232. Decoded keyframe struct:

| Offset | Field | Type | Notes |
|---|---|---|---|
| +0x04 | SunMagnitude | float | lerp → param_4 (radius) |
| +0x08 | SunYAngle | float | degrees; `* (π/180)` gives radians |
| +0x0c | SunZAngle | float | degrees; `* (π/180)` gives radians |
| +0x10–0x12 | AmbientColor | byte[3] | R,G,B (packed via byte-shuffles) |
| +0x14 | FogDensity | float | lerp → param_2 |
| +0x18–0x1a | SunColor | byte[3] | R,G,B |

From chunk_00500000.c:1190-1216:

```c
// out sunDirVec (param_4):
fVar9 = lerp(nextKey[+0x04], prevKey[+0x04], param_1);  // magnitude
float sinAngY = lerp(nextKey[+0x08], prevKey[+0x08]) * DEG2RAD;
float sinAngZ = lerp(nextKey[+0x0c], prevKey[+0x0c]) * DEG2RAD;
float cosY = cos(sinAngY);
float sinY = sin(sinAngY);
float cosZ = cos(sinAngZ);
float sinZ = sin(sinAngZ);
param_4[0] = fVar9 * sinZ * cosY;
param_4[1] = fVar9 * cosZ * cosY;
param_4[2] = fVar9 * sinY;

// out sunColor ARGB (param_3):  from bytes at +0x18,0x19,0x1a
// out ambientColor ARGB (param_5):  from bytes at +0x10,0x11,0x12
```

(The repeated `FUN_005df4c4()` calls with no args are Ghidra's artifact
for a union/reinterpret-cast byte shuffle — they are NOT an RNG and NOT
a lightning modulator.)

## Block-2 Keyframe Layout — `FUN_00501860` @ 0x00501860

chunk_00500000.c, lines 1236-1268. Second block of the keyframe struct:

| Offset | Field | Type | Notes |
|---|---|---|---|
| +0x20 | FogNear | float | |
| +0x24 | FogFar | float | |
| +0x28–0x2a | FogColor | byte[3] | R,G,B |

## Apply-Block-1 — `FUN_00505f30` @ 0x00505F30

chunk_00500000.c, lines 6026-6092. Stores the sampled values into global
cache and into the `_DAT_008682bc/c0/c4` "per-vertex ambient" slot:

```c
DAT_00842780 = fogDensity;      // param_2
DAT_0084277c = sunColor;        // param_3 (ARGB)
DAT_00842950 = sunDir[0];       // param_4[0]
DAT_00842954 = sunDir[1];
DAT_00842958 = sunDir[2];
DAT_00842778 = ambientColor;    // param_5 (ARGB)

_DAT_008682c8 = sunDir[0];      // duplicated
_DAT_008682d0 = sunDir[2];
_DAT_008682cc = sunDir[1];
FUN_00451a60(&_something, ambientColor);  // unpacks ARGB → 3 floats
_DAT_008682bc = unpacked R;     // RGB ambient floats for mesh lighting
_DAT_008682c0 = unpacked G;
_DAT_008682c4 = unpacked B;
DAT_008682d4 = 0;               // ambient dirty flag
```

**`_DAT_008682bc/c0/c4` is the THING the sky tints the world with.**
It is consumed per-vertex by mesh-draw, not by a D3D state write.

## Candidate "Sky Pass" — `FUN_00507a50` @ 0x00507A50

chunk_00500000.c, lines 7250-7299.

```c
void FUN_00507a50(weatherMgr, phase) {
  if ((FUN_00451ec0() || phase == 0)) {  // skyEnabled or pass-0
    weatherMgr.renderingFlag = 1;
    char oldAlpha = FUN_005a1560();
    FUN_005a3f90(DAT_008427a9 != '\0');     // FOGENABLE ← weatherFog flag
    float oldFar = DAT_0081fc98;
    FUN_0054bf30(DAT_0081fc98 * _DAT_007c6f14);  // multiply far plane
    FUN_005a3e20(8, 0);                      // ZFUNC=ALWAYS, ZWRITE=0
    if (phase == 0) {
      // iterate weather volume objects (rain/snow/fog cells)
      for (uint i = 0; i < weatherMgr.count; ++i) {
        int obj = *(int*)(weatherMgr.pArray + i*4);
        uint flags = *(uint*)(weatherMgr.pFlags + i*4);
        if (obj && !(flags & 1) &&
            (DAT_0081dbf9 || !(flags & 4)) &&
            (!DAT_008427a9 || !FUN_005a1560() || !(flags_byte & 2)))
        {
          FUN_00511720(obj);   // scene-graph walk (update per-frame)
          FUN_00511760(obj);   // scene-graph walk (draw)
        }
      }
    } else if (DAT_0081dbf9) {
      // phase 1: just let the device callback at +0x64 run
      (**(code **)(*DAT_00870340 + 0x64))(weatherMgr[+0x28]);
    }
    FUN_0054bf30(oldFar);                    // restore far plane
    FUN_005a3e20(4, 1);                      // ZFUNC=LESSEQUAL, ZWRITE=1
    FUN_005a3f90(oldAlpha);                  // restore FOGENABLE
    weatherMgr.renderingFlag = 0;
  }
}
```

Called by `FUN_00506d90` (chunk_00500000.c:6683):

- `FUN_00507a50(0)` = phase-0 (sky-ish volume draw, before terrain/entity)
- `FUN_00507a50(1)` = phase-1 (post-draw overlay, gated by weather flag)

The `DAT_0081fc98 * _DAT_007c6f14` line IS the far-plane multiplier —
however `_DAT_007c6f14` here is ambiguous, used elsewhere as a small
rotation coefficient (chunk_005E0000.c:258 etc). This deserves a
follow-up: check if that DAT is a configurable sky-far-plane multiplier
or a recycled constant.

**No matrix-translation-zero (camera-anchor) is present in this
function.** The scene graph objects iterated via `FUN_00511720/60` are
rain/snow/fog-shaft volumes — they are positioned in world space and
expected to follow the camera via normal scene-graph propagation.

**No per-mesh blend swap (alpha for clouds vs additive for sun) is
present.** Blend mode is set once for the whole pass.

## Fog Write Path — SUMMARY

The complete trail:

1. `FUN_00505f30` stores sun/ambient globals (no D3D call).
2. `FUN_005062e0` lerps current-keyframe fog → weather-fog if needed.
3. `FUN_005a41b0(&fogColor, fogNear, fogFar)` →
4. `FUN_005a4080(pFogColor_as_ARGB, near, far)` →
5. Writes D3DRS_FOGCOLOR=0x22, D3DRS_FOGSTART=0x24, D3DRS_FOGEND=0x25.

Fog ENABLE is wrapped by `FUN_005a4010` (master gate at +0x4be) +
`FUN_005a3f90` (actual D3DRS_FOGENABLE=0x1c write). Both driven by
the DAT_0081dbf8 master-fog flag.

**D3DRS_FOGTABLEMODE=0x23, FOGVERTEXMODE=0x8c, FOGDENSITY=0x26** —
these are only set once in the default-init (`FUN_005a10f0`) and never
per-frame. Retail uses linear fog (FOGSTART/FOGEND), not exponential
(FOGDENSITY).

## Lightning Flash — NOT FOUND

Searched for:

- `FUN_005df4c4` (the RNG/byte-shuffle) — all hits are byte-packing
  for ARGB color interpolation, not random modulation.
- `_DAT_008427b8` — it's a weather-fog-blend progress (0 → 1 ramp),
  not a per-frame random value.
- Time-based sine/cos on small periods — none found coupled to sky
  color.
- Any RNG call near fog/ambient writes — none found.

**Lightning is likely a separate system not found in this hunt, OR
does not exist in retail and is purely decorative in modern ports.**

## Matrix-Anchor (Camera-Centered Sky) — NOT FOUND

Searched for patterns like:

- `*(undefined4*)(mat + 0x30) = 0;`
- `SetTransform(D3DTS_VIEW=2, ...)` via any vtable offset
- A matrix copy that zeroes three consecutive 4-byte fields

Nothing found anchored to the sky pass. The view matrix is NOT rewritten
with zero translation before the sky draw. This is consistent with the
conclusion that there is no discrete "sky dome" — the weather/fog volume
objects follow the camera by being placed in camera-relative world
position by their parent scene-graph node.

## Huge Far-Plane Constants — NOT FOUND

Searched for:

- 0x49742400 (1e6f) — no hits
- 0x47c35000 (1e5f) — no hits
- 0x4b189680 (1e7f) — no hits

The only far-plane modulator is `DAT_0081fc98 * _DAT_007c6f14` at
chunk_00500000.c:7272. Without knowing `_DAT_007c6f14`'s numeric value
from a debugger or disassembly of `.rdata`, we can't tell if this is
>>1 (sky-far-plane multiplier) or ~1 (no-op). A follow-up
disassembly of the address `0x007c6f14` should nail this down.

## D3D State Inventory — Sky-Relevant Per-Frame Writes

Only four D3D states are written per-frame in the sky-adjacent code path:

| State | Hex | Name | Writer | Source of value |
|---|---|---|---|---|
| 34 | 0x22 | FOGCOLOR | `FUN_005a4080` | current keyframe+weather lerp |
| 36 | 0x24 | FOGSTART | `FUN_005a4080` | current keyframe+weather lerp |
| 37 | 0x25 | FOGEND | `FUN_005a4080` | current keyframe+weather lerp |
| 28 | 0x1c | FOGENABLE | `FUN_005a3f90` | `DAT_0081dbf8` / weather flag |

Plus, inside `FUN_00507a50` (phase-0 weather-volume draw only):

| State | Hex | Name | Value |
|---|---|---|---|
| 23+14 | 0x17+0x0e | ZFUNC + ZWRITE | ALWAYS + OFF → restore LESSEQUAL + ON |

## Gaps / Unresolved

1. **The classical sky dome / celestial body draw** — NOT FOUND. Either
   retail literally does not have one (sky is just a clear-color glimpse
   plus fog between camera and terrain), or it's hidden inside the
   RegionDesc.Scene entries and rendered as a regular object through the
   normal scene-graph path.
2. **`_DAT_007c6f14`** — used as a far-plane multiplier in the sky pass,
   but cross-referenced use in chunks 0x5E0000 suggests it's a unit-scale
   float (< 10). Needs raw `.rdata` dump to confirm its value.
3. **Is `_DAT_008682bc/c0/c4` consumed by D3D material or per-vertex
   color?** The writers are clear; the readers need a separate hunt
   (likely in chunk_00590000.c or the mesh-draw path at `FUN_0054c9c0`).
4. **Lightning flash** — not found in the keyframe/fog paths. If it
   exists, it's in a separate code path (maybe tied to weather presets
   6 "thunderstorm" — DAT_008427a9=1 case in chunk_00550000.c:11886).

## Files / Addresses cited (all absolute paths)

- `C:\Users\erikn\source\repos\acdream\docs\research\decompiled\chunk_005A0000.c`
  - lines 687-740: `FUN_005a10f0` device reset (AMBIENT=0 here, only caller)
  - lines 2606-3035: D3D state wrapper zoo (all vtable-0xe4 writers)
  - lines 2868-2907: `FUN_005a4080` = SetFog triple
  - lines 2911-2921: `FUN_005a41b0` = SetFog wrapper
  - lines 3346-3400: default state-init defaults
  - lines 3860-3970: `FUN_005a5950` world-scene top-level renderer
- `C:\Users\erikn\source\repos\acdream\docs\research\decompiled\chunk_00500000.c`
  - lines 1151-1232: `FUN_00501600` Block-1 keyframe sampler
  - lines 1236-1268: `FUN_00501860` Block-2 (fog) keyframe sampler
  - lines 6026-6092: `FUN_00505f30` apply-keyframe-1 to globals
  - lines 6213-6333: `FUN_005062e0` per-frame sky+fog update (MAIN)
  - lines 6683-6708: `FUN_00506d90` scene renderer (calls sky phase 0/1)
  - lines 7250-7299: `FUN_00507a50` the phase-0 weather-volume draw
- `C:\Users\erikn\source\repos\acdream\docs\research\decompiled\chunk_00450000.c`
  - lines 608-622: `FUN_00451a60` ARGB → 3-float unpack
  - lines 4300-4479: per-landblock ambient setup (`_DAT_008682bc` writers)
- `C:\Users\erikn\source\repos\acdream\docs\research\decompiled\chunk_00550000.c`
  - lines 11835-12016: `FUN_0055eb40` weather-preset-id → fog constants
    (0=clear, 1=light rain, 2=medium, 3=heavy, 4=blizzard, 5=?, 6=thunderstorm)
- `C:\Users\erikn\source\repos\acdream\docs\research\decompiled\chunk_004F0000.c`
  - lines 10692-10720: `FUN_004ff440` / `FUN_004ff480` keyframe trampolines

## Recommendation for acdream port

Given these findings, our C# SkyRenderer should:

1. **Stop expecting a celestial-body draw loop in the decompile** — Hunt A
   will likely confirm via the Region-loader angle.
2. **Port the keyframe sampler faithfully** from `FUN_00501600` / 1860 —
   the struct layout above is the ground truth for RegionDesc keyframe
   blobs.
3. **Apply the sun direction and colors to world-mesh vertex lighting**,
   not to a D3DRS_AMBIENT equivalent. The values live in
   `_DAT_008682bc/c0/c4` and are consumed by the mesh pipeline.
4. **Set fog via SetFog(color, start, end) + FogEnable** per frame from
   the Block-2 sample. This matches `FUN_005a41b0`.
5. **Do NOT add a matrix translation-zero** — retail does not anchor the
   sky dome, because retail does not appear to HAVE a sky dome draw in
   the D3D state sense. If acdream renders a dome mesh, it's a modern
   addition.
6. **Tint clouds (if rendered) via the per-mesh ambient global**, not
   via the current uniform-one approach. The previous research doc's
   conclusion on "clouds multiply by ambient" is likely correct in
   spirit — just know that "ambient" here means
   `_DAT_008682bc/c0/c4`, not D3DRS_AMBIENT.
