@forgeax/engine-shader 0.1.2

package/src/pbr-temporal.wgsl

@@ -0,0 +1,73 @@
+#define_import_path forgeax_pbr::temporal
+
+#import forgeax_view::common::{sampleMaterialTexture, packSceneTemporal}
+
+fn transformedPbrTemporalUv(
+  transform : vec4<f32>,
+  metadata : vec4<f32>,
+  uv0 : vec2<f32>,
+  uv1 : vec2<f32>,
+  uv2 : vec2<f32>,
+  uv3 : vec2<f32>,
+  uv4 : vec2<f32>,
+  uv5 : vec2<f32>,
+  uv6 : vec2<f32>,
+  uv7 : vec2<f32>,
+) -> vec2<f32> {
+  var source = uv0;
+  if (metadata.x >= 1.0) { source = uv1; }
+  if (metadata.x >= 2.0) { source = uv2; }
+  if (metadata.x >= 3.0) { source = uv3; }
+  if (metadata.x >= 4.0) { source = uv4; }
+  if (metadata.x >= 5.0) { source = uv5; }
+  if (metadata.x >= 6.0) { source = uv6; }
+  if (metadata.x >= 7.0) { source = uv7; }
+  let scaled = source * transform.zw;
+  let angle = metadata.y;
+  let c = cos(angle);
+  let s = sin(angle);
+  return vec2<f32>(scaled.x * c - scaled.y * s, scaled.x * s + scaled.y * c) + transform.xy;
+}
+
+fn projectPbrSceneTemporal(
+  baseColorAlpha : f32,
+  alphaCutoff : f32,
+  baseColorTexture : texture_2d<f32>,
+  baseColorSampler : sampler,
+  transform : vec4<f32>,
+  metadata : vec4<f32>,
+  currentClip : vec4<f32>,
+  previousClip : vec4<f32>,
+  reactive : f32,
+  uv0 : vec2<f32>,
+  uv1 : vec2<f32>,
+  uv2 : vec2<f32>,
+  uv3 : vec2<f32>,
+  uv4 : vec2<f32>,
+  uv5 : vec2<f32>,
+  uv6 : vec2<f32>,
+  uv7 : vec2<f32>,
+) -> vec4<f32> {
+  let baseUv = transformedPbrTemporalUv(
+    transform,
+    metadata,
+    uv0,
+    uv1,
+    uv2,
+    uv3,
+    uv4,
+    uv5,
+    uv6,
+    uv7,
+  );
+  let baseSample = sampleMaterialTexture(
+    baseColorTexture,
+    baseColorSampler,
+    baseUv,
+    metadata.zw,
+  );
+  if (alphaCutoff > 0.0 && baseColorAlpha * baseSample.a <= alphaCutoff) {
+    discard;
+  }
+  return packSceneTemporal(currentClip, previousClip, reactive);
+}

package/src/register-default-sprite-lit.ts

