@aura3d/rendering 4.6.1 → 4.7.0

package/dist/shaders/chunks/author/shadow.glsl.js

@@ -1,3 +1,37 @@
+/**
+ * GU47 E-D (PRD §3.1) `a3d_scene`: the scene built-ins a `material.custom` shader may read, each bound by the forward pass
+ * only when the program declares it (`ForwardPass.ts` `applyCustomShaderFrameUniforms` / `applyCustomShaderLightingUniforms`):
+ *   - `u_a3dSunDirection`: unit direction from the surface toward the sun (the shadow-casting directional light, else the
+ *     first directional light; straight up when the scene has none).
+ *   - `u_a3dSunColor` (linear rgb) and `u_a3dSunIntensity`: that light's colour and intensity (0 when there is none).
+ *   - `u_a3dHemiSky` / `u_a3dHemiGround`: the authored hemisphere light pair (linear rgb, premultiplied by intensity; 0 when none).
+ *   - `u_a3dFogColor` / `u_a3dFogDensity`: the scene fog colour and an 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).
+ * `#include <a3d_shadow>`, `<a3d_lights>` and `<a3d_ibl>` include it; the adapter expands each author chunk once per stage.
+ */
+export const A3D_SCENE_GLSL = /* glsl */ `
+uniform vec3 u_a3dSunDirection;
+uniform vec3 u_a3dSunColor;
+uniform float u_a3dSunIntensity;
+uniform vec3 u_a3dHemiSky;
+uniform vec3 u_a3dHemiGround;
+uniform vec3 u_a3dFogColor;
+uniform float u_a3dFogDensity;
+
+vec3 a3dSunRadiance() {
+  return u_a3dSunColor * max(u_a3dSunIntensity, 0.0);
+}
+
+vec3 a3dHemiLight(vec3 n) {
+  float up = clamp(n.y / max(length(n), 1e-4) * 0.5 + 0.5, 0.0, 1.0);
+  return mix(u_a3dHemiGround, u_a3dHemiSky, up);
+}
+
+vec3 a3dSceneFog(vec3 color, float viewDistance) {
+  float x = max(u_a3dFogDensity, 0.0) * max(viewDistance, 0.0);
+  return mix(color, u_a3dFogColor, 1.0 - exp(-x * x));
+}
+`;
 /**
  * `a3d_shadow`: sun-shadow receive for `material.custom` fragment shaders.
  *
@@ -5,9 +39,13 @@
  * from the light's `shadow` options) to any program that declares the `u_shadowMap*` uniforms below. This chunk declares them
  * and wraps the same lookup the built-in lit programs use, so a custom surface is darkened by exactly the same shadow.
  * `a3dSunShadow` returns 1 in light and `1 - strength * occlusion` in shadow; it returns 1 when the scene has no shadow map.
- * `u_a3dSunDirection` is bound to the direction from the surface toward the shadow-casting directional light.
+ * `u_a3dSunDirection` (from `a3d_scene`) is bound to the direction from the surface toward the shadow-casting directional light.
+ * GU47 E-D: `a3dFragWorldPosition()` reconstructs this fragment's world position from `gl_FragCoord` and the bound
+ * `u_a3dInverseViewProjection` (exact for any author vertex displacement; no varying needed).
  */
 export const A3D_SHADOW_GLSL = /* glsl */ `
+#include <a3d_scene>
+uniform mat4 u_a3dInverseViewProjection;
 uniform sampler2D u_shadowMapTexture;
 uniform float u_shadowMapEnabled;
 uniform mat4 u_shadowMapMatrix;
@@ -18,7 +56,6 @@ uniform vec2 u_shadowMapTexelSize;
 uniform float u_shadowPcfSampleCount;
 uniform vec4 u_shadowPcfSamples[32];
 uniform float u_shadowMapNormalBias;
-uniform vec3 u_a3dSunDirection;
 
 float a3dSunShadow(vec3 worldPosition, vec3 normal, vec3 toLight) {
   if (u_shadowMapEnabled < 0.5) return 1.0;
@@ -53,5 +90,12 @@ float a3dSunShadow(vec3 worldPosition, vec3 normal, vec3 toLight) {
 float a3dSunShadowAuto(vec3 worldPosition, vec3 normal) {
   return a3dSunShadow(worldPosition, normal, u_a3dSunDirection);
 }
+
+vec3 a3dFragWorldPosition() {
+  vec2 ndc = gl_FragCoord.xy / max(u_resolution, vec2(1.0)) * 2.0 - 1.0;
+  vec4 world = u_a3dInverseViewProjection * vec4(ndc, gl_FragCoord.z * 2.0 - 1.0, 1.0);
+  float w = abs(world.w) > 1e-8 ? world.w : 1e-8;
+  return world.xyz / w;
+}
 `;
 //# sourceMappingURL=shadow.glsl.js.map

package/dist/shaders/chunks/author/shadow.glsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadow.glsl.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/shaders/chunks/author/shadow.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CzC,CAAC"}
+{"version":3,"file":"shadow.glsl.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/shaders/chunks/author/shadow.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsBxC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDzC,CAAC"}

