@aura3d/engine 4.6.1 → 4.7.0

package/dist/rendering/ForwardPass.js

@@ -37,9 +37,37 @@ import { packA3DEnvironmentUniforms } from "./environment/EnvUniforms.js";
 import { dfgLutBinding, dfgLutTexture } from "./program/DFGLut.js";
 // PR 0b-2 re-imports for moved carve-out modules (CONTRACTS.md §3.3).
 import { SkinningPaletteUploadManager, applyGpuMorphUniforms, resolveRenderGeometry } from "./forward/Deform.js";
-import { FORWARD_DIRECT_LIGHT_CAPACITY, applyClusteredLightingUniforms, applyForwardShadowMapUniforms, resolveForwardClusteredLighting, selectForwardShadowMap } from "./forward/Lighting.js";
+import { FORWARD_DIRECT_LIGHT_CAPACITY, applyClusteredLightingUniforms, applyForwardLocalShadowUniforms, applyForwardShadowMapUniforms, resolveForwardClusteredLighting, selectForwardShadowMap } from "./forward/Lighting.js";
 import { flushMultiDrawQueue, submitDraw } from "./forward/DrawSubmit.js";
 import { bindVelocityUniforms } from "./forward/Velocity.js";
+import { A3D_INSTANCE_EMISSIVE_ATTRIBUTE, materialInstanceColorTarget, registerInstanceColorTargetFeature } from "./shaders/chunks/instance_color_target.glsl.js";
+/**
+ * GU47 E-D: the `prd04.instanceColorTarget` ShaderFeature. Registered when this module loads, so the renderer warmup
+ * sees it, and again (idempotently) by every ForwardPass in case a module cycle deferred the first call. It never selects
+ * for a material that does not carry its parameter, so existing programs are unchanged. (The rim term is the existing
+ * PRD-04 `prd04.rim` feature, registered by `lanes/prd04.ts`; see `shaders/chunks/rim.glsl.ts`.)
+ */
+function ensureGu47ForwardFeatures() {
+    registerInstanceColorTargetFeature();
+}
+try {
+    ensureGu47ForwardFeatures();
+}
+catch {
+    // contracts/program not initialised yet (import cycle): the ForwardPass constructor registers them.
+}
+const forwardDrawHooks = [];
+/** Registers a per-draw uniform hook; returns its unregister function. A duplicate id throws. */
+export function registerForwardDrawHook(hook) {
+    if (forwardDrawHooks.some((entry) => entry.id === hook.id))
+        throw new Error(`FORWARD_DRAW_HOOK_DUPLICATE:${hook.id}`);
+    forwardDrawHooks.push(hook);
+    return () => {
+        const index = forwardDrawHooks.indexOf(hook);
+        if (index >= 0)
+            forwardDrawHooks.splice(index, 1);
+    };
+}
 /** Joints addressable through the uniform-array palette. Re-exported for shaders. */
 export const MAX_UNIFORM_SKINNING_JOINTS = SHADER_MAX_UNIFORM_SKINNING_JOINTS;
 /**
@@ -52,6 +80,29 @@ export const MAX_SKINNING_JOINTS = 1024;
 export const MAX_GPU_MORPH_VERTICES = 64;
 export const MAX_GPU_MORPH_TARGETS = 4;
 export const MAX_GPU_INSTANCES = 64;
+/** Most PRD-02 local-light atlas tiles a frame binds (`shadows/ShadowSystem.ts` MAX_LOCAL_TILES). */
+export const MAX_FORWARD_LOCAL_SHADOW_TILES = 6;
+/**
+ * GU47 eint (EB-3): the lights as the forward programs see them. On a PRD-02 bridge frame (`localShadows` set) a
+ * shadow-casting spot / point light keeps lighting but drops its `castsShadow` gate (the bound forward map is the
+ * sun's), and carries `localShadowSlot` when it got atlas tiles. Any other frame returns `lights` itself.
+ */
+export function forwardShadedLights(lights, localShadows) {
+    if (!lights)
+        return [];
+    if (!localShadows)
+        return lights;
+    let changed = false;
+    const shaded = lights.map((light) => {
+        if (!light.castsShadow || (light.kind !== "spot" && light.kind !== "point"))
+            return light;
+        changed = true;
+        const slot = localShadows.slots.get(light);
+        const out = { ...light, castsShadow: false, ...(slot === undefined ? {} : { localShadowSlot: slot }) };
+        return out;
+    });
+    return changed ? shaded : lights;
+}
 export const MAX_FORWARD_SHADOW_PCF_SAMPLES = 32;
 const INSTANCE_MATRIX_ATTRIBUTE_NAMES = [
     "a_instanceMatrix0",
@@ -92,14 +143,31 @@ export class ForwardPass extends BaseRenderPass {
         super(options.framePass?.name ?? "forward", [...(options.inputColorResource ? [options.inputColorResource] : []), ...(options.framePass?.reads ?? [])], options.framePass?.writes ?? ["color"]);
         this.options = options;
         this.shaderLibrary = options.shaderLibrary ?? createLeanCoreShaderLibrary();
+        ensureGu47ForwardFeatures();
+    }
+    /**
+     * GU47 E-D: per-execute values the `material.custom` built-ins share (`u_lightCount`/`u_lightData` for
+     * `#include <a3d_lights>`, `u_a3dInverseViewProjection` for `a3dFragWorldPosition`), computed once on first use.
+     */
+    customFrame = {};
+    customFrameCache = {
+        lights: () => (this.customFrame.lights ??= LightUniforms.pack(this.shadedLights())),
+        inverseViewProjection: () => (this.customFrame.inverseViewProjection ??= customShaderInverseViewProjection(this.options))
+    };
+    /** GU47 eint (EB-3): `forwardShadedLights` of this pass, computed once per execute (packed per draw). */
+    shadedLightsMemo;
+    shadedLights() {
+        return (this.shadedLightsMemo ??= forwardShadedLights(this.options.lights, this.options.shadowMap?.localShadows));
     }
     execute(context) {
+        this.customFrame = {};
+        this.shadedLightsMemo = undefined;
         this.skinningPaletteUploads.beginFrame();
         this.frameWidth = context.width;
         this.frameHeight = context.height;
         this.contactMaskScope = { device: context.device, width: context.width, height: context.height, cameraPosition: this.options.cameraPosition };
         this.beginFramePools(context.device);
-        this.clusteredLighting = resolveForwardClusteredLighting(this.options.lights, context.width, context.height, this.options.cameraViewProjectionMatrix);
+        this.clusteredLighting = resolveForwardClusteredLighting(this.shadedLights(), context.width, context.height, this.options.cameraViewProjectionMatrix);
         const flags = rendererQrFlags(context.device);
         if (qrGeneratedProgramsOn(flags)) {
             const auraFrame = rendererAuraFrame(context.device, flags);
@@ -190,17 +258,20 @@ export class ForwardPass extends BaseRenderPass {
             }
             return;
         }
+        // GU47 E-D: a `material.custom` vertex shader that reads `instanceMatrix` / `instanceColor` draws every instance in
+        // one call from the same per-instance attribute buffer the generated path uses (no split, no per-instance expansion).
+        const authorInstancing = item.instanceTransforms !== undefined && !generated && supportsAuthorInstancing(shader);
         // Phase 6: generated programs only know attribute-matrix instancing — the
         // uniform fallback (`u_instanceMatrices[64]`) exists only in the frozen
         // legacy library, so the >64 split and no-support expansion never apply
         // on this path.
-        if (item.instanceTransforms && !generated && !supportsInstanceAttributes(shader) && instanceTransformCount(item) > MAX_GPU_INSTANCES) {
+        if (item.instanceTransforms && !generated && !authorInstancing && !supportsInstanceAttributes(shader) && instanceTransformCount(item) > MAX_GPU_INSTANCES) {
             for (const batch of splitInstanceTransforms(item.instanceTransforms)) {
                 this.drawItem(device, { ...item, instanceTransforms: batch });
             }
             return;
         }
-        if (item.instanceTransforms && !generated && !supportsInstanceAttributes(shader) && !supportsInstanceUniforms(shader)) {
+        if (item.instanceTransforms && !generated && !authorInstancing && !supportsInstanceAttributes(shader) && !supportsInstanceUniforms(shader)) {
             for (const expanded of expandInstancedRenderItem(item)) {
                 this.drawItem(device, expanded);
             }
@@ -262,6 +333,8 @@ export class ForwardPass extends BaseRenderPass {
         if (generated)
             applyGeneratedFogUniforms(itemFog, shader, uniforms);
         applyForwardShadowMapUniforms(selectForwardShadowMap(this.options.shadowMap, item, this.options.cameraViewMatrix, this.options.cameraPosition), item, shader, uniforms, this.contactMaskScope);
+        // GU47 eint (EB-3): PRD-02 local-light tiles, bound only to programs that declare them (generated, localShadows > 0).
+        applyForwardLocalShadowUniforms(this.options.shadowMap?.localShadows, item, shader, uniforms);
         applyOutputColorSpaceUniform(this.options.outputColorSpace ?? "srgb", item, shader, uniforms);
         applyCameraUniforms(this.options.cameraPosition, item, shader, uniforms);
         applyAlphaCutoffUniform(item, shader, uniforms);
@@ -271,7 +344,19 @@ export class ForwardPass extends BaseRenderPass {
         // may declare (u_time/u_resolution/u_viewMatrix/u_projectionMatrix) — bound
         // only when the program actually reflects them, mirroring applyCameraUniforms.
         applyCustomShaderFrameUniforms(this.options, this.frameWidth, this.frameHeight, shader, uniforms);
+        // GU47 E-D: `a3d_lights` / sun / hemisphere / fog built-ins for `material.custom` programs (reflection-guarded).
+        if (baseMaterial instanceof PortableShaderMaterial) {
+            applyCustomShaderLightingUniforms(this.options, itemFog, shader, uniforms, this.customFrameCache);
+            // `instanceColor` reads white unless this instanced draw carries per-instance colours.
+            if (shader.reflection.uniforms.has("u_a3dInstanceColors")) {
+                uniforms.set("u_a3dInstanceColors", authorInstancing && item.instanceColors !== undefined ? 1 : 0);
+            }
+        }
         bindVelocityUniforms?.(item, uniforms);
+        if (forwardDrawHooks.length > 0) {
+            for (const hook of forwardDrawHooks)
+                hook.bind(item, shader, (name, value) => uniforms.set(name, value));
+        }
         if (generated && this.lastProgramFeatures) {
             // C-02 `ShaderFeature.bindUniforms` for the features this draw selected.
             bindShaderFeatureUniforms(this.lastProgramFeatures.features, rendererQrFlags(device), item, (name, value) => uniforms.set(name, value));
@@ -293,7 +378,9 @@ export class ForwardPass extends BaseRenderPass {
             // a generated draw without it has no skin attributes (featuresForGeometry).
             this.skinningPaletteUploads.bind(item, item.skinning, baseMaterial, shader, uniforms, device);
         }
-        const instanceBinding = item.instanceTransforms ? this.applyInstanceBinding(device, item, shader, uniforms, generated) : { count: 1 };
+        const instanceBinding = item.instanceTransforms ? this.applyInstanceBinding(device, item, shader, uniforms, generated || authorInstancing) : { count: 1 };
+        if (authorInstancing)
+            uniforms.set("u_a3dInstancing", 1);
         const gpuMorph = item.morphTargets || item.morphWeights ? applyGpuMorphUniforms(item, shader, uniforms) : false;
         const geometry = gpuMorph ? item.geometry : resolveRenderGeometry(item);
         // Generated programs validate their selected attributes in MaterialBinding.
@@ -357,6 +444,8 @@ export class ForwardPass extends BaseRenderPass {
         }
         const bound = slot.buffer.bind();
         const extra = createExtraInstanceAttributeBindings(device, item, count, false);
+        // GU47 E-D: `instanceColorTarget: "emissive"` — the colours feed the emissive term only (prd04.instanceColorTarget).
+        const colorAttribute = materialInstanceColorTarget(item.material) === "emissive" ? A3D_INSTANCE_EMISSIVE_ATTRIBUTE : "a_instanceColor";
         return {
             count,
             attributes: [
@@ -370,7 +459,7 @@ export class ForwardPass extends BaseRenderPass {
                 })),
                 ...(bound.colorBuffer ? [{
                         buffer: bound.colorBuffer,
-                        shaderName: "a_instanceColor",
+                        shaderName: colorAttribute,
                         components: 4,
                         offset: 0,
                         stride: 16,
@@ -386,7 +475,7 @@ export class ForwardPass extends BaseRenderPass {
         if (!baseMaterial.requiredUniforms.includes("u_lightCount") || !baseMaterial.requiredUniforms.includes("u_lightData")) {
             return;
         }
-        const packed = LightUniforms.pack(this.options.lights ?? []);
+        const packed = LightUniforms.pack(this.shadedLights());
         if (material instanceof MaterialInstance) {
             material.setOverride("u_lightCount", packed.lightCount);
             material.setOverride("u_lightData", packed.data);
@@ -521,7 +610,8 @@ export class ForwardPass extends BaseRenderPass {
             // Phase 6: instancing is item-driven — a material's own feature record
             // only declares it when authored instanced; the draw's program must
             // cover the union (attribute matrices are the only generated path).
-            ...(item?.instanceTransforms ? { instancing: { color: item.instanceColors !== undefined } } : {}),
+            // GU47 E-D: `instanceColorTarget: "emissive"` keeps the base colour (no USE_INSTANCING_COLOR base multiply).
+            ...(item?.instanceTransforms ? { instancing: { color: item.instanceColors !== undefined && materialInstanceColorTarget(material) !== "emissive" } } : {}),
             // #1140: a per-item probe cube (PRD-02 S12) is sampled as a cube.
             ...(item?.environmentCube?.texture?.dimension === "cube" ? { environment: "pmrem-cube" } : {}),
             backgroundCoverage: this.options.backgroundCoverage === true,
@@ -742,7 +832,13 @@ export function forwardPassFeatureAxes(options, clustered) {
             hemisphere: env?.proceduralMap !== undefined
         },
         shadows: options.shadowMap
-            ? { cascades: Math.max(1, Math.min(4, options.shadowMap.cascades?.length ?? 1)), pcfTaps: 4, localShadows: 0, contact: false }
+            ? {
+                cascades: Math.max(1, Math.min(4, options.shadowMap.cascades?.length ?? 1)),
+                pcfTaps: 4,
+                // GU47 eint (EB-3): one variant for any tile count, so lights entering / leaving do not recompile.
+                localShadows: (options.shadowMap.localShadows?.slots.size ?? 0) > 0 ? MAX_FORWARD_LOCAL_SHADOW_TILES : 0,
+                contact: false
+            }
             : { cascades: 0, pcfTaps: 4, localShadows: 0, contact: false },
         environment: 
         // #1140: the generated env chunk samples exactly the texture it was
@@ -1782,15 +1878,143 @@ function applyCustomShaderFrameUniforms(options, frameWidth, frameHeight, shader
         uniforms.set("u_viewMatrix", toMat4Uniform(options.customFrameCamera?.viewMatrix ?? options.cameraViewMatrix ?? identityMatrix(), "cameraViewMatrix"));
     }
     if (reflected.has("u_a3dSunDirection") && !uniforms.has("u_a3dSunDirection")) {
-        // `#include <a3d_shadow>`: direction from the surface toward the shadow-casting directional light.
-        const sun = options.lights?.find((light) => light.castsShadow && light.kind === "directional");
-        const d = sun?.direction ?? [0, -1, 0];
+        // `#include <a3d_shadow>` and the GU47 sun built-ins: direction from the surface toward the sun (the shadow-casting
+        // directional light, else the first directional light; straight up when the scene has none).
+        const d = customShaderSun(options.lights)?.direction ?? [0, -1, 0];
         const length = Math.hypot(d[0], d[1], d[2]) || 1;
         uniforms.set("u_a3dSunDirection", [-d[0] / length, -d[1] / length, -d[2] / length]);
     }
     if (reflected.has("u_projectionMatrix") && !uniforms.has("u_projectionMatrix")) {
         uniforms.set("u_projectionMatrix", toMat4Uniform(options.customFrameCamera?.projectionMatrix ?? options.auraFrameCamera?.projectionMatrix ?? identityMatrix(), "auraFrameCamera.projectionMatrix"));
     }
+    // GU47 E-D: `instanceMatrix` / `instanceColor` read identity / white on a non-instanced draw (the instanced path sets 1).
+    if (reflected.has("u_a3dInstancing") && !uniforms.has("u_a3dInstancing"))
+        uniforms.set("u_a3dInstancing", 0);
+}
+/** The light the custom-shader sun built-ins describe: the shadow-casting directional light, else the first directional one. */
+function customShaderSun(lights) {
+    return lights?.find((light) => light.castsShadow && light.kind === "directional") ?? lights?.find((light) => light.kind === "directional");
+}
+/** Exp2 density whose fog reaches 98% at `far`, so a linear-fog scene still gives `u_a3dFogDensity` a matching value. */
+const LINEAR_FOG_EXP2_EQUIVALENT = Math.sqrt(-Math.log(0.02));
+/**
+ * GU47 E-D (PRD §3.1): lighting built-ins for `material.custom` programs, each bound only when the program reflects it:
+ *   - `u_a3dSunColor` (linear rgb) / `u_a3dSunIntensity`: the sun `u_a3dSunDirection` points at (0 when there is none).
+ *   - `u_a3dHemiSky` / `u_a3dHemiGround`: the authored hemisphere pair (linear rgb, premultiplied by intensity; 0 when none).
+ *   - `u_a3dFogColor` / `u_a3dFogDensity`: the scene fog for this draw (exp2 density; a linear fog gets the density that
+ *     reaches 98% at `far`; 0 when the scene has no fog or the material opts out with `fog: false`).
+ *   - `u_lightCount` / `u_lightData`: the packed direct lights `#include <a3d_lights>` loops over (same packing as the
+ *     built-in lit programs; the clustered textures are bound by `applyClusteredLightingUniforms`).
+ *   - `u_a3dInverseViewProjection`: inverse(projection * view) of the camera the other custom built-ins describe, for
+ *     `a3dFragWorldPosition()`.
+ *   - `#include <a3d_ibl>`: `u_a3dEnvAmbient` (environment colour * intensity), `u_a3dEnvSh` / `u_a3dEnvShEnabled` (the
+ *     scene probe's SH9), `u_a3dEnvSky` / `u_a3dEnvHorizon` / `u_a3dEnvGround` (procedural map * intensity) and the
+ *     equirect `u_a3dEnvMap` with `u_a3dEnvMapEnabled` / `Intensity` / `Rotation` / `MaxLod` / `Encoding` (same values the
+ *     generated programs' `u_environmentMap*` get; the white fallback with enabled 0 when the scene has none).
+ */
+export function applyCustomShaderLightingUniforms(options, fog, shader, uniforms, frame) {
+    const reflected = shader.reflection.uniforms;
+    const wants = (name) => reflected.has(name) && !uniforms.has(name);
+    if (wants("u_a3dInverseViewProjection"))
+        uniforms.set("u_a3dInverseViewProjection", frame.inverseViewProjection());
+    applyCustomShaderEnvironmentUniforms(options.environmentLighting, wants, uniforms);
+    if (wants("u_a3dSunColor") || wants("u_a3dSunIntensity")) {
+        const sun = customShaderSun(options.lights);
+        if (wants("u_a3dSunColor"))
+            uniforms.set("u_a3dSunColor", sun ? [sun.color[0], sun.color[1], sun.color[2]] : [0, 0, 0]);
+        if (wants("u_a3dSunIntensity"))
+            uniforms.set("u_a3dSunIntensity", sun && Number.isFinite(sun.intensity) ? Math.max(0, sun.intensity) : 0);
+    }
+    const hemisphere = options.environmentLighting?.hemisphere;
+    if (wants("u_a3dHemiSky"))
+        uniforms.set("u_a3dHemiSky", hemisphere ? [...hemisphere.sky] : [0, 0, 0]);
+    if (wants("u_a3dHemiGround"))
+        uniforms.set("u_a3dHemiGround", hemisphere ? [...hemisphere.ground] : [0, 0, 0]);
+    if (wants("u_a3dFogColor"))
+        uniforms.set("u_a3dFogColor", fog ? Array.from(fog.color) : [0, 0, 0]);
+    if (wants("u_a3dFogDensity")) {
+        const density = !fog ? 0
+            : fog.mode === "linear" ? (Number.isFinite(fog.far) && fog.far > 0 ? LINEAR_FOG_EXP2_EQUIVALENT / fog.far : 0)
+                : Math.max(0, Number.isFinite(fog.density) ? fog.density : 0);
+        uniforms.set("u_a3dFogDensity", density);
+    }
+    if (wants("u_lightCount") || wants("u_lightData")) {
+        const packed = frame.lights();
+        if (wants("u_lightCount"))
+            uniforms.set("u_lightCount", packed.lightCount);
+        if (wants("u_lightData"))
+            uniforms.set("u_lightData", packed.data);
+    }
+}
+/** inverse(projection * view) of the camera `applyCustomShaderFrameUniforms` binds as `u_projectionMatrix` / `u_viewMatrix`. */
+export function customShaderInverseViewProjection(options) {
+    const view = Array.from(options.customFrameCamera?.viewMatrix ?? options.cameraViewMatrix ?? identityMatrix());
+    const projection = Array.from(options.customFrameCamera?.projectionMatrix ?? options.auraFrameCamera?.projectionMatrix ?? identityMatrix());
+    if (view.length !== 16 || projection.length !== 16 || !isFiniteArrayLike(view) || !isFiniteArrayLike(projection))
+        return new Float32Array(identityMatrix());
+    try {
+        const inverse = invertMat4(multiplyMat4(projection, view));
+        return new Float32Array(isFiniteArrayLike(inverse) ? inverse : identityMatrix());
+    }
+    catch {
+        // Singular camera (degenerate projection): `a3dFragWorldPosition` reads clip space instead of NaN.
+        return new Float32Array(identityMatrix());
+    }
+}
+const ZERO_SH9 = new Float32Array(27);
+const CUSTOM_ENV_MAP_FALLBACK = new TextureBinding({ name: "u_a3dEnvMap", required: false });
+/** `#include <a3d_ibl>` uniforms (see `applyCustomShaderLightingUniforms`). */
+function applyCustomShaderEnvironmentUniforms(environment, wants, uniforms) {
+    if (wants("u_a3dEnvAmbient")) {
+        const k = environment && Number.isFinite(environment.intensity) ? Math.max(0, environment.intensity) : 0;
+        uniforms.set("u_a3dEnvAmbient", environment ? [environment.color[0] * k, environment.color[1] * k, environment.color[2] * k] : [0, 0, 0]);
+    }
+    if (wants("u_a3dEnvSh") || wants("u_a3dEnvShEnabled")) {
+        const sh9 = environment?.environmentProbe?.sh9;
+        const valid = sh9 !== undefined && sh9.length === 27 && isFiniteArrayLike(sh9);
+        if (wants("u_a3dEnvSh"))
+            uniforms.set("u_a3dEnvSh", valid ? sh9 : ZERO_SH9);
+        if (wants("u_a3dEnvShEnabled"))
+            uniforms.set("u_a3dEnvShEnabled", valid ? 1 : 0);
+    }
+    if (wants("u_a3dEnvSky") || wants("u_a3dEnvHorizon") || wants("u_a3dEnvGround")) {
+        const procedural = environment?.proceduralMap;
+        const k = procedural && Number.isFinite(procedural.intensity) ? Math.max(0, procedural.intensity) : 0;
+        const scaled = (color) => color ? [color[0] * k, color[1] * k, color[2] * k] : [0, 0, 0];
+        if (wants("u_a3dEnvSky"))
+            uniforms.set("u_a3dEnvSky", scaled(procedural?.skyColor));
+        if (wants("u_a3dEnvHorizon"))
+            uniforms.set("u_a3dEnvHorizon", scaled(procedural?.horizonColor));
+        if (wants("u_a3dEnvGround"))
+            uniforms.set("u_a3dEnvGround", scaled(procedural?.groundColor));
+    }
+    if (!wants("u_a3dEnvMap") && !wants("u_a3dEnvMapEnabled"))
+        return;
+    const binding = environment?.environmentMapTexture;
+    const texture = binding?.texture;
+    const usable = texture !== null && texture !== undefined && texture.dimension !== "cube";
+    if (wants("u_a3dEnvMap")) {
+        uniforms.set("u_a3dEnvMap", usable && binding
+            ? new TextureBinding({ name: "u_a3dEnvMap", texture, sampler: binding.sampler, required: false, ready: binding.ready, expectedColorSpace: binding.expectedColorSpace, expectedDimension: "2d" })
+            : CUSTOM_ENV_MAP_FALLBACK);
+    }
+    if (wants("u_a3dEnvMapEnabled"))
+        uniforms.set("u_a3dEnvMapEnabled", usable ? 1 : 0);
+    const intensity = environment?.environmentMapIntensity ?? 1;
+    const mipCount = environment?.environmentMapMipCount ?? 1;
+    const encoding = environment?.environmentMapEncoding ?? "srgb";
+    if (wants("u_a3dEnvMapIntensity"))
+        uniforms.set("u_a3dEnvMapIntensity", usable && Number.isFinite(intensity) ? Math.max(0, intensity) : 0);
+    if (wants("u_a3dEnvMapRotation"))
+        uniforms.set("u_a3dEnvMapRotation", Number.isFinite(environment?.environmentMapRotation) ? environment.environmentMapRotation : 0);
+    if (wants("u_a3dEnvMapMaxLod"))
+        uniforms.set("u_a3dEnvMapMaxLod", Number.isInteger(mipCount) && mipCount >= 1 ? mipCount - 1 : 0);
+    if (wants("u_a3dEnvMapEncoding"))
+        uniforms.set("u_a3dEnvMapEncoding", encoding === "rgbe" ? 1 : encoding === "linear" ? 2 : 0);
+}
+/** GU47 E-D: a `material.custom` vertex shader that reads `instanceMatrix` (the adapter declares these inputs for it). */
+function supportsAuthorInstancing(shader) {
+    return shader.reflection.uniforms.has("u_a3dInstancing") && INSTANCE_MATRIX_ATTRIBUTE_NAMES.every((name) => shader.reflection.attributes.has(name));
 }
 export function toMat4Uniform(value, field, label) {
     if (value.length !== 16 || !isFiniteArrayLike(value)) {