@@ -0,0 +1,87 @@
+// @forgeax/engine-shader - registerDefaultSpriteLit helper.
+//
+// feat-20260624-sprite-lit-shading-model-pure-2d-lighting M1' / w4
+// (plan-strategy D-10 application registration path).
+//
+// Mirrors registerDefaultStandardPbrSkin (same package; identical
+// registration shape). paramSchema mirrors sprite.material.json minus
+// PBR-only fields; the BGL is derived from paramSchema via
+// `derive(paramSchema).bglEntries` inside the runtime pipeline-builder.
+//
+// Anchors:
+//   - requirements section 2 #2 / #10 (sprite-lit.wgsl new + 4 BGL byte-identical)
+//   - plan-strategy D-3 (sprite-lit single Half-Lambert formula lock)
+//   - plan-strategy D-5 (STORAGE_BUFFER_AVAILABLE variant axis day-1)
+//   - plan-strategy D-6 (4 PBR-unused slots default sampler + white tex)
+//   - plan-strategy D-10 (application registration path)
+
+import type { ShaderRegistry } from './index.js';
+import { DEFAULT_SPRITE_PARAM_SCHEMA } from './material-schemas.js';
+
+/**
+ * paramSchema for forgeax::sprite-lit -- mirrors sprite.material.json
+ * exactly (same 5 fields: colorTint / region / pivotAndSize /
+ * slicesAndMode / baseColorTexture). sprite-lit and sprite share the
+ * same Material UBO layout byte-for-byte so the host-side
+ * SpriteMaterialAsset writer + 4 BGL JSON are byte-identical (AC-07).
+ *
+ * OOS-1 (feat-future-sprite-lit-normal-map) will extend this with
+ * normalTexture + normalStrength. M1' deliberately keeps the schema
+ * byte-identical to sprite so AC-13 "1 string-change between sprite
+ * and sprite-lit materials" is provably the only delta required.
+ */
+const RESERVED_ID = 'forgeax::sprite-lit' as const;
+
+/**
+ * Caps shape exposed for sprite-lit registration. Currently only
+ * `storageBuffer` matters (STORAGE_BUFFER_AVAILABLE variant axis); the
+ * per-shader BGL is derived from paramSchema at pipeline-build time, so
+ * the runtime layout factory consumes this caps shape downstream.
+ *
+ * Kept as a separate type rather than reusing `SkinCaps` to preserve
+ * a clear contract surface; the structural shape is currently identical
+ * but future divergence (sprite-lit may opt in to OOS-7 cluster-forward
+ * later) should not silently leak via a shared type.
+ */
+export interface SpriteLitCaps {
+  readonly storageBuffer: boolean;
+}
+
+/**
+ * Register the engine-shipped `forgeax::sprite-lit` material shader in
+ * the ShaderRegistry. Must be called once at engine boot (createRenderer),
+ * after `ShaderRegistry.loadManifest()` has completed.
+ *
+ * The `composedWgsl` parameter is the post-naga_oil composed WGSL source,
+ * compiled by @forgeax/engine-vite-plugin-shader at build time and surfaced
+ * in manifest.json. The caller reads it from the manifest entries.
+ *
+ * `caps.storageBuffer` switches the runtime BGL buffer types for
+ * @group(0) bindings 1+2 (pointLightsBuffer / spotLightsBuffer):
+ * `false` -> uniform fallback (AC-10 WebGL2 path); `true` -> read-only-storage.
+ * The BGL itself is built downstream in runtime/pbr-pipeline.ts (sprite-lit
+ * reuses pbr-view / pbr-mesh-array / pbr-instances unchanged; AC-07
+ * BGL byte-identical).
+ *
+ * @param registry ShaderRegistry instance (engine boot path).
+ * @param composedWgsl Post-naga_oil composed WGSL source string.
+ * @param caps sprite-lit caps (storageBuffer boolean) for BGL entry type selection.
+ *
+ * Throws if the identifier is already registered (fail-fast per
+ * ShaderRegistry.installMaterialArtifact contract).
+ */
+export function registerDefaultSpriteLit(
+  registry: ShaderRegistry,
+  composedWgsl: string,
+  caps: SpriteLitCaps,
+): void {
+  // The caps argument is retained for API symmetry with
+  // registerDefaultStandardPbrSkin -- equivalent caps gating lives in
+  // buildPbrPipelineLayouts since the per-shader BGL is paramSchema-derived
+  // and the storage-vs-uniform branching is a runtime-level concern.
+  void caps;
+  registry.installMaterialArtifact(RESERVED_ID, {
+    source: composedWgsl,
+    paramSchema: DEFAULT_SPRITE_PARAM_SCHEMA,
+  });
+}

package/src/register-default-standard-pbr-skin.ts