package/dist/shaders/chunks/instance_color_target.glsl.d.ts

@@ -0,0 +1,34 @@
+/**
+ * GU47 E-D (PRD §3.1): what a per-instance colour multiplies (`instanceColorTarget`).
+ *
+ * Today the generated program multiplies the base colour by `a_instanceColor` (`USE_INSTANCING_COLOR`). The engine
+ * stamps `u_a3dInstanceColorTarget` on the node's material (0 = "base", 1 = "emissive", 2 = "both"; written through the
+ * public `Material.setParameter` API) and ForwardPass routes the colours per draw:
+ *   - "base" (or no parameter): unchanged; this feature never selects, so the program is byte-identical.
+ *   - "both": `a_instanceColor` still multiplies the base, and this feature also multiplies the emissive term by it.
+ *   - "emissive": ForwardPass drops `instancing.color` from the program record (no base multiply) and binds the same
+ *     colour buffer as `a_a3dInstanceEmissive`; this feature declares it and multiplies the emissive term only.
+ * Multiply semantics match "base": give the material an emissive colour (white is the usual choice) and an
+ * `emissiveIntensity`, and each instance glows its own colour. Generated programs only.
+ */
+import type { RenderItem } from "../../contracts/renderItem.js";
+import type { Material } from "../../Material.js";
+import { MaterialInstance } from "../../MaterialInstance.js";
+export type InstanceColorTarget = "base" | "emissive" | "both";
+export declare const A3D_INSTANCE_COLOR_TARGET_FEATURE = "prd04.instanceColorTarget";
+export declare const A3D_INSTANCE_COLOR_TARGET_PARAM = "u_a3dInstanceColorTarget";
+/** Per-instance attribute that carries the colours when the target is "emissive" (no base multiply). */
+export declare const A3D_INSTANCE_EMISSIVE_ATTRIBUTE = "a_a3dInstanceEmissive";
+export declare const A3D_INSTANCE_EMISSIVE_VTX_PARS_CHUNK = "a3d_prd04_instance_emissive_vtx_pars";
+export declare const A3D_INSTANCE_EMISSIVE_VTX_END_CHUNK = "a3d_prd04_instance_emissive_vtx_end";
+export declare const A3D_INSTANCE_EMISSIVE_FRAG_PARS_CHUNK = "a3d_prd04_instance_emissive_frag_pars";
+export declare const A3D_INSTANCE_EMISSIVE_FRAG_CALL_CHUNK = "a3d_prd04_instance_emissive_frag_call";
+/** Material parameter value for a target. */
+export declare function instanceColorTargetCode(target: InstanceColorTarget | undefined): number;
+/** The target a material carries ("base" when it has none). */
+export declare function materialInstanceColorTarget(material: Material | MaterialInstance | undefined): InstanceColorTarget;
+/** `select`: forward draws with per-instance colours whose material targets the emissive term. Pure. */
+export declare function selectInstanceColorTargetFeature(item: RenderItem, pass: string): "emissive" | "both" | undefined;
+/** Registers the chunks and the `prd04.instanceColorTarget` ShaderFeature once per process (ForwardPass calls this at load). */
+export declare function registerInstanceColorTargetFeature(): void;
+//# sourceMappingURL=instance_color_target.glsl.d.ts.map

package/dist/shaders/chunks/instance_color_target.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance_color_target.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/instance_color_target.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;AAE/D,eAAO,MAAM,iCAAiC,8BAA8B,CAAC;AAC7E,eAAO,MAAM,+BAA+B,6BAA6B,CAAC;AAC1E,wGAAwG;AACxG,eAAO,MAAM,+BAA+B,0BAA0B,CAAC;AAEvE,eAAO,MAAM,oCAAoC,yCAAyC,CAAC;AAC3F,eAAO,MAAM,mCAAmC,wCAAwC,CAAC;AACzF,eAAO,MAAM,qCAAqC,0CAA0C,CAAC;AAC7F,eAAO,MAAM,qCAAqC,0CAA0C,CAAC;AAiC7F,6CAA6C;AAC7C,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS,GAAG,MAAM,CAEvF;AAED,+DAA+D;AAC/D,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,QAAQ,GAAG,gBAAgB,GAAG,SAAS,GAAG,mBAAmB,CAMlH;AAED,wGAAwG;AACxG,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,CAIhH;AAiBD,gIAAgI;AAChI,wBAAgB,kCAAkC,IAAI,IAAI,CAazD"}

package/dist/shaders/chunks/instance_color_target.glsl.js

