@forgeax/engine-shader 0.1.27 → 0.1.29

package/NOTICE

@@ -0,0 +1,35 @@
+forgeax-engine
+Copyright 2026 ForgeaXGame Contributors
+
+This is part of the ForgeaX project, an open-source AI-native game
+development toolchain (https://github.com/ForgeaXGame).
+
+Licensed under the Apache License, Version 2.0 (the "License");
+see the LICENSE file in this repository or at
+http://www.apache.org/licenses/LICENSE-2.0 for details.
+
+The projected-space SSR tracing implementation in
+packages/shader/src/ssr-trace.wgsl is adapted from the algorithms in Three.js
+SSRShader and SSRNode at 4457aa3c5de4a05bbae4e0bee2d99d994c38a2bb.
+
+The MIT License
+
+Copyright © 2010-2026 three.js authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -33,6 +33,12 @@ BRDF 的输入，不是最终颜色；Engine-owned Standard pass family 负责
 
 ### Minimal authoring shape
 
+`SurfaceInput` exposes `uv0` through `uv7`, matching the geometry coordinate
+inputs. Every texture slot selects its own set, scale, rotation and offset.
+The default Surface evaluator is shared by CPU, GPU scene-index and shadow
+passes; no shadow-only sampling formula may discard those authored coordinates.
+Changes to the engine-owned input ABI require re-cooking authored materials.
+
 `SurfaceData` is deliberately base-only. Its frozen field order is:
 
 | Order | Field | Meaning |
@@ -111,6 +117,13 @@ not import this accessor. The canonical source is `src/standard-cluster.wgsl`;
 all Standard lit variants compose this one module, so there is no second
 implementation to maintain.
 
+`src/standard-surface.wgsl` owns the Standard material/fragment evaluation shared
+by ordinary Mesh and the VFX Mesh vertex adapter. Geometry adapters supply world
+position, normal, tangent, UVs and color; they do not fork BRDF, shadow reception
+or IBL formulas. Render supplies the corresponding lighting resources. The
+single-level BRDF LUT uses explicit-LOD sampling, including when per-particle
+surface factors make fragment control flow non-uniform.
+
 ## MaterialAsset and shader route
 
 The recovery route is to inspect the structured code, detail, and hint, then
@@ -134,6 +147,22 @@ const materialHandle = world.allocSharedRef('MaterialAsset', result.value);
 
 The custom-shader demo is the executable reference: [`apps/hello/custom-shader`](../../apps/hello/custom-shader). It loads the root and derived GUIDs, validates their cooked records, checks the manifest artifact, and only then draws.
 
+## GPU-driven PBR / shadow / skin navigation
+
+This package is the producer entry: author `paramSchema` and WGSL, then inspect
+the cooked receipt before the render owner admits a draw. The consumer route is
+[`packages/render/README.md`](../render/README.md#gpu-driven-pbr--shadow--skin-navigation); host
+assembly and recovery are documented in
+[`packages/runtime/README.md`](../runtime/README.md#gpu-driven-pbr--shadow--skin-navigation).
+An Alpha Mask cutoff, texture/sampler slot, or skin palette mismatch is a
+structured producer failure, not a CPU duplicate-draw request.
+
+Offline recovery is always `inspect -> repair this producer -> retry`:
+
+```text
+shader source/schema -> cook + reflection receipt -> runtime catalog -> render prepare
+```
+
 ## Shader module catalog
 
 `ShaderRegistry` owns the content-addressed build manifest. It is a runtime
@@ -165,6 +194,16 @@ must agree with that derived shape before a record is published. Per-slot
 texture coordinates are data in `MaterialTextureValue`, not a global shader
 switch.
 
+Standard texture availability comes from authored parameter declarations, not
+GPU residency. Cooked materials omit unavailable texture declarations and
+sampling code. Shared built-in Standard modules retain a fixed binding layout
+and specialize sampling with one pipeline override, `STANDARD_TEXTURE_MASK_OVERRIDE`.
+`standardTextureMask()` derives its bits from the canonical texture-field order;
+the renderer carries the authored mask separately from the canonical UBO schema
+and includes it in pipeline identity. Runtime selects published WGSL and GPU
+pipeline constants; it does not compose or cook WGSL. A declared but nonresident
+texture remains enabled and follows the existing resource recovery route.
+
 ## Error recovery
 
 Material and shader errors are closed. Switch on `error.code`, then use the

package/dist/ShaderRegistry.d.ts

@@ -33,6 +33,14 @@ export interface ShaderRegistryDevice {
  * (UUIDv5/v7) shape and not `forgeax::*`.
  */
 export declare const FORGEAX_RESERVED_PATH_PREFIX: "forgeax::";
+/** Stable build-time module ids for the M1 spatial SSR artifact set. */
+export declare const SSR_SHADER_MODULES: Readonly<{
+    readonly hiz: "forgeax_ssr::hiz";
+    readonly hizReduce: "forgeax_ssr::hiz_reduce";
+    readonly trace: "forgeax_ssr::trace";
+    readonly temporal: "forgeax_ssr::temporal";
+}>;
+export type SsrShaderModule = (typeof SSR_SHADER_MODULES)[keyof typeof SSR_SHADER_MODULES];
 /**
  * Material shader admission input accepted by
  * `installMaterialArtifact(identifier, entry)`. `findMaterialArtifact`

package/dist/ShaderRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderRegistry.d.ts","sourceRoot":"","sources":["../src/ShaderRegistry.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EACV,8BAA8B,EAC9B,aAAa,EACb,gBAAgB,EAChB,+BAA+B,EAChC,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,MAAM,IAAI,YAAY,EAE5B,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAI9D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB;IACnC,kBAAkB,CAAC,IAAI,EAAE;QACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KACrC,GAAG,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;CACpC;AAID;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,EAAG,WAAoB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACnD;AAED,+EAA+E;AAC/E,MAAM,WAAW,6BAA8B,SAAQ,mBAAmB;IACxE,QAAQ,CAAC,qBAAqB,EAAE,8BAA8B,CAAC;CAChE;AAID,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAkCD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,cAAc;;gBAcb,IAAI,EAAE,qBAAqB;IAKvC;;;;;;;;;;;;;;;OAeG;IACG,YAAY,IAAI,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAyK9D;;;;;;;;;;OAUG;IACH,OAAO,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAI1C;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,YAAY,EAAE,QAAQ,GAAG,WAAW,CAAC;IA2C/D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAsC7E;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAClB,UAAU,EAAE,MAAM,GACjB,YAAY,CAAC,6BAA6B,EAAE,WAAW,CAAC;IAc3D;;;;OAIG;IACH,yBAAyB,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAIrD,uEAAuE;IACvE,0BAA0B,IAAI,+BAA+B;IAI7D;;;;;;;;;;;OAWG;IACH,6BAA6B,IAAI,gBAAgB,CAAC,2BAA2B,CAAC;CAG/E"}
+{"version":3,"file":"ShaderRegistry.d.ts","sourceRoot":"","sources":["../src/ShaderRegistry.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EACV,8BAA8B,EAC9B,aAAa,EACb,gBAAgB,EAChB,+BAA+B,EAChC,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,MAAM,IAAI,YAAY,EAE5B,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAI9D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB;IACnC,kBAAkB,CAAC,IAAI,EAAE;QACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KACrC,GAAG,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;CACpC;AAID;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,EAAG,WAAoB,CAAC;AAEjE,wEAAwE;AACxE,eAAO,MAAM,kBAAkB;;;;;EAKpB,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE3F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACnD;AAED,+EAA+E;AAC/E,MAAM,WAAW,6BAA8B,SAAQ,mBAAmB;IACxE,QAAQ,CAAC,qBAAqB,EAAE,8BAA8B,CAAC;CAChE;AAID,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAkCD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,cAAc;;gBAcb,IAAI,EAAE,qBAAqB;IAKvC;;;;;;;;;;;;;;;OAeG;IACG,YAAY,IAAI,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAyK9D;;;;;;;;;;OAUG;IACH,OAAO,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAI1C;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,YAAY,EAAE,QAAQ,GAAG,WAAW,CAAC;IA2C/D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAsC7E;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAClB,UAAU,EAAE,MAAM,GACjB,YAAY,CAAC,6BAA6B,EAAE,WAAW,CAAC;IAc3D;;;;OAIG;IACH,yBAAyB,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAIrD,uEAAuE;IACvE,0BAA0B,IAAI,+BAA+B;IAI7D;;;;;;;;;;;OAWG;IACH,6BAA6B,IAAI,gBAAgB,CAAC,2BAA2B,CAAC;CAG/E"}

package/dist/index.d.ts

@@ -5,11 +5,11 @@ export { err, manifestMalformed, materialShaderNotFound, ok, type Result, type R
 export { generateLtcTables, hashLtcTable, LTC_SOURCE_PROVENANCE, LTC_TABLE_HASHES, LTC_TABLE_HEIGHT, LTC_TABLE_INPUT_HASHES, LTC_TABLE_WIDTH, LTC_TABLES, } from './ltc/tables.js';
 export { type MaterialArtifactConflictError, type MaterialArtifactInspection, MaterialArtifactRegistry, type MaterialRuntimeArtifact, } from './material/artifact-registry.js';
 export { createStandardPbrArtifactReceipt, isMaterialShaderArtifact, type MaterialShaderArtifact, type MaterialShaderArtifactReceipt, type MaterialShaderResourceSlot, type MaterialShaderVertexInput, } from './material/artifact-types.js';
-export { DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA, STANDARD_BASE_PARAM_SCHEMA, STANDARD_PBR_ALPHA_CUTOFF_DEFAULT, STANDARD_PBR_ARTIFACT_RECEIPT, STANDARD_PBR_SKIN_ARTIFACT_RECEIPT, STANDARD_PHYSICAL_LAYER_PARAM_SCHEMA, STANDARD_PHYSICAL_TEXTURE_FIELDS, STANDARD_PIPELINE_PARAM_SCHEMA, type StandardPhysicalTextureField, standardPhysicalTextureFields, } from './material-schemas.js';
+export { DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, DEFAULT_UNLIT_PARAM_SCHEMA, PARTICLE_MESH_SURFACE_PARAM_SCHEMA, STANDARD_BASE_PARAM_SCHEMA, STANDARD_PBR_ALPHA_CUTOFF_DEFAULT, STANDARD_PBR_ARTIFACT_RECEIPT, STANDARD_PBR_SKIN_ARTIFACT_RECEIPT, STANDARD_PHYSICAL_LAYER_PARAM_SCHEMA, STANDARD_PHYSICAL_TEXTURE_FIELDS, STANDARD_PIPELINE_PARAM_SCHEMA, STANDARD_TEXTURE_MASK_OVERRIDE, type StandardPhysicalTextureField, standardPhysicalTextureFields, standardTextureMask, } from './material-schemas.js';
 export { registerDefaultSpriteLit, type SpriteLitCaps, } from './register-default-sprite-lit.js';
 export { registerDefaultStandardPbrSkin } from './register-default-standard-pbr-skin.js';
 export declare const RECT_AREA_LTC_SHADER_MODULE: "forgeax::lighting-rect-area";
-export { FORGEAX_RESERVED_PATH_PREFIX, type MaterialShaderEntry, type RegisteredMaterialShaderEntry, ShaderRegistry, ShaderRegistry as ShaderCatalog, type ShaderRegistryDevice, type ShaderRegistryDevice as ShaderCatalogDevice, type ShaderRegistryOptions, type ShaderRegistryOptions as ShaderCatalogOptions, } from './ShaderRegistry.js';
+export { FORGEAX_RESERVED_PATH_PREFIX, type MaterialShaderEntry, type RegisteredMaterialShaderEntry, ShaderRegistry, ShaderRegistry as ShaderCatalog, type ShaderRegistryDevice, type ShaderRegistryDevice as ShaderCatalogDevice, type ShaderRegistryOptions, type ShaderRegistryOptions as ShaderCatalogOptions, SSR_SHADER_MODULES, type SsrShaderModule, } from './ShaderRegistry.js';
 export { findVariantByKey, type MaterialShaderManifestEntry, type MaterialShaderManifestVariant, } from './types.js';
 export declare const BUILTIN_MATERIAL_MODULES: {
     readonly standard: "forgeax_material::standard";
@@ -24,6 +24,10 @@ export declare const BUILTIN_MATERIAL_MODULES: {
 export declare const DEFAULT_STANDARD_SURFACE_MODULE: "forgeax_material::default_standard_surface";
 /** Stable build-time module id for the temporal-v1 accessor owner. */
 export declare const SCENE_DATA_TEMPORAL_V1_SHADER_MODULE: "forgeax_scene_temporal";
+/** Stable build-time module id for the single Standard output encoder. */
+export declare const STANDARD_OUTPUT_ENCODING_SHADER_MODULE: "forgeax_view::output_encoding";
+/** Runtime WGSL for the fixed-cohort, same-frame auto exposure meter. */
+export declare const AUTO_EXPOSURE_METER_WGSL = "\nstruct AutoExposureParameters {\n  compensationEv: f32,\n  rangeMinEv: f32,\n  rangeMaxEv: f32,\n  upRate: f32,\n  downRate: f32,\n  deltaTime: f32,\n  fallback: f32,\n  generation: f32,\n};\n@group(0) @binding(0) var source: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> histogram: array<atomic<u32>>;\n@group(0) @binding(2) var<storage, read_write> state: array<vec4<f32>>;\n@group(0) @binding(3) var<storage, read_write> candidate: array<vec4<f32>>;\n@group(0) @binding(4) var<storage, read> parameters: AutoExposureParameters;\n\nvar<workgroup> localHistogram: array<atomic<u32>, 256>;\nvar<workgroup> totals: array<u32, 64>;\nvar<workgroup> sampleTotal: u32;\n\nfn finite(value: f32) -> bool {\n  // Equality rejects NaN; the magnitude bound rejects +/-infinity.\n  return value == value && abs(value) <= 3.402823e+37;\n}\n\nfn centerWeight(\n  block: vec2<u32>,\n  center: vec2<f32>,\n  inverseExtentSquared: vec2<f32>,\n) -> u32 {\n  let delta = vec2<f32>(block) - center;\n  let distanceSquared =\n    delta.x * delta.x * inverseExtentSquared.x +\n    delta.y * delta.y * inverseExtentSquared.y;\n  if (distanceSquared <= 0.25) { return 3u; }\n  if (distanceSquared <= 0.75) { return 2u; }\n  return 1u;\n}\n\nfn accumulateSample(\n  block: vec2<u32>,\n  sampleGrid: vec2<u32>,\n  dimensions: vec2<u32>,\n  center: vec2<f32>,\n  extent: vec2<f32>,\n) {\n  if (block.x >= sampleGrid.x || block.y >= sampleGrid.y) { return; }\n  let pixel = min(block * vec2<u32>(4u) + vec2<u32>(2u), dimensions - vec2<u32>(1u));\n  let sample = textureLoad(source, vec2<i32>(pixel), 0);\n  if (!finite(sample.r) || !finite(sample.g) || !finite(sample.b)) { return; }\n  let luminance = dot(sample.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));\n  if (!finite(luminance) || luminance <= 0.0) { return; }\n  let bin = min(u32(clamp(log2(luminance) + 12.0, 0.0, 23.999) * (256.0 / 24.0)), 255u);\n  atomicAdd(&localHistogram[bin], centerWeight(block, center, extent));\n}\n\n@compute @workgroup_size(256, 1, 1)\nfn auto_exposure_clear(@builtin(local_invocation_index) localIndex: u32) {\n  atomicStore(&histogram[localIndex], 0u);\n}\n\n@compute @workgroup_size(256, 1, 1)\nfn auto_exposure_histogram(\n  @builtin(local_invocation_index) localIndex: u32,\n  @builtin(workgroup_id) workgroupId: vec3<u32>,\n  @builtin(num_workgroups) numWorkgroups: vec3<u32>,\n) {\n  let dimensions = textureDimensions(source);\n  let sampleGrid = (dimensions.xy + vec2<u32>(3u)) / vec2<u32>(4u);\n  let grid = vec2<f32>(sampleGrid);\n  let center = (grid - vec2<f32>(1.0)) * 0.5;\n  let extent = max(center, vec2<f32>(1.0));\n  let inverseExtent = 1.0 / extent;\n  let inverseExtentSquared = inverseExtent * inverseExtent;\n\n  // Map the 256 lanes to a 16x16 logical tile. The fixed 4x8 dispatch grid\n  // then uses a two-dimensional tile stride to cover every 4x4 sample block.\n  atomicStore(&localHistogram[localIndex], 0u);\n  workgroupBarrier();\n  let localGrid = vec2<u32>(localIndex % 16u, localIndex / 16u);\n  let tileSize = vec2<u32>(16u);\n  let blockStart = workgroupId.xy * tileSize + localGrid;\n  let blockStride = numWorkgroups.xy * tileSize;\n  for (var blockY = blockStart.y; blockY < sampleGrid.y; blockY += blockStride.y) {\n    for (var blockX = blockStart.x; blockX < sampleGrid.x; blockX += blockStride.x) {\n      accumulateSample(\n        vec2<u32>(blockX, blockY),\n        sampleGrid,\n        dimensions,\n        center,\n        inverseExtentSquared,\n      );\n    }\n  }\n  workgroupBarrier();\n\n  // Every lane owns one bin. All local accumulation is complete before the\n  // owners atomically publish their finite result to the one global 1KiB map.\n  let localCount = atomicLoad(&localHistogram[localIndex]);\n  if (localCount > 0u) {\n    atomicAdd(&histogram[localIndex], localCount);\n  }\n}\n\n@compute @workgroup_size(64, 1, 1)\nfn auto_exposure_adapt(@builtin(local_invocation_index) localIndex: u32) {\n  var total = 0u;\n  for (var index = localIndex; index < 256u; index += 64u) {\n    total += atomicLoad(&histogram[index]);\n  }\n  totals[localIndex] = total;\n  workgroupBarrier();\n  if (localIndex == 0u) {\n    var reducedTotal = 0u;\n    for (var lane = 0u; lane < 64u; lane += 1u) {\n      reducedTotal += totals[lane];\n    }\n    sampleTotal = reducedTotal;\n  }\n  workgroupBarrier();\n  if (localIndex == 0u) {\n    let validParameters =\n      finite(parameters.compensationEv) &&\n      finite(parameters.rangeMinEv) &&\n      finite(parameters.rangeMaxEv) &&\n      parameters.rangeMinEv <= parameters.rangeMaxEv &&\n      finite(parameters.upRate) &&\n      finite(parameters.downRate) &&\n      finite(parameters.deltaTime) &&\n      parameters.deltaTime >= 0.0 &&\n      finite(parameters.fallback) &&\n      parameters.fallback > 0.0 &&\n      finite(parameters.generation);\n    let safeFallback = select(\n      1.0,\n      parameters.fallback,\n      finite(parameters.fallback) && parameters.fallback > 0.0,\n    );\n    let safeGeneration = select(0.0, parameters.generation, finite(parameters.generation));\n    let lowRank = min(sampleTotal, u32(f32(sampleTotal) * 0.05));\n    let highRank = min(sampleTotal, max(lowRank + 1u, u32(ceil(f32(sampleTotal) * 0.95))));\n    var cumulative = 0u;\n    var clippedWeightedLog = 0.0;\n    var clippedTotal = 0u;\n    for (var index = 0u; index < 256u; index += 1u) {\n      let count = atomicLoad(&histogram[index]);\n      let begin = cumulative;\n      cumulative += count;\n      let keptBegin = max(begin, lowRank);\n      let keptEnd = min(cumulative, highRank);\n      if (keptEnd > keptBegin) {\n        let kept = keptEnd - keptBegin;\n        clippedTotal += kept;\n        clippedWeightedLog += f32(kept) * (-12.0 + (f32(index) + 0.5) * (24.0 / 256.0));\n      }\n    }\n    let averageLog = select(0.0, clippedWeightedLog / f32(clippedTotal), clippedTotal > 0u);\n    let measuredExposure = exp2(-averageLog) * 0.18;\n    let targetExposure = select(\n      safeFallback,\n      exp2(clamp(log2(max(measuredExposure, 1e-6)) + parameters.compensationEv, parameters.rangeMinEv, parameters.rangeMaxEv)),\n      validParameters && clippedTotal > 0u && finite(measuredExposure),\n    );\n    let previous = state[0];\n    let hasPrevious = validParameters && previous.y > 0.5 && previous.z == safeGeneration && previous.w == safeFallback && finite(previous.x) && previous.x > 0.0;\n    let current = select(safeFallback, previous.x, hasPrevious);\n    let rate = select(parameters.downRate, parameters.upRate, targetExposure > current);\n    let safeRate = select(0.0, rate, finite(rate) && rate >= 0.0);\n    let dt = select(0.0, parameters.deltaTime, finite(parameters.deltaTime) && parameters.deltaTime >= 0.0);\n    let amount = 1.0 - exp(-safeRate * dt);\n    let adapted = select(current, current + (targetExposure - current) * amount, validParameters && finite(targetExposure) && finite(current) && dt > 0.0 && safeRate > 0.0);\n    let exposure = select(safeFallback, adapted, finite(adapted) && adapted > 0.0);\n    candidate[0] = vec4<f32>(exposure, 1.0, safeGeneration, safeFallback);\n    state[0] = candidate[0];\n  }\n}\n";
 /**
  * Material modules whose shader source and parameter contract are owned by
  * the Engine. They live in the runtime ShaderRegistry, so a Pack containing

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAsBA,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE7E,OAAO,KAAK,EAAE,aAAa,EAAoC,MAAM,uBAAuB,CAAC;AAI7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EACL,GAAG,EACH,iBAAiB,EACjB,sBAAsB,EACtB,EAAE,EACF,KAAK,MAAM,EACX,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,WAAW,EACX,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,wBAAwB,EACxB,KAAK,uBAAuB,GAC7B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,gCAAgC,EAChC,wBAAwB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,GAC/B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,0BAA0B,EAC1B,iCAAiC,EACjC,6BAA6B,EAC7B,kCAAkC,EAClC,oCAAoC,EACpC,gCAAgC,EAChC,8BAA8B,EAC9B,KAAK,4BAA4B,EACjC,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,wBAAwB,EACxB,KAAK,aAAa,GACnB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AACzF,eAAO,MAAM,2BAA2B,EAAG,6BAAsC,CAAC;AAClF,OAAO,EACL,4BAA4B,EAC5B,KAAK,mBAAmB,EACxB,KAAK,6BAA6B,EAClC,cAAc,EACd,cAAc,IAAI,aAAa,EAC/B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,IAAI,mBAAmB,EAChD,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,IAAI,oBAAoB,GACnD,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,gBAAgB,EAChB,KAAK,2BAA2B,EAChC,KAAK,6BAA6B,GACnC,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,EAC1C,4CAAqD,CAAC;AAExD,sEAAsE;AACtE,eAAO,MAAM,oCAAoC,EAAG,wBAAiC,CAAC;AAEtF;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,wVAa1B,CAAC;AAEX,0EAA0E;AAC1E,eAAO,MAAM,+BAA+B,2DAGjC,CAAC;AAEZ,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,GAAG,OAAO,CAWjF;AAED,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,wBAAwB,CAAC;AA0BxE,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,mBAAmB,GAAG,aAAa,CAoBnF;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,UAAO,CAAC;AAE9C,OAAO,EAAE,mBAAmB,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.mjs

@@ -1,43 +1,32 @@
-import { STANDARD_MATERIAL_PARAM_SCHEMA, STANDARD_PHYSICAL_PARAMETER_NAMES, ok, err, ParamSchemaProjectionOwner, findUndeclaredSampledTextures, standardSurfaceParameters } from '@forgeax/engine-types';
+import { STANDARD_MATERIAL_PARAM_SCHEMA, STANDARD_PHYSICAL_TEXTURE_FIELDS, derive, STANDARD_PHYSICAL_PARAMETER_NAMES, ok, err, ParamSchemaProjectionOwner, findUndeclaredSampledTextures, standardSurfaceParameters } from '@forgeax/engine-types';
 export { MATERIAL_PARAM_TYPES, STANDARD_PHYSICAL_TEXTURE_FIELDS, standardPhysicalTextureFields } from '@forgeax/engine-types';
 import { ok as ok$1, err as err$1 } from '@forgeax/engine-rhi';
 export { err, ok } from '@forgeax/engine-rhi';
 
 // src/index.ts
-
-// src/material/artifact-types.ts
-var STANDARD_PBR_TEXTURES = [
-  "baseColorTexture",
-  "metallicRoughnessTexture",
-  "normalTexture",
-  "specularColorTexture",
-  "emissiveTexture",
-  "occlusionTexture",
-  "transmissionTexture",
-  "thicknessTexture"
-];
-var STANDARD_PBR_NUMERIC_FIELDS = [
-  "baseColor",
-  "metallic",
-  "roughness",
-  "metallicChannel",
-  "roughnessChannel",
-  "aoChannel",
-  "extraChannel",
-  "emissive",
-  "emissiveIntensity",
-  "occlusionStrength",
-  "alphaCutoff",
-  "clearcoat",
-  "clearcoatRoughness",
-  "specularColor",
-  "normalScale",
-  "transmission",
-  "ior",
-  "thickness",
-  "attenuationColor",
-  "attenuationDistance"
-];
+var STANDARD_PIPELINE_PARAM_SCHEMA = STANDARD_MATERIAL_PARAM_SCHEMA.filter(
+  (entry) => !(entry.type.startsWith("texture") && STANDARD_PHYSICAL_TEXTURE_FIELDS.includes(
+    entry.name
+  ))
+);
+var STANDARD_PIPELINE_DERIVED = derive(STANDARD_PIPELINE_PARAM_SCHEMA);
+function isNumericParam(entry) {
+  return entry.type === "f32" || entry.type === "i32" || entry.type === "u32" || entry.type === "vec2" || entry.type === "vec3" || entry.type === "vec4" || entry.type === "color";
+}
+function standardPbrMaterialRowFields() {
+  const coordinates = new Map(
+    STANDARD_PIPELINE_DERIVED.coordinateRecords.map((record) => [record.parameter, record])
+  );
+  return STANDARD_PIPELINE_PARAM_SCHEMA.flatMap((entry) => {
+    if (isNumericParam(entry)) return [entry.name];
+    if (entry.type.startsWith("texture")) {
+      const record = coordinates.get(entry.name);
+      if (record === void 0) throw new Error(`missing coordinate record for ${entry.name}`);
+      return [record.transformMember, record.metadataMember];
+    }
+    return [];
+  });
+}
 var STANDARD_PBR_VERTEX_INPUTS = [
   { semantic: "position", location: 0, format: "float32x3" },
   { semantic: "normal", location: 1, format: "float32x3" },
@@ -45,56 +34,79 @@ var STANDARD_PBR_VERTEX_INPUTS = [
   { semantic: "tangent", location: 3, format: "float32x4" }
 ];
 function standardPbrResourceSlots() {
-  return STANDARD_PBR_TEXTURES.flatMap((parameter, index) => [
-    {
-      name: `${parameter}_sampler`,
-      parameter,
-      kind: "sampler",
-      group: 1,
-      binding: index * 2 + 1
-    },
-    {
-      name: parameter,
-      parameter,
-      kind: "texture",
-      group: 1,
-      binding: index * 2 + 2
-    }
-  ]);
+  return STANDARD_PIPELINE_DERIVED.resourceBindings.flatMap((resource) => {
+    if (resource.kind !== "sampler" && resource.kind !== "texture") return [];
+    return [
+      {
+        name: resource.name,
+        parameter: resource.parameter ?? resource.name,
+        kind: resource.kind,
+        group: 1,
+        binding: resource.binding
+      }
+    ];
+  });
 }
-function createStandardPbrArtifactReceipt(skinned = false) {
+function createStandardPbrArtifactReceipt(skinned = false, vertexColorAvailable = false) {
   const resourceSlots = standardPbrResourceSlots();
-  const uvSets = STANDARD_PBR_TEXTURES.map((parameter) => ({ parameter, set: 0 }));
-  const vertexInputs = skinned ? [
+  const uvSets = STANDARD_PIPELINE_DERIVED.coordinateRecords.map((record) => ({
+    parameter: record.parameter,
+    set: 0
+  }));
+  const vertexInputs = [
     ...STANDARD_PBR_VERTEX_INPUTS,
-    { semantic: "skinIndex", location: 4, format: "uint16x4" },
-    { semantic: "skinWeight", location: 5, format: "float32x4" }
-  ] : [...STANDARD_PBR_VERTEX_INPUTS];
+    ...skinned ? [
+      { semantic: "skinIndex", location: 4, format: "uint16x4" },
+      { semantic: "skinWeight", location: 5, format: "float32x4" }
+    ] : [],
+    ...vertexColorAvailable ? [{ semantic: "color", location: 13, format: "float32x4" }] : []
+  ];
+  const layoutIdentity = `standard-pbr/material-row-v2${vertexColorAvailable ? "/vertex-color" : ""}`;
   return {
     directEntry: "vs_main",
     sceneIndexEntry: "vs_scene_index",
-    materialRow: { byteLength: 384, fields: [...STANDARD_PBR_NUMERIC_FIELDS] },
+    materialRow: {
+      byteLength: STANDARD_PIPELINE_DERIVED.totalBytes,
+      fields: [...standardPbrMaterialRowFields()]
+    },
     resourceSlots,
     uvSets,
     vertexInputs,
     alphaMask: { cutoff: "alphaCutoff", source: "baseColor.a" },
     ...skinned ? { skinPaletteAddress: { group: 2, binding: 1, stride: 64 } } : {},
     reflection: {
-      layoutIdentity: "standard-pbr/material-row-v1",
+      layoutIdentity,
       resourceSlots,
       vertexInputs
     },
-    receiptIdentity: "standard-pbr/material-row-v1",
-    generation: 1
+    receiptIdentity: layoutIdentity,
+    generation: 2
   };
 }
 function isMaterialShaderArtifact(value) {
   if (value === null || typeof value !== "object") return false;
   const artifact = value;
-  return typeof artifact.material === "string" && typeof artifact.pass === "string" && typeof artifact.wgsl === "string" && typeof artifact.layoutIdentity === "string" && Array.isArray(artifact.bindings) && Array.isArray(artifact.deps) && Array.isArray(artifact.vertexInputs);
+  const particleInputs = artifact.particleInputs;
+  const particleInputsValid = particleInputs === void 0 || Array.isArray(particleInputs) && particleInputs.every(
+    (input) => input !== null && typeof input === "object" && typeof input.name === "string" && typeof input.type === "string" && typeof input.visibility === "string" && Number.isInteger(input.lane) && input.lane >= 0
+  );
+  return typeof artifact.material === "string" && typeof artifact.pass === "string" && typeof artifact.wgsl === "string" && typeof artifact.layoutIdentity === "string" && Array.isArray(artifact.bindings) && Array.isArray(artifact.deps) && Array.isArray(artifact.vertexInputs) && particleInputsValid;
 }
 var STANDARD_PBR_ALPHA_CUTOFF_DEFAULT = 0;
 var DEFAULT_STANDARD_PBR_PARAM_SCHEMA = STANDARD_MATERIAL_PARAM_SCHEMA;
+var STANDARD_TEXTURE_MASK_OVERRIDE = "64000";
+var standardTextureBits = new Map(
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter((entry) => entry.type === "texture2d").map(
+    (entry, index) => [entry.name, 2 ** index]
+  )
+);
+function standardTextureMask(schema) {
+  let mask = 0;
+  for (const entry of schema) {
+    if (entry.type === "texture2d") mask |= standardTextureBits.get(entry.name) ?? 0;
+  }
+  return mask;
+}
 var STANDARD_PHYSICAL_LAYER_PARAM_SCHEMA = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter(
   (entry) => STANDARD_PHYSICAL_PARAMETER_NAMES.has(entry.name)
 );
@@ -108,12 +120,52 @@ var STANDARD_BASE_PARAM_SCHEMA = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter(
     "thicknessTexture"
   ].includes(entry.name)
 );
-var STANDARD_PIPELINE_PARAM_SCHEMA = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.filter(
-  // The canonical Standard UBO keeps every numeric root coordinate,
-  // including the physical-layer tail. Physical map pairs are engine-owned
-  // resources and are injected after the stable user region.
-  (entry) => !(STANDARD_PHYSICAL_PARAMETER_NAMES.has(entry.name) && entry.type.startsWith("texture"))
-);
+var STANDARD_PIPELINE_PARAM_SCHEMA2 = STANDARD_PIPELINE_PARAM_SCHEMA;
+var PARTICLE_SURFACE_NUMERIC_FIELDS = [
+  "baseColor",
+  "metallic",
+  "roughness",
+  "metallicChannel",
+  "roughnessChannel",
+  "aoChannel",
+  "extraChannel",
+  "emissive",
+  "emissiveIntensity",
+  "occlusionStrength",
+  "alphaCutoff",
+  "clearcoat",
+  "clearcoatRoughness",
+  "specularTint",
+  "normalScale",
+  "transmission",
+  "ior",
+  "thickness",
+  "attenuationColor",
+  "attenuationDistance"
+];
+var PARTICLE_SURFACE_TEXTURE_FIELDS = [
+  "baseColorTexture",
+  "metallicRoughnessTexture",
+  "normalTexture",
+  "specularTintTexture",
+  "emissiveTexture",
+  "occlusionTexture",
+  "transmissionTexture",
+  "thicknessTexture"
+];
+function particleSurfaceSchemaEntry(name) {
+  const entry = DEFAULT_STANDARD_PBR_PARAM_SCHEMA.find((candidate) => candidate.name === name);
+  if (entry !== void 0) return entry;
+  if (name === "specularTint") {
+    return { name, type: "vec3", colorSpace: "srgb", default: [1, 1, 1] };
+  }
+  if (name === "specularTintTexture") return { name, type: "texture2d" };
+  throw new Error(`Particle Standard Surface schema field is missing: ${name}`);
+}
+var PARTICLE_MESH_SURFACE_PARAM_SCHEMA = Object.freeze([
+  ...PARTICLE_SURFACE_NUMERIC_FIELDS.map(particleSurfaceSchemaEntry),
+  ...PARTICLE_SURFACE_TEXTURE_FIELDS.map(particleSurfaceSchemaEntry)
+]);
 var STANDARD_PBR_ARTIFACT_RECEIPT = createStandardPbrArtifactReceipt();
 var STANDARD_PBR_SKIN_ARTIFACT_RECEIPT = createStandardPbrArtifactReceipt(true);
 var DEFAULT_UNLIT_PARAM_SCHEMA = [
@@ -33173,10 +33225,16 @@ var RESERVED_ID2 = "forgeax::pbr-skin";
 function registerDefaultStandardPbrSkin(registry, composedWgsl, caps) {
   registry.installMaterialArtifact(RESERVED_ID2, {
     source: composedWgsl,
-    paramSchema: STANDARD_PIPELINE_PARAM_SCHEMA
+    paramSchema: STANDARD_PIPELINE_PARAM_SCHEMA2
   });
 }
 var FORGEAX_RESERVED_PATH_PREFIX = "forgeax::";
+var SSR_SHADER_MODULES = Object.freeze({
+  hiz: "forgeax_ssr::hiz",
+  hizReduce: "forgeax_ssr::hiz_reduce",
+  trace: "forgeax_ssr::trace",
+  temporal: "forgeax_ssr::temporal"
+});
 function markShaderManifestStage(name, detail = {}) {
   if (typeof globalThis === "undefined") return;
   const host = globalThis;
@@ -33604,6 +33662,188 @@ var BUILTIN_MATERIAL_MODULES = {
 };
 var DEFAULT_STANDARD_SURFACE_MODULE = "forgeax_material::default_standard_surface";
 var SCENE_DATA_TEMPORAL_V1_SHADER_MODULE = "forgeax_scene_temporal";
+var STANDARD_OUTPUT_ENCODING_SHADER_MODULE = "forgeax_view::output_encoding";
+var AUTO_EXPOSURE_METER_WGSL = (
+  /* wgsl */
+  `
+struct AutoExposureParameters {
+  compensationEv: f32,
+  rangeMinEv: f32,
+  rangeMaxEv: f32,
+  upRate: f32,
+  downRate: f32,
+  deltaTime: f32,
+  fallback: f32,
+  generation: f32,
+};
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var<storage, read_write> histogram: array<atomic<u32>>;
+@group(0) @binding(2) var<storage, read_write> state: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> candidate: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read> parameters: AutoExposureParameters;
+
+var<workgroup> localHistogram: array<atomic<u32>, 256>;
+var<workgroup> totals: array<u32, 64>;
+var<workgroup> sampleTotal: u32;
+
+fn finite(value: f32) -> bool {
+  // Equality rejects NaN; the magnitude bound rejects +/-infinity.
+  return value == value && abs(value) <= 3.402823e+37;
+}
+
+fn centerWeight(
+  block: vec2<u32>,
+  center: vec2<f32>,
+  inverseExtentSquared: vec2<f32>,
+) -> u32 {
+  let delta = vec2<f32>(block) - center;
+  let distanceSquared =
+    delta.x * delta.x * inverseExtentSquared.x +
+    delta.y * delta.y * inverseExtentSquared.y;
+  if (distanceSquared <= 0.25) { return 3u; }
+  if (distanceSquared <= 0.75) { return 2u; }
+  return 1u;
+}
+
+fn accumulateSample(
+  block: vec2<u32>,
+  sampleGrid: vec2<u32>,
+  dimensions: vec2<u32>,
+  center: vec2<f32>,
+  extent: vec2<f32>,
+) {
+  if (block.x >= sampleGrid.x || block.y >= sampleGrid.y) { return; }
+  let pixel = min(block * vec2<u32>(4u) + vec2<u32>(2u), dimensions - vec2<u32>(1u));
+  let sample = textureLoad(source, vec2<i32>(pixel), 0);
+  if (!finite(sample.r) || !finite(sample.g) || !finite(sample.b)) { return; }
+  let luminance = dot(sample.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+  if (!finite(luminance) || luminance <= 0.0) { return; }
+  let bin = min(u32(clamp(log2(luminance) + 12.0, 0.0, 23.999) * (256.0 / 24.0)), 255u);
+  atomicAdd(&localHistogram[bin], centerWeight(block, center, extent));
+}
+
+@compute @workgroup_size(256, 1, 1)
+fn auto_exposure_clear(@builtin(local_invocation_index) localIndex: u32) {
+  atomicStore(&histogram[localIndex], 0u);
+}
+
+@compute @workgroup_size(256, 1, 1)
+fn auto_exposure_histogram(
+  @builtin(local_invocation_index) localIndex: u32,
+  @builtin(workgroup_id) workgroupId: vec3<u32>,
+  @builtin(num_workgroups) numWorkgroups: vec3<u32>,
+) {
+  let dimensions = textureDimensions(source);
+  let sampleGrid = (dimensions.xy + vec2<u32>(3u)) / vec2<u32>(4u);
+  let grid = vec2<f32>(sampleGrid);
+  let center = (grid - vec2<f32>(1.0)) * 0.5;
+  let extent = max(center, vec2<f32>(1.0));
+  let inverseExtent = 1.0 / extent;
+  let inverseExtentSquared = inverseExtent * inverseExtent;
+
+  // Map the 256 lanes to a 16x16 logical tile. The fixed 4x8 dispatch grid
+  // then uses a two-dimensional tile stride to cover every 4x4 sample block.
+  atomicStore(&localHistogram[localIndex], 0u);
+  workgroupBarrier();
+  let localGrid = vec2<u32>(localIndex % 16u, localIndex / 16u);
+  let tileSize = vec2<u32>(16u);
+  let blockStart = workgroupId.xy * tileSize + localGrid;
+  let blockStride = numWorkgroups.xy * tileSize;
+  for (var blockY = blockStart.y; blockY < sampleGrid.y; blockY += blockStride.y) {
+    for (var blockX = blockStart.x; blockX < sampleGrid.x; blockX += blockStride.x) {
+      accumulateSample(
+        vec2<u32>(blockX, blockY),
+        sampleGrid,
+        dimensions,
+        center,
+        inverseExtentSquared,
+      );
+    }
+  }
+  workgroupBarrier();
+
+  // Every lane owns one bin. All local accumulation is complete before the
+  // owners atomically publish their finite result to the one global 1KiB map.
+  let localCount = atomicLoad(&localHistogram[localIndex]);
+  if (localCount > 0u) {
+    atomicAdd(&histogram[localIndex], localCount);
+  }
+}
+
+@compute @workgroup_size(64, 1, 1)
+fn auto_exposure_adapt(@builtin(local_invocation_index) localIndex: u32) {
+  var total = 0u;
+  for (var index = localIndex; index < 256u; index += 64u) {
+    total += atomicLoad(&histogram[index]);
+  }
+  totals[localIndex] = total;
+  workgroupBarrier();
+  if (localIndex == 0u) {
+    var reducedTotal = 0u;
+    for (var lane = 0u; lane < 64u; lane += 1u) {
+      reducedTotal += totals[lane];
+    }
+    sampleTotal = reducedTotal;
+  }
+  workgroupBarrier();
+  if (localIndex == 0u) {
+    let validParameters =
+      finite(parameters.compensationEv) &&
+      finite(parameters.rangeMinEv) &&
+      finite(parameters.rangeMaxEv) &&
+      parameters.rangeMinEv <= parameters.rangeMaxEv &&
+      finite(parameters.upRate) &&
+      finite(parameters.downRate) &&
+      finite(parameters.deltaTime) &&
+      parameters.deltaTime >= 0.0 &&
+      finite(parameters.fallback) &&
+      parameters.fallback > 0.0 &&
+      finite(parameters.generation);
+    let safeFallback = select(
+      1.0,
+      parameters.fallback,
+      finite(parameters.fallback) && parameters.fallback > 0.0,
+    );
+    let safeGeneration = select(0.0, parameters.generation, finite(parameters.generation));
+    let lowRank = min(sampleTotal, u32(f32(sampleTotal) * 0.05));
+    let highRank = min(sampleTotal, max(lowRank + 1u, u32(ceil(f32(sampleTotal) * 0.95))));
+    var cumulative = 0u;
+    var clippedWeightedLog = 0.0;
+    var clippedTotal = 0u;
+    for (var index = 0u; index < 256u; index += 1u) {
+      let count = atomicLoad(&histogram[index]);
+      let begin = cumulative;
+      cumulative += count;
+      let keptBegin = max(begin, lowRank);
+      let keptEnd = min(cumulative, highRank);
+      if (keptEnd > keptBegin) {
+        let kept = keptEnd - keptBegin;
+        clippedTotal += kept;
+        clippedWeightedLog += f32(kept) * (-12.0 + (f32(index) + 0.5) * (24.0 / 256.0));
+      }
+    }
+    let averageLog = select(0.0, clippedWeightedLog / f32(clippedTotal), clippedTotal > 0u);
+    let measuredExposure = exp2(-averageLog) * 0.18;
+    let targetExposure = select(
+      safeFallback,
+      exp2(clamp(log2(max(measuredExposure, 1e-6)) + parameters.compensationEv, parameters.rangeMinEv, parameters.rangeMaxEv)),
+      validParameters && clippedTotal > 0u && finite(measuredExposure),
+    );
+    let previous = state[0];
+    let hasPrevious = validParameters && previous.y > 0.5 && previous.z == safeGeneration && previous.w == safeFallback && finite(previous.x) && previous.x > 0.0;
+    let current = select(safeFallback, previous.x, hasPrevious);
+    let rate = select(parameters.downRate, parameters.upRate, targetExposure > current);
+    let safeRate = select(0.0, rate, finite(rate) && rate >= 0.0);
+    let dt = select(0.0, parameters.deltaTime, finite(parameters.deltaTime) && parameters.deltaTime >= 0.0);
+    let amount = 1.0 - exp(-safeRate * dt);
+    let adapted = select(current, current + (targetExposure - current) * amount, validParameters && finite(targetExposure) && finite(current) && dt > 0.0 && safeRate > 0.0);
+    let exposure = select(safeFallback, adapted, finite(adapted) && adapted > 0.0);
+    candidate[0] = vec4<f32>(exposure, 1.0, safeGeneration, safeFallback);
+    state[0] = candidate[0];
+  }
+}
+`
+);
 var ENGINE_MATERIAL_MODULES = [
   "forgeax::default-standard-pbr",
   "forgeax::pbr-skin",
@@ -33660,7 +33900,8 @@ function createBuiltinMaterialAsset(kind) {
         program: {
           module: BUILTIN_MATERIAL_MODULES[kind],
           ...kind === "standard" ? { moduleSlots: { surface: DEFAULT_STANDARD_SURFACE_MODULE } } : {}
-        }
+        },
+        renderState: { tags: { LightMode: "Forward" } }
       }
     ],
     parameters: kind === "standard" ? standardSurfaceParameters(BUILTIN_PARAMETERS[kind]) : BUILTIN_PARAMETERS[kind],
@@ -33669,6 +33910,6 @@ function createBuiltinMaterialAsset(kind) {
 }
 var TONEMAP_LUMINANCE_EPSILON = 1e-5;
 
-export { BUILTIN_MATERIAL_MODULES, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, DEFAULT_STANDARD_SURFACE_MODULE, DEFAULT_UNLIT_PARAM_SCHEMA, ENGINE_MATERIAL_MODULES, FORGEAX_RESERVED_PATH_PREFIX, LTC_SOURCE_PROVENANCE, LTC_TABLES, LTC_TABLE_HASHES, LTC_TABLE_HEIGHT, LTC_TABLE_INPUT_HASHES, LTC_TABLE_WIDTH, MaterialArtifactRegistry, RECT_AREA_LTC_SHADER_MODULE, REFLECTION_PROBE_SHADER_HELPERS, SCENE_DATA_TEMPORAL_V1_SHADER_MODULE, STANDARD_BASE_PARAM_SCHEMA, STANDARD_PBR_ALPHA_CUTOFF_DEFAULT, STANDARD_PBR_ARTIFACT_RECEIPT, STANDARD_PBR_SKIN_ARTIFACT_RECEIPT, STANDARD_PHYSICAL_LAYER_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA, ShaderRegistry as ShaderCatalog, ShaderError, ShaderRegistry, TONEMAP_LUMINANCE_EPSILON, TONEMAP_SHADER_MODE, createBuiltinMaterialAsset, createStandardPbrArtifactReceipt, findVariantByKey, generateLtcTables, hashLtcTable, isEngineMaterial, isEngineMaterialModule, isMaterialShaderArtifact, manifestMalformed, materialShaderNotFound, registerDefaultSpriteLit, registerDefaultStandardPbrSkin, shaderNotFound };
+export { AUTO_EXPOSURE_METER_WGSL, BUILTIN_MATERIAL_MODULES, DEFAULT_MSDF_TEXT_PARAM_SCHEMA, DEFAULT_SPRITE_PARAM_SCHEMA, DEFAULT_STANDARD_PBR_PARAM_SCHEMA, DEFAULT_STANDARD_SURFACE_MODULE, DEFAULT_UNLIT_PARAM_SCHEMA, ENGINE_MATERIAL_MODULES, FORGEAX_RESERVED_PATH_PREFIX, LTC_SOURCE_PROVENANCE, LTC_TABLES, LTC_TABLE_HASHES, LTC_TABLE_HEIGHT, LTC_TABLE_INPUT_HASHES, LTC_TABLE_WIDTH, MaterialArtifactRegistry, PARTICLE_MESH_SURFACE_PARAM_SCHEMA, RECT_AREA_LTC_SHADER_MODULE, REFLECTION_PROBE_SHADER_HELPERS, SCENE_DATA_TEMPORAL_V1_SHADER_MODULE, SSR_SHADER_MODULES, STANDARD_BASE_PARAM_SCHEMA, STANDARD_OUTPUT_ENCODING_SHADER_MODULE, STANDARD_PBR_ALPHA_CUTOFF_DEFAULT, STANDARD_PBR_ARTIFACT_RECEIPT, STANDARD_PBR_SKIN_ARTIFACT_RECEIPT, STANDARD_PHYSICAL_LAYER_PARAM_SCHEMA, STANDARD_PIPELINE_PARAM_SCHEMA2 as STANDARD_PIPELINE_PARAM_SCHEMA, STANDARD_TEXTURE_MASK_OVERRIDE, ShaderRegistry as ShaderCatalog, ShaderError, ShaderRegistry, TONEMAP_LUMINANCE_EPSILON, TONEMAP_SHADER_MODE, createBuiltinMaterialAsset, createStandardPbrArtifactReceipt, findVariantByKey, generateLtcTables, hashLtcTable, isEngineMaterial, isEngineMaterialModule, isMaterialShaderArtifact, manifestMalformed, materialShaderNotFound, registerDefaultSpriteLit, registerDefaultStandardPbrSkin, shaderNotFound, standardTextureMask };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map