@@ -0,0 +1,74 @@
+// @forgeax/engine-shader - registerDefaultStandardPbrSkin helper.
+//
+// feat-20260523-skin-skeleton-animation M3 / T-30; updated by
+// feat-20260613-material-paramschema-driven-binding M3 / w13: the
+// bindingLayout sidecar field has been removed from MaterialShaderEntry;
+// the BGL is derived from paramSchema via `derive(paramSchema).bglEntries`
+// inside the runtime pipeline-builder. paramSchema remains shared with
+// default-standard-pbr (identical PBR material interface).
+//
+// Anchors:
+//   - plan-strategy D-3: register independent WGSL template for skin variant
+//   - plan-strategy D-1 / D-2: paramSchema is the single source of truth
+//   - R-10: paramSchema reuses default-standard-pbr schema (same params)
+
+import type { ShaderRegistry } from './index.js';
+import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from './material-schemas.js';
+
+/**
+ * paramSchema for forgeax::pbr-skin — mirrors default-standard-pbr 8 fields.
+ * Previously sourced from default-standard-pbr.schema.json; now inlined because
+ * the .schema.json file has been deleted (feat-20260528-material-shader-registration-unification M1/w4).
+ * The SSOT is default-standard-pbr.material.json paramSchema[].
+ */
+const RESERVED_ID = 'forgeax::pbr-skin' as const;
+
+/**
+ * Caps shape historically consumed by the pbr-skin BGL builder. The
+ * BGL builder itself moved to runtime/pbr-pipeline.ts (buildPbrSkinLayouts);
+ * this type is preserved as the public registration-API contract so
+ * existing callers compile unchanged. M3 / w13: per-shader BGL is
+ * derived from paramSchema; the storage-buffer-vs-uniform branching
+ * the BGL needs lives entirely in the runtime layout factory.
+ */
+export interface SkinCaps {
+  readonly storageBuffer: boolean;
+}
+
+/**
+ * Register the engine-shipped `forgeax::pbr-skin` material shader in the
+ * ShaderRegistry. Must be called once at engine boot (createRenderer), after
+ * `ShaderRegistry.loadManifest()` has completed.
+ *
+ * The `composedWgsl` parameter is the post-naga_oil composed WGSL source,
+ * compiled by @forgeax/engine-vite-plugin-shader at build time and surfaced
+ * in manifest.json. The caller reads it from the manifest entries.
+ *
+ * `caps.storageBuffer` switches the runtime BGL buffer types:
+ * `false` -> uniform fallback; `true` -> read-only-storage. The BGL itself
+ * is built downstream in runtime/pbr-pipeline.ts (M3 / w13).
+ *
+ * @param registry ShaderRegistry instance (engine boot path).
+ * @param composedWgsl Post-naga_oil composed WGSL source string.
+ * @param caps PBR caps (storageBuffer boolean) for BGL entry type selection.
+ *
+ * Throws if the identifier is already registered (fail-fast per
+ * ShaderRegistry.installMaterialArtifact contract).
+ */
+export function registerDefaultStandardPbrSkin(
+  registry: ShaderRegistry,
+  composedWgsl: string,
+  caps: SkinCaps,
+): void {
+  // M3 / w13 (D-1 / D-2): bindingLayout sidecar deleted from
+  // MaterialShaderEntry; paramSchema is the SSOT and downstream
+  // pipeline-builder reads `derive(paramSchema).bglEntries` on demand.
+  // The `caps` argument is retained for API compat — historically it
+  // selected the storage-buffer vs uniform-buffer skin variant of the
+  // BGL; equivalent caps gating now lives in buildPbrSkinLayouts.
+  void caps;
+  registry.installMaterialArtifact(RESERVED_ID, {
+    source: composedWgsl,
+    paramSchema: DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+  });
+}

package/src/shadow-pcf.wgsl