@@ -0,0 +1,101 @@
+/**
+ * GU47 E-D (PRD §3.1): what a per-instance colour multiplies (`instanceColorTarget`).
+ *
+ * Today the generated program multiplies the base colour by `a_instanceColor` (`USE_INSTANCING_COLOR`). The engine
+ * stamps `u_a3dInstanceColorTarget` on the node's material (0 = "base", 1 = "emissive", 2 = "both"; written through the
+ * public `Material.setParameter` API) and ForwardPass routes the colours per draw:
+ *   - "base" (or no parameter): unchanged; this feature never selects, so the program is byte-identical.
+ *   - "both": `a_instanceColor` still multiplies the base, and this feature also multiplies the emissive term by it.
+ *   - "emissive": ForwardPass drops `instancing.color` from the program record (no base multiply) and binds the same
+ *     colour buffer as `a_a3dInstanceEmissive`; this feature declares it and multiplies the emissive term only.
+ * Multiply semantics match "base": give the material an emissive colour (white is the usual choice) and an
+ * `emissiveIntensity`, and each instance glows its own colour. Generated programs only.
+ */
+import { registerShaderChunk, registerShaderFeature, shaderChunk } from "../../contracts/program.js";
+import { MaterialInstance } from "../../MaterialInstance.js";
+export const A3D_INSTANCE_COLOR_TARGET_FEATURE = "prd04.instanceColorTarget";
+export const A3D_INSTANCE_COLOR_TARGET_PARAM = "u_a3dInstanceColorTarget";
+/** Per-instance attribute that carries the colours when the target is "emissive" (no base multiply). */
+export const A3D_INSTANCE_EMISSIVE_ATTRIBUTE = "a_a3dInstanceEmissive";
+export const A3D_INSTANCE_EMISSIVE_VTX_PARS_CHUNK = "a3d_prd04_instance_emissive_vtx_pars";
+export const A3D_INSTANCE_EMISSIVE_VTX_END_CHUNK = "a3d_prd04_instance_emissive_vtx_end";
+export const A3D_INSTANCE_EMISSIVE_FRAG_PARS_CHUNK = "a3d_prd04_instance_emissive_frag_pars";
+export const A3D_INSTANCE_EMISSIVE_FRAG_CALL_CHUNK = "a3d_prd04_instance_emissive_frag_call";
+// Varying named apart from PRD-11's `v_a3dInstanceEmissive` (`batching/shaders/instanceEmissive.glsl.ts`), so both
+// features may select in one program.
+const VTX_PARS_GLSL = /* glsl */ `
+#ifdef A3D_INSTANCE_EMISSIVE_ATTRIBUTE
+in vec4 a_a3dInstanceEmissive;
+out vec4 v_a3dInstanceEmissiveTint;
+#endif
+`;
+const VTX_END_GLSL = /* glsl */ `
+#ifdef A3D_INSTANCE_EMISSIVE_ATTRIBUTE
+v_a3dInstanceEmissiveTint = a_a3dInstanceEmissive;
+#endif
+`;
+const FRAG_PARS_GLSL = /* glsl */ `
+#ifdef A3D_INSTANCE_EMISSIVE_ATTRIBUTE
+in vec4 v_a3dInstanceEmissiveTint;
+#endif
+`;
+const FRAG_CALL_GLSL = /* glsl */ `
+#if defined(A3D_INSTANCE_EMISSIVE_ATTRIBUTE)
+a3dEmissive *= v_a3dInstanceEmissiveTint.rgb;
+#elif defined(USE_INSTANCING_COLOR)
+a3dEmissive *= v_instanceColor.rgb;
+#endif
+`;
+const TARGET_CODES = { base: 0, emissive: 1, both: 2 };
+/** Material parameter value for a target. */
+export function instanceColorTargetCode(target) {
+    return TARGET_CODES[target ?? "base"] ?? 0;
+}
+/** The target a material carries ("base" when it has none). */
+export function materialInstanceColorTarget(material) {
+    if (!material)
+        return "base";
+    const base = material instanceof MaterialInstance ? material.baseMaterial : material;
+    if (base.disposed)
+        return "base";
+    const value = base.getParameter(A3D_INSTANCE_COLOR_TARGET_PARAM);
+    return value === 1 ? "emissive" : value === 2 ? "both" : "base";
+}
+/** `select`: forward draws with per-instance colours whose material targets the emissive term. Pure. */
+export function selectInstanceColorTargetFeature(item, pass) {
+    if (pass !== "forward" || item.instanceTransforms === undefined || item.instanceColors === undefined)
+        return undefined;
+    const target = materialInstanceColorTarget(item.material);
+    return target === "base" ? undefined : target;
+}
+const FEATURE = {
+    id: A3D_INSTANCE_COLOR_TARGET_FEATURE,
+    owner: "prd04",
+    flag: "A3D_QR_MATERIALS",
+    order: 10,
+    select: (input) => selectInstanceColorTargetFeature(input.item, input.pass),
+    defines: (value) => value === "emissive"
+        ? { A3D_INSTANCE_COLOR_EMISSIVE: true, A3D_INSTANCE_EMISSIVE_ATTRIBUTE: true }
+        : { A3D_INSTANCE_COLOR_EMISSIVE: true },
+    chunks: [A3D_INSTANCE_EMISSIVE_VTX_PARS_CHUNK, A3D_INSTANCE_EMISSIVE_VTX_END_CHUNK, A3D_INSTANCE_EMISSIVE_FRAG_PARS_CHUNK, A3D_INSTANCE_EMISSIVE_FRAG_CALL_CHUNK],
+    hooks: ["vertex:pars", "vertex:end", "fragment:pars", "fragment:emissive"]
+};
+let registered = false;
+/** Registers the chunks and the `prd04.instanceColorTarget` ShaderFeature once per process (ForwardPass calls this at load). */
+export function registerInstanceColorTargetFeature() {
+    if (registered)
+        return;
+    const chunks = [
+        [A3D_INSTANCE_EMISSIVE_VTX_PARS_CHUNK, VTX_PARS_GLSL, "vertex"],
+        [A3D_INSTANCE_EMISSIVE_VTX_END_CHUNK, VTX_END_GLSL, "vertex"],
+        [A3D_INSTANCE_EMISSIVE_FRAG_PARS_CHUNK, FRAG_PARS_GLSL, "fragment"],
+        [A3D_INSTANCE_EMISSIVE_FRAG_CALL_CHUNK, FRAG_CALL_GLSL, "fragment"]
+    ];
+    for (const [name, glsl, stage] of chunks) {
+        if (!shaderChunk(name))
+            registerShaderChunk({ name, owner: "prd04", glsl, stage });
+    }
+    registerShaderFeature(FEATURE);
+    registered = true;
+}
+//# sourceMappingURL=instance_color_target.glsl.js.map