@@ -0,0 +1,120 @@
+#define_import_path forgeax_pbr::shadow_pcf
+
+// @forgeax/engine-shader - shadow-pcf.wgsl
+// feat-20260612-point-light-shadows-urp-hdrp M2 / T-M2-1 (plan-strategy D-4).
+//
+// Shared PCF (percentage-closer filtering) for directional and point-light
+// shadow sampling. Single SSOT for the slope-scaled bias formula and 9-tap 3x3
+// kernel-offset table. Directional shadows (2D) and point-light shadows
+// (cube_array) each have their own wrapper function; the bias formula and
+// offset table are shared.
+//
+// Exports:
+//   - PCF_OFFSETS: const array<vec2<i32>, 9> — 3x3 kernel offset table
+//   - sample_shadow_2d(...) -> f32 — directional 2D 9-tap software PCF
+//   - sample_shadow_cube_hw2x2(...) -> f32 — point cube hardware 2x2 PCF
+//
+// Bias formula (D-1 directional convention -- normalBias is the slope
+// coefficient, depthBias the floor; feat-20260621 m3-t5 rename):
+//   bias = max(normalBias * (1.0 - dot(N, L)), depthBias / 1000.0)
+//
+// Return: 1.0 = fully lit, 0.0 = fully shadowed.
+
+// 3x3 integer offset table for PCF kernel (9 taps).
+// Extracted from lighting-directional.wgsl inline loop (T-M2-4);
+// `sample_shadow_2d` walks all 9 taps; `sample_shadow_cube_hw2x2` does NOT
+// use this table (cubemap sampling has no UV parameterization across face
+// seams — see Round-2 F-2 finding).
+const PCF_OFFSETS = array<vec2<i32>, 9>(
+  vec2<i32>(-1, -1), vec2<i32>( 0, -1), vec2<i32>( 1, -1),
+  vec2<i32>(-1,  0), vec2<i32>( 0,  0), vec2<i32>( 1,  0),
+  vec2<i32>(-1,  1), vec2<i32>( 0,  1), vec2<i32>( 1,  1),
+);
+
+// === 2D directional-shadow wrapper ============================================
+//
+// `shadowMap` and `shadowSampler` are @group(0) @binding(3/4) from
+// forgeax_view::common. `uv` is the [0,1]^2 projected light-clip coordinate.
+// `texel` is 1.0 / textureDimensions(shadowMap, 0) precomputed by the caller.
+//
+// The caller must perform the OOB gate `uv in [0,1] && depthRef <= 1.0` before
+// calling this function; OOB returns fully lit (1.0) upstream.
+
+fn sample_shadow_2d(
+  shadowMap    : texture_depth_2d,
+  shadowSampler: sampler_comparison,
+  uv           : vec2<f32>,
+  texel        : vec2<f32>,
+  depthRef     : f32,
+  normalBias   : f32,
+  depthBias    : f32,
+  nDotL        : f32,
+) -> f32 {
+  // feat-20260621-merge-directionallightshadow-into-directionallight M3 / m3-t5:
+  // param names aligned to the D-1 directional convention -- the slope
+  // coefficient is `normalBias` (scales the 1 - dot(N,L) term) and the floor is
+  // `depthBias`. Pure formal-parameter rename: the two names are swapped in BOTH
+  // the signature and the formula, so each positional argument keeps its prior
+  // role and all call sites are unaffected. The /1000.0 floor scaling is the
+  // existing point-light convention and is preserved.
+  let bias = max(normalBias * (1.0 - nDotL), depthBias / 1000.0);
+  let adjustedDepth = depthRef - bias;
+
+  // 9-tap 3x3 PCF kernel. textureSampleCompareLevel returns 1.0 when
+  // adjustedDepth < sampledDepth (sampler compare op = 'less'), 0.0 otherwise.
+  // Sampler uses clamp-to-edge wrap so OOB texels return the nearest border value.
+  var blocked = 0.0;
+  for (var i = 0u; i < 9u; i++) {
+    let off = PCF_OFFSETS[i];
+    let offsetUv = uv + vec2<f32>(f32(off.x), f32(off.y)) * texel;
+    let lit = textureSampleCompareLevel(shadowMap, shadowSampler, offsetUv, adjustedDepth);
+    blocked = blocked + (1.0 - lit);
+  }
+  return 1.0 - blocked / 9.0;
+}
+
+// === Cube point-light-shadow wrapper =========================================
+//
+// `shadowAtlas` is @group(0) @binding(5) texture_depth_cube_array.
+// `shadowSampler` is @group(0) @binding(4) sampler_comparison (shared with
+// directional shadows — same sampler type, no dimension distinction).
+// `lightLocal` is the fragment-to-light direction vector in the cubemap's
+// coordinate system (Bevy convention: left-handed cubemap; caller applies
+// flip_z = vec3(1,1,-1) to convert right-hand world to left-hand cubemap).
+// `layer` is the cube_array layer index (i32; 0..3 for 4 shadow-casting
+// point lights; sentinel -1 must be gated upstream — this function assumes
+// a valid layer).
+// `depthRef` is the reconstructed [0,1] NDC depth (largest-axis projection,
+// research L0.5 Bevy fetch_point_shadow pattern).
+//
+// Hardware 2x2 PCF only: 2D texel offsets from PCF_OFFSETS have no direct 3D
+// cubemap mapping (no UV parameterization across face seams). A previous
+// 9-tap loop using the same cubemap direction every iteration was algorithmic
+// dead code — every iteration returned the same `lit` value, so 9-tap = 1-tap
+// (Reviewer F-2). This single call lets the GPU's silicon-level 2x2 PCF
+// resolve the local neighborhood within each face natively. Matches Bevy's
+// HARDWARE_2X2 path (research L0.6) and README §AC-11 default. Software 9-tap
+// on cubemaps requires face-basis vector offsets and is OOS-3 here.
+
+fn sample_shadow_cube_hw2x2(
+  shadowAtlas   : texture_depth_cube_array,
+  shadowSampler : sampler_comparison,
+  lightLocal    : vec3<f32>,
+  layer         : i32,
+  depthRef      : f32,
+  normalBias    : f32,
+  depthBias     : f32,
+  nDotL         : f32,
+) -> f32 {
+  // Slope-scaled bias: same formula as 2D path, shared SSOT. feat-20260621 M3 /
+  // m3-t5: param names aligned to D-1 (normalBias = slope coefficient,
+  // depthBias = floor). Pure rename -- each positional arg keeps its prior role.
+  let bias = max(normalBias * (1.0 - nDotL), depthBias / 1000.0);
+  let adjustedDepth = depthRef - bias;
+
+  // Single textureSampleCompareLevel call: the comparison sampler resolves a
+  // 2x2 PCF neighborhood at the silicon level; clamp-to-edge address mode
+  // handles face-boundary texel fetches. Returns 1.0 = fully lit, 0.0 = fully
+  // shadowed.
+  return textureSampleCompareLevel(shadowAtlas, shadowSampler, lightLocal, layer, adjustedDepth);
+}

package/src/shadow_caster.wgsl

@@ -0,0 +1,54 @@
+#pragma variant_axis STORAGE_BUFFER_AVAILABLE
+
+// @forgeax/engine-shader shadow_caster.wgsl
+// feat-20260520-directional-light-shadow-mapping M1c / w9 (D-9 / AC-09):
+// vertex-only depth pass for directional shadow map. No fragment stage --
+// the GPU writes depth automatically from gl_Position.z (depth32float RT).
+//
+// feat-20260613-csm-cascaded-shadow-maps M5 / w28: per-cascade
+// lightViewProj selection. Each cascade pass writes a different
+// `shadowCasterCascade.index` (0..3) before encoder submit; the vertex
+// shader reads it to pick `view.lightViewProj_A..D`. The atlas tile UV
+// inset is already baked into each lightViewProj host-side
+// (render-system-extract.ts), so the per-cascade viewport on the depth
+// pass clips rasterization to the correct atlas tile while the matrix
+// itself maps NDC straight into atlas-space [0,1]^2.
+//
+// Reuses:
+//   @group(0) binding(0) view : View                 -- common.wgsl
+//   @group(0) binding(5) shadowCasterCascade         -- common.wgsl
+//   @group(2) binding(0) meshes : array<Mesh>        -- common.wgsl
+//   @group(3) binding(0) instances : array<InstanceData>  -- common.wgsl
+//
+// Vertex layout: matches the 12F procedural layout of every mesh
+// (position vec3, normal vec3, uv vec2, tangent vec4; 48 B stride).
+
+#import forgeax_view::common::{View, Mesh, InstanceData, ShadowCasterCascade, view, shadowCasterCascade, meshes, instances}
+
+struct VsInput {
+  @location(0) position : vec3<f32>,
+};
+
+fn _cascadeLightViewProj(layer : u32) -> mat4x4<f32> {
+  switch (layer) {
+    case 0u: { return view.lightViewProj_A; }
+    case 1u: { return view.lightViewProj_B; }
+    case 2u: { return view.lightViewProj_C; }
+    default: { return view.lightViewProj_D; }
+  }
+}
+
+@vertex
+fn vs_main(in : VsInput, @builtin(instance_index) idx : u32) -> @builtin(position) vec4<f32> {
+  let worldPos = meshes[0].worldFromLocal * instances[idx].localFromInstance * vec4<f32>(in.position, 1.0);
+  // feat-20260625-spot-light-shadow-mapping M2 / w10 (D-1): spot shadow passes
+  // set `isSpot = 1u` and write their perspective matrix into
+  // `spotLightViewProj`; directional cascade passes keep `isSpot = 0u` and read
+  // `view.lightViewProj_A..D` via `index`. Routing on the discriminant keeps
+  // the spot matrix out of the directional View UBO (no same-frame contention).
+  if (shadowCasterCascade.isSpot == 1u) {
+    return shadowCasterCascade.spotLightViewProj * worldPos;
+  }
+  let lvp = _cascadeLightViewProj(shadowCasterCascade.index);
+  return lvp * worldPos;
+}