package/dist/shaders/chunks/instance_color_target.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance_color_target.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/instance_color_target.glsl.ts"],"names":[],"mappings":"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"}

package/dist/shaders/chunks/rim.glsl.d.ts

@@ -0,0 +1,37 @@
+/**
+ * GU47 E-D (PRD §3.1): `rim: { color, power, intensity }` on the forward PBR program.
+ *
+ * The forward term is the PRD-04 `prd04.rim` ShaderFeature (#88: `materials/features.ts`, chunks `a3d_prd04_rim_pars`
+ * and `a3d_prd04_rim_call` in `shaders/physical/lobe_calls.glsl.ts`, registered by `lanes/prd04.ts`). It adds
+ * `u_prd04RimColor * u_prd04RimStrength * (1 - N·V)^u_prd04RimPower` to the emitted light of lit generated programs and
+ * selects only when the draw's material carries `u_prd04RimStrength > 0`, so a material without rim (or with intensity
+ * 0) gets no feature bit, no define and no chunk: its program is byte-identical to the one it compiled to before.
+ *
+ * GU47 reuses that feature instead of registering a second one (a second `prd04.rim` id throws REGISTRY_DUPLICATE when
+ * the rendering barrel loads, and two rim terms could stack). This module is the single source of the parameter names
+ * and defaults the engine lowers `rim` onto (`production-runtime/ModelMaterialOverrides.ts` mirrors them, it cannot
+ * import this file), and of the `a3dRim()` GLSL the toon material and the author chunk `a3d_rim` share. Generated
+ * programs only (the default `A3D_QR_CORE` path); the frozen legacy shaderKey library (`?a3d-qr=-core`) has no rim.
+ */
+import type { Material } from "../../Material.js";
+import { MaterialInstance } from "../../MaterialInstance.js";
+/** The forward ShaderFeature that draws the rim (`materials/features.ts` `rimFeature`). */
+export declare const A3D_RIM_FEATURE = "prd04.rim";
+/** Material parameter names (also the GLSL uniform names of `a3d_prd04_rim_pars`). */
+export declare const A3D_RIM_COLOR_PARAM = "u_prd04RimColor";
+export declare const A3D_RIM_POWER_PARAM = "u_prd04RimPower";
+export declare const A3D_RIM_INTENSITY_PARAM = "u_prd04RimStrength";
+export declare const A3D_RIM_DEFAULT_POWER = 3;
+export declare const A3D_RIM_DEFAULT_INTENSITY = 1;
+/** Clamp ranges the engine lowering applies (`power` 0.1..16, `intensity` 0..16). */
+export declare const A3D_RIM_POWER_RANGE: readonly [number, number];
+export declare const A3D_RIM_INTENSITY_RANGE: readonly [number, number];
+/**
+ * `vec3 a3dRim(n, v, color, power, intensity)`: the same term as `a3d_prd04_rim_call`, written with `exp2/log2` instead
+ * of `pow` so it is defined for every input on every GPU and composes with the custom-material safe-`pow` define. Used by
+ * `material.toon` and published to `material.custom` authors as `#include <a3d_rim>`.
+ */
+export declare const A3D_RIM_FUNCTION_GLSL = "\nvec3 a3dRim(vec3 n, vec3 v, vec3 color, float power, float intensity) {\n  float facing = clamp(dot(n / max(length(n), 1e-4), v / max(length(v), 1e-4)), 0.0, 1.0);\n  float edge = exp2(clamp(power, 0.1, 16.0) * log2(max(1.0 - facing, 1e-4)));\n  return color * (clamp(intensity, 0.0, 16.0) * edge);\n}\n";
+/** The rim intensity a material carries (0 when it has no rim, so `prd04.rim` does not select). */
+export declare function materialRimIntensity(material: Material | MaterialInstance | undefined): number;
+//# sourceMappingURL=rim.glsl.d.ts.map