package/src/skybox.wgsl

@@ -0,0 +1,75 @@
+#define_import_path forgeax_view::skybox
+
+// @forgeax/engine-shader - skybox.wgsl
+// (feat-20260531-skybox-env-background / M3 / w13).
+//
+// Skybox fullscreen pass: vertex stage imports the SSOT fullscreen_triangle()
+// from forgeax_view::common (same single-large-triangle pattern as tonemap +
+// fxaa); fragment stage reconstructs world-space view direction from the
+// screen-space UV + inverseViewProj (View UBO, w3), samples the cubemap
+// texture, and writes HDR colour to the hdrColor rgba16float render target
+// (plan-strategy D-2/D-7).
+//
+// Y-negation: the equirect-to-cube render passes used during cubemap upload
+// follow the WebGL/OpenGL convention (Y-up in world space maps to V=0 at
+// the bottom of the cubemap face). WebGPU's texture coordinate origin is
+// top-left (V=0 at the top), so sampled directions must negate Y to match
+// the same convention used by ibl-sampling.wgsl (plan-strategy R-4, D-7).
+//
+// Bindings (group 0):
+//   @binding(0) cubemap       : texture_cube<f32>    // skybox environment map
+//   @binding(1) cubemapSampler : sampler             // linear filter + clamp-to-edge
+//   @binding(2) view          : View (UBO)           // carries inverseViewProj (w3)
+//   @binding(3) rotation      : SkyboxRotation (UBO)
+
+#import forgeax_view::common::FullscreenOutput
+#import forgeax_view::common::{View, FogViewParams, FogRay}
+#import forgeax_view::common::fullscreen_triangle
+#import forgeax_view::fog::{apply_fog}
+#import forgeax_pbr::ibl_shared::{inverseRotateEnvironment}
+
+@group(0) @binding(0) var cubemap       : texture_cube<f32>;
+@group(0) @binding(1) var cubemapSampler : sampler;
+@group(0) @binding(2) var<uniform> view : View;
+
+struct SkyboxRotation {
+  rotation: vec4<f32>,
+};
+
+@group(0) @binding(3) var<uniform> environment : SkyboxRotation;
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index : u32) -> FullscreenOutput {
+  return fullscreen_triangle(vertex_index);
+}
+
+// Reconstruct world-space view direction from screen UV + inverseViewProj.
+// clipPos.xy derived from screen-space UV, clipPos.w = 1, apply
+// inverseViewProj to get world-space direction. Negate Y to match the
+// IBL cubemap Y convention (ibl-sampling.wgsl:30,47).
+//
+// bug-20260608-skybox-cubemaps-upside-down: ndc.y must UNDO the V-flip
+// `fullscreen_triangle()` bakes in (`v = 1 - (y + 1) * 0.5`, common.wgsl:204);
+// the prior `uv.y * 2 - 1` produced the OPPOSITE sign of the actual NDC.y at
+// each fragment, so `inverseViewProj * ndc` returned the world ray for the
+// MIRRORED screen position, and the final `-dir.y` (kept for the IBL bake
+// convention) ended up rendering the skybox upside-down. Reverse the V-flip
+// here with `1.0 - uv.y * 2.0`; see skybox-direction.test.ts.
+fn skyboxDirection(uv : vec2<f32>) -> vec3<f32> {
+  let ndc = vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, 1.0, 1.0);
+  let worldDir = view.inverseViewProj * ndc;
+  let dir = normalize(worldDir.xyz / worldDir.w);
+  let rotated = inverseRotateEnvironment(dir, environment.rotation);
+  return vec3<f32>(rotated.x, -rotated.y, rotated.z);
+}
+
+@fragment
+fn skybox_fs(in : FullscreenOutput) -> @location(0) vec4<f32> {
+  let dir = skyboxDirection(in.uv);
+  let color = textureSample(cubemap, cubemapSampler, dir).rgb;
+  return apply_fog(
+    view.fog,
+    FogRay(view.cameraPos, dir, max(view.temporalProjection.y, 0.0)),
+    vec4<f32>(color, 1.0),
+  );
+}