package/dist/shaders/chunks/rim.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rim.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/rim.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,2FAA2F;AAC3F,eAAO,MAAM,eAAe,cAAc,CAAC;AAE3C,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,oBAAoB,CAAC;AACrD,eAAO,MAAM,mBAAmB,oBAAoB,CAAC;AACrD,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAE5D,eAAO,MAAM,qBAAqB,IAAI,CAAC;AACvC,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAC3C,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAa,CAAC;AACxE,eAAO,MAAM,uBAAuB,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAW,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,sTAMjC,CAAC;AAEF,mGAAmG;AACnG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,gBAAgB,GAAG,SAAS,GAAG,MAAM,CAM9F"}

package/dist/shaders/chunks/rim.glsl.js

@@ -0,0 +1,50 @@
+/**
+ * GU47 E-D (PRD §3.1): `rim: { color, power, intensity }` on the forward PBR program.
+ *
+ * The forward term is the PRD-04 `prd04.rim` ShaderFeature (#88: `materials/features.ts`, chunks `a3d_prd04_rim_pars`
+ * and `a3d_prd04_rim_call` in `shaders/physical/lobe_calls.glsl.ts`, registered by `lanes/prd04.ts`). It adds
+ * `u_prd04RimColor * u_prd04RimStrength * (1 - N·V)^u_prd04RimPower` to the emitted light of lit generated programs and
+ * selects only when the draw's material carries `u_prd04RimStrength > 0`, so a material without rim (or with intensity
+ * 0) gets no feature bit, no define and no chunk: its program is byte-identical to the one it compiled to before.
+ *
+ * GU47 reuses that feature instead of registering a second one (a second `prd04.rim` id throws REGISTRY_DUPLICATE when
+ * the rendering barrel loads, and two rim terms could stack). This module is the single source of the parameter names
+ * and defaults the engine lowers `rim` onto (`production-runtime/ModelMaterialOverrides.ts` mirrors them, it cannot
+ * import this file), and of the `a3dRim()` GLSL the toon material and the author chunk `a3d_rim` share. Generated
+ * programs only (the default `A3D_QR_CORE` path); the frozen legacy shaderKey library (`?a3d-qr=-core`) has no rim.
+ */
+import { MaterialInstance } from "../../MaterialInstance.js";
+/** The forward ShaderFeature that draws the rim (`materials/features.ts` `rimFeature`). */
+export const A3D_RIM_FEATURE = "prd04.rim";
+/** Material parameter names (also the GLSL uniform names of `a3d_prd04_rim_pars`). */
+export const A3D_RIM_COLOR_PARAM = "u_prd04RimColor";
+export const A3D_RIM_POWER_PARAM = "u_prd04RimPower";
+export const A3D_RIM_INTENSITY_PARAM = "u_prd04RimStrength";
+export const A3D_RIM_DEFAULT_POWER = 3;
+export const A3D_RIM_DEFAULT_INTENSITY = 1;
+/** Clamp ranges the engine lowering applies (`power` 0.1..16, `intensity` 0..16). */
+export const A3D_RIM_POWER_RANGE = [0.1, 16];
+export const A3D_RIM_INTENSITY_RANGE = [0, 16];
+/**
+ * `vec3 a3dRim(n, v, color, power, intensity)`: the same term as `a3d_prd04_rim_call`, written with `exp2/log2` instead
+ * of `pow` so it is defined for every input on every GPU and composes with the custom-material safe-`pow` define. Used by
+ * `material.toon` and published to `material.custom` authors as `#include <a3d_rim>`.
+ */
+export const A3D_RIM_FUNCTION_GLSL = /* glsl */ `
+vec3 a3dRim(vec3 n, vec3 v, vec3 color, float power, float intensity) {
+  float facing = clamp(dot(n / max(length(n), 1e-4), v / max(length(v), 1e-4)), 0.0, 1.0);
+  float edge = exp2(clamp(power, 0.1, 16.0) * log2(max(1.0 - facing, 1e-4)));
+  return color * (clamp(intensity, 0.0, 16.0) * edge);
+}
+`;
+/** The rim intensity a material carries (0 when it has no rim, so `prd04.rim` does not select). */
+export function materialRimIntensity(material) {
+    if (!material)
+        return 0;
+    const base = material instanceof MaterialInstance ? material.baseMaterial : material;
+    if (base.disposed)
+        return 0;
+    const value = base.getParameter(A3D_RIM_INTENSITY_PARAM);
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+//# sourceMappingURL=rim.glsl.js.map

package/dist/shaders/chunks/rim.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rim.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/rim.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,2FAA2F;AAC3F,MAAM,CAAC,MAAM,eAAe,GAAG,WAAW,CAAC;AAE3C,sFAAsF;AACtF,MAAM,CAAC,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;AACrD,MAAM,CAAC,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;AACrD,MAAM,CAAC,MAAM,uBAAuB,GAAG,oBAAoB,CAAC;AAE5D,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AACvC,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAC3C,qFAAqF;AACrF,MAAM,CAAC,MAAM,mBAAmB,GAA8B,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;AACxE,MAAM,CAAC,MAAM,uBAAuB,GAA8B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAE1E;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;CAM/C,CAAC;AAEF,mGAAmG;AACnG,MAAM,UAAU,oBAAoB,CAAC,QAAiD;IACpF,IAAI,CAAC,QAAQ;QAAE,OAAO,CAAC,CAAC;IACxB,MAAM,IAAI,GAAG,QAAQ,YAAY,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC;IACrF,IAAI,IAAI,CAAC,QAAQ;QAAE,OAAO,CAAC,CAAC;IAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC;IACzD,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACtF,CAAC"}

package/dist/shadows/Prd02ShadowBridge.d.ts

@@ -16,15 +16,22 @@
  * (compiler/shadows.ts) for the config and `source.collectedLights` for the
  * sun, falling back to the scene graph only when the source carries neither.
  * Flag off never reaches this module (ShadowOrchestration legacy path).
+ *
+ * GU47 eint (E-B handoff EB-3): the shadowed spot / point lights of
+ * `source.collectedLights` (E-B's multi-caster selection) render into the
+ * PRD-02 local atlas in the same update and reach the forward pass as
+ * `ForwardShadowMapOptions.localShadows`, which the generated forward program
+ * samples per light (`program/chunks/shadow_forward.glsl.ts` `shadow_local`).
  */
 import type { Camera } from "@aura3d/scene";
 import type { ForwardShadowMapOptions } from "../ForwardPass.js";
+import type { CollectedLight } from "../LightCollector.js";
 import type { RenderDevice } from "../RenderDevice.js";
 import type { QrFlags } from "../contracts/core.js";
 import type { AuraQualityTierSettings } from "../contracts/quality.js";
 import type { RenderItem } from "../contracts/renderItem.js";
 import type { RenderSource } from "../contracts/renderSource.js";
-import { Prd02ShadowSystem, type Prd02ShadowFrameUniforms, type ShadowSystemConfigInput } from "./ShadowSystem.js";
+import { Prd02ShadowSystem, type Prd02ShadowFrameUniforms, type ShadowSystemConfigInput, type ShadowSystemLocalLight } from "./ShadowSystem.js";
 /** Uniform the `a3d_prd02_shadow_lookup` chunk declares (C-11); marks a lookup consumer. */
 export declare const PRD02_SHADOW_LOOKUP_UNIFORM = "u_prd02CascadeCompare0";
 type SourceLike = RenderSource | Iterable<RenderItem> | unknown;
@@ -33,6 +40,17 @@ type SourceLike = RenderSource | Iterable<RenderItem> | unknown;
  * else the legacy RendererShadowOptions mapped onto the tier defaults.
  */
 export declare function prd02ShadowConfig(source: SourceLike, flags: QrFlags, tier: AuraQualityTierSettings, cameraFar: number | undefined): ShadowSystemConfigInput;
+/** A shadow-casting spot / point light of the compiled source and its PRD-02 shadow-system input. */
+export interface Prd02LocalShadowLight {
+    readonly input: ShadowSystemLocalLight;
+    readonly light: CollectedLight;
+}
+/**
+ * Visible shadow-casting spot / point lights of `source.collectedLights`, in collected order (`shadowIndex` 0, 1, ...).
+ * Engine scenes mark them with E-B's multi-caster selection (`resolveProductionShadowCasterIndices`, capped by the
+ * tier's `localShadowLights`). Empty for sources without collected lights and with `?a3dLighting=atlas=off`.
+ */
+export declare function prd02LocalShadowLights(source: SourceLike): readonly Prd02LocalShadowLight[];
 /** Normalized direction of the first visible shadow-casting sun. */
 export declare function prd02SunDirection(source: SourceLike): readonly [number, number, number] | null;
 /** True when a forward program samples the prd02 lookup chunk (C-02 generator path). */
@@ -114,8 +132,13 @@ export declare function shadowFrameCamera(viewProjection: Float32Array | readonl
  * Renders the prd02 sun cascades now and returns them as legacy
  * `ForwardShadowMapOptions` (T0-26 bridge). Returns undefined — and allocates
  * nothing — when shadows are off/killed, a lookup-chunk consumer exists (the
- * contributor owns that path), or there is no sun, caster, camera or depth
- * texture support.
+ * contributor owns that path), or there is no sun or local caster, no caster
+ * item, camera or depth texture support.
+ *
+ * GU47 eint (E-B handoff EB-3): the explicitly shadowed spot / point lights of
+ * the compiled source (`prd02LocalShadowLights`) get PRD-02 atlas tiles in the
+ * same update, handed to the forward pass as `localShadows`; a scene whose only
+ * casters are local lights binds a strength-0 sun map plus its tiles.
  */
 export declare function executePrd02BridgedShadowMap(input: Prd02BridgeInput): ForwardShadowMapOptions | undefined;
 export {};

package/dist/shadows/Prd02ShadowBridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Prd02ShadowBridge.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/shadows/Prd02ShadowBridge.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Prd02ShadowBridge.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/shadows/Prd02ShadowBridge.ts"],"names":[],"mappings":"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"}

package/dist/shadows/Prd02ShadowBridge.js

@@ -16,6 +16,12 @@
  * (compiler/shadows.ts) for the config and `source.collectedLights` for the
  * sun, falling back to the scene graph only when the source carries neither.
  * Flag off never reaches this module (ShadowOrchestration legacy path).
+ *
+ * GU47 eint (E-B handoff EB-3): the shadowed spot / point lights of
+ * `source.collectedLights` (E-B's multi-caster selection) render into the
+ * PRD-02 local atlas in the same update and reach the forward pass as
+ * `ForwardShadowMapOptions.localShadows`, which the generated forward program
+ * samples per light (`program/chunks/shadow_forward.glsl.ts` `shadow_local`).
  */
 import { Sampler } from "../Sampler.js";
 import { createShadowFilterKernel } from "../ShadowMap.js";
@@ -75,6 +81,37 @@ export function prd02ShadowConfig(source, flags, tier, cameraFar) {
         ...(isShadowPcfTapTier(compiled?.pcfTapTier) ? { pcfTapTier: compiled.pcfTapTier } : {})
     };
 }
+/**
+ * Visible shadow-casting spot / point lights of `source.collectedLights`, in collected order (`shadowIndex` 0, 1, ...).
+ * Engine scenes mark them with E-B's multi-caster selection (`resolveProductionShadowCasterIndices`, capped by the
+ * tier's `localShadowLights`). Empty for sources without collected lights and with `?a3dLighting=atlas=off`.
+ */
+export function prd02LocalShadowLights(source) {
+    if (!source || typeof source !== "object" || Symbol.iterator in source)
+        return [];
+    const collected = source.collectedLights;
+    if (collected === undefined || !readPrd02KillSwitches(source).atlas)
+        return [];
+    const out = [];
+    for (const light of collected) {
+        if (!light.castsShadow || light.source?.visible === false)
+            continue;
+        if (light.kind !== "spot" && light.kind !== "point")
+            continue;
+        out.push({
+            light,
+            input: {
+                shadowIndex: out.length,
+                kind: light.kind,
+                position: light.position,
+                direction: light.kind === "spot" ? light.direction : [0, -1, 0],
+                range: light.range,
+                ...(light.kind === "spot" ? { outerAngleRadians: light.spotAngle } : {})
+            }
+        });
+    }
+    return out;
+}
 /** Normalized direction of the first visible shadow-casting sun. */
 export function prd02SunDirection(source) {
     const collected = source && typeof source === "object" && !(Symbol.iterator in source)
@@ -183,8 +220,13 @@ export function shadowFrameCamera(viewProjection, eye, viewMatrix) {
  * Renders the prd02 sun cascades now and returns them as legacy
  * `ForwardShadowMapOptions` (T0-26 bridge). Returns undefined — and allocates
  * nothing — when shadows are off/killed, a lookup-chunk consumer exists (the
- * contributor owns that path), or there is no sun, caster, camera or depth
- * texture support.
+ * contributor owns that path), or there is no sun or local caster, no caster
+ * item, camera or depth texture support.
+ *
+ * GU47 eint (E-B handoff EB-3): the explicitly shadowed spot / point lights of
+ * the compiled source (`prd02LocalShadowLights`) get PRD-02 atlas tiles in the
+ * same update, handed to the forward pass as `localShadows`; a scene whose only
+ * casters are local lights binds a strength-0 sun map plus its tiles.
  */
 export function executePrd02BridgedShadowMap(input) {
     bridgedFrames.delete(input.device);
@@ -208,7 +250,8 @@ export function executePrd02BridgedShadowMap(input) {
     if (!camera?.viewProjectionMatrix)
         return bail("no-camera");
     const sun = prd02SunDirection(input.source);
-    if (!sun)
+    const localLights = prd02LocalShadowLights(input.source);
+    if (!sun && localLights.length === 0)
         return bail("no-sun");
     const tier = input.tier ?? QUALITY_TIERS.high;
     const config = prd02ShadowConfig(input.source, input.flags, tier, camera.far);
@@ -228,14 +271,21 @@ export function executePrd02BridgedShadowMap(input) {
     // camera's real clip range; `config.maxDistance` caps the cascade splits.
     const uniforms = system.update({
         camera: { viewProjectionMatrix: camera.viewProjectionMatrix, near, far: camera.far ?? 200 },
-        sun: { direction: sun },
+        sun: sun ? { direction: sun } : null,
         casters: input.items,
-        // Local (spot/point) prd02 tiles need the lookup chunk; the bridge is sun-only.
-        localLights: [],
+        // GU47 eint (EB-3): local (spot / point) tiles render here too; the forward pass samples them.
+        localLights: localLights.map((light) => light.input),
         flags: input.flags,
         tier,
         ...(cascadeUse ? { cascadeUse } : {})
     });
+    const localShadows = bridgeLocalShadows(uniforms, localLights, config);
+    if (!sun) {
+        if (!localShadows.texture)
+            return bail("no-local-tiles");
+        bridgedFrames.set(input.device, { uniforms, config, system });
+        return localOnlyShadowMap(localShadows);
+    }
     const fits = system.cascadeFits();
     const maps = fits.map((fit) => {
         const texture = uniforms.cascadeTextures[fit.index] ?? null;
@@ -247,7 +297,7 @@ export function executePrd02BridgedShadowMap(input) {
     const resolved = maps;
     const first = resolved[0].map;
     if (resolved.length === 1)
-        return first;
+        return { ...first, localShadows };
     let previousFar = 0;
     return {
         ...first,
@@ -255,7 +305,83 @@ export function executePrd02BridgedShadowMap(input) {
             const cascade = { index: fit.index, near: previousFar, far: fit.splitFar, shadowMap: map };
             previousFar = fit.splitFar;
             return cascade;
-        })
+        }),
+        localShadows
+    };
+}
+/** Local-tile receiver biases in tile texels (GU47 eint EB-3; tuned by the phase-2 local-shadow frames). */
+const LOCAL_DEPTH_BIAS_TEXELS = 1;
+const LOCAL_NORMAL_BIAS_TEXELS = 1;
+/** `shadows/ShadowSystem.ts` ATLAS_SIZE, for a mock atlas texture without a width. */
+const LOCAL_ATLAS_FALLBACK_SIZE = 1024;
+const LOCAL_COMPARE = new Sampler({
+    minFilter: "linear",
+    magFilter: "linear",
+    addressU: "clamp-to-edge",
+    addressV: "clamp-to-edge",
+    compare: "less-equal"
+});
+const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+/** The spot tile's field of view (`ShadowAtlas.spotClip`). */
+function spotTileFov(outerAngleRadians) {
+    return Math.min(Math.PI - 1e-3, Math.max(1e-3, (outerAngleRadians ?? Math.PI / 4) * 2));
+}
+/**
+ * GU47 eint (EB-3): this frame's atlas tiles as `ForwardShadowMapOptions.localShadows`. A light gets a slot only when
+ * all its tiles were kept, in face order (a spot 1, a point 6 consecutive); `slots` is empty (and `texture` unset)
+ * when no light did, which still tells the forward pass the bridged map is the sun's.
+ */
+function bridgeLocalShadows(uniforms, lights, config) {
+    const tilesByLight = new Map();
+    const pairs = uniforms.perLightShadowIndex;
+    for (let i = 0; i + 1 < pairs.length; i += 2) {
+        const tiles = tilesByLight.get(pairs[i]) ?? [];
+        tiles.push(pairs[i + 1]);
+        tilesByLight.set(pairs[i], tiles);
+    }
+    const atlas = uniforms.atlasTexture;
+    const atlasSize = atlas && atlas.width > 0 ? atlas.width : LOCAL_ATLAS_FALLBACK_SIZE;
+    const texelScale = new Float32Array(8);
+    const slots = new Map();
+    for (const { input, light } of atlas ? lights : []) {
+        const tiles = tilesByLight.get(input.shadowIndex) ?? [];
+        if (tiles.length !== (input.kind === "point" ? 6 : 1) || tiles.some((tile, face) => tile !== tiles[0] + face))
+            continue;
+        const tanHalfFov = input.kind === "point" ? 1 : Math.tan(spotTileFov(input.outerAngleRadians) / 2);
+        for (const tile of tiles) {
+            texelScale[tile] = (2 * tanHalfFov) / Math.max(1, (uniforms.localShadowData[tile * 4 + 2] ?? 0) * atlasSize);
+        }
+        slots.set(light, tiles[0]);
+    }
+    return {
+        slots,
+        ...(atlas && slots.size > 0 ? { texture: new TextureBinding({ name: "u_localShadowAtlas", texture: atlas, sampler: LOCAL_COMPARE, required: true }) } : {}),
+        atlasSize,
+        matrices: uniforms.localShadowMatrices,
+        rects: uniforms.localShadowData,
+        texelScale,
+        strength: config.strength,
+        biasTexels: LOCAL_DEPTH_BIAS_TEXELS,
+        slopeBiasTexels: BRIDGE_SLOPE_BIAS,
+        normalBiasTexels: LOCAL_NORMAL_BIAS_TEXELS
+    };
+}
+/**
+ * A frame whose only casters are local lights: the forward programs still declare the sun map, so it is bound to the
+ * atlas at strength 0 (no light is gated onto it: `forwardShadedLights` clears every local caster's gate).
+ */
+function localOnlyShadowMap(localShadows) {
+    const texel = 1 / localShadows.atlasSize;
+    return {
+        texture: new TextureBinding({ name: "u_shadowMapTexture", texture: localShadows.texture.texture, sampler: NEAREST_CLAMP, required: true }),
+        lightMatrix: IDENTITY,
+        strength: 0,
+        bias: BRIDGE_AUTO_DEPTH_BIAS,
+        slopeBias: BRIDGE_SLOPE_BIAS,
+        normalBias: 0,
+        texelSize: [texel, texel],
+        filterKernel: createShadowFilterKernel({ filter: "none" }),
+        localShadows
     };
 }
 function bridgeShadowMap(texture, lightMatrix, config, texelWorld) {