@flighthq/scene3d-gl 0.2.1-next.840.857425c

package/dist/glShadedPrelude.js

@@ -0,0 +1,393 @@
+import { createModifierRegistry, getModifierDefineKey, orderModifierStack, resolveModifier } from '@flighthq/shading';
+import { MAX_FORWARD_LIGHTS, ModifierSlot } from '@flighthq/types';
+import { GL_MESH_LIGHT_BLOCK_GLSL, resolveGlLitLocations } from './glLitProgram';
+import { GL_SKIN_VERTEX_DECLARATIONS_GLSL, GL_UV_TRANSFORM_VERTEX_GLSL, compileGlProgram, ensureGlScene3DProgram, } from './glMeshProgram';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+// The stable program-cache key for a ShadedMaterial variant: the base feature flags joined with the
+// modifier stack's define-key. Two materials sharing both the same base flags AND the same modifier
+// feature-set produce the same key and share one compiled program (and batch together); a different
+// map set OR a different modifier feature-set breaks the batch. `modifierDefineKey` comes from
+// @flighthq/shading's getModifierDefineKey, so cross-slot authoring order never changes it.
+export function buildGlShadedCacheKey(key, modifierDefineKey) {
+    const base = `${key.alphaMaskEnabled ? 'm' : '-'}${key.hasDiffuseMap ? 'd' : '-'}${key.hasSpecularMap ? 's' : '-'}${key.hasNormalMap ? 'n' : '-'}${key.hasUvTransform ? 'u' : '-'}${key.hasSkin ? 'k' : '-'}`;
+    return `shaded:${base}|${modifierDefineKey}`;
+}
+// Compiles the ShadedMaterial uber-shader for a base key and an ORDERED modifier stack: assembles the
+// base lit source (reusing GL_MESH_LIGHT_BLOCK_GLSL for lighting — no second light loop) with each
+// modifier's GLSL injected at its slot hook, links it, and resolves the base + time uniform
+// locations. Pure GL work — no caching — used by ensureGlShadedProgram. Throws on a compile/link
+// failure (a programmer error: a malformed base or modifier snippet), not an expected runtime case.
+export function compileGlShadedProgram(gl, key, orderedModifiers, registry) {
+    const defineSource = buildGlShadedDefineSource(key);
+    // The skin GLSL is vertex-only (its `in` attributes are illegal in a fragment shader), so it is
+    // spliced into the vertex source alone, never the fragment. The Vertex-slot modifiers are likewise
+    // vertex-only — they deform the geometry — so they inject into the vertex body, not the fragment.
+    const vertexSource = defineSource +
+        (key.hasSkin ? GL_SKIN_VERTEX_DECLARATIONS_GLSL : '') +
+        assembleGlShadedVertexBody(orderedModifiers, registry);
+    const fragmentSource = defineSource + assembleGlShadedFragmentBody(orderedModifiers, registry);
+    const program = compileGlProgram(gl, vertexSource, fragmentSource);
+    return {
+        ...resolveGlLitLocations(gl, program),
+        program,
+        locAlphaCutoff: gl.getUniformLocation(program, 'u_alphaCutoff'),
+        locDiffuse: gl.getUniformLocation(program, 'u_diffuse'),
+        locDiffuseMap: gl.getUniformLocation(program, 'u_diffuseMap'),
+        locJointTexture: gl.getUniformLocation(program, 'u_jointTexture'),
+        locModel: gl.getUniformLocation(program, 'u_model'),
+        locNormalMap: gl.getUniformLocation(program, 'u_normalMap'),
+        locNormalMatrix: gl.getUniformLocation(program, 'u_normalMatrix'),
+        locNormalScale: gl.getUniformLocation(program, 'u_normalScale'),
+        locShininess: gl.getUniformLocation(program, 'u_shininess'),
+        locSpecular: gl.getUniformLocation(program, 'u_specular'),
+        locSpecularMap: gl.getUniformLocation(program, 'u_specularMap'),
+        locTime: gl.getUniformLocation(program, 'u_time'),
+        locViewProjection: gl.getUniformLocation(program, 'u_viewProjection'),
+    };
+}
+// Resolves the ShadedMaterial program for a base key and modifier stack, compiling and caching it on
+// first use under the `shaded:` family namespace. Orders the stack and computes its define-key from
+// this state's modifier-snippet registry (so the cache key captures every compile-time modifier
+// variant), then keys the shared scene program cache by base-key + modifier-define-key — each variant
+// compiles at most once per state and reused every frame.
+export function ensureGlShadedProgram(state, key, modifiers) {
+    // A null registry means no modifier snippet was ever registered (the lazy-allocation default); the
+    // shared empty registry then yields the coarse bare-kind define-key and no modifier GLSL — the same
+    // result an allocated-but-empty registry gives — without allocating on this per-bind path.
+    const registry = getGlScene3DRuntime(state).modifierSnippetRegistry ?? EMPTY_MODIFIER_REGISTRY;
+    const ordered = orderModifierStack(modifiers);
+    // Fold the render-state skinned-run flag into the variant so a skinned draw of an otherwise-identical
+    // material compiles + caches its own HAS_SKIN program, without the material renderer knowing.
+    const fullKey = {
+        ...key,
+        hasSkin: getGlScene3DRuntime(state).activeSkinnedRun,
+    };
+    const cacheKey = buildGlShadedCacheKey(fullKey, getModifierDefineKey(modifiers, registry));
+    return ensureGlScene3DProgram(state, cacheKey, (gl) => compileGlShadedProgram(gl, fullKey, ordered, registry));
+}
+// Assembles the ShadedMaterial fragment body for an ordered modifier stack: each FRAGMENT-slot
+// modifier's declarations are collected at the top, and each contribution is injected at the hook for
+// its slot (Normal perturbs the normal before lighting, Diffuse/Specular adjust the surface terms,
+// Emissive adds self-illumination, Effect post-processes the shaded radiance). Vertex-slot modifiers
+// are skipped here — they inject into the vertex body (assembleGlShadedVertexBody). A modifier whose
+// kind has no registered GL snippet contributes nothing. An empty stack leaves every hook empty,
+// yielding the lean plain-ShadedMaterial variant that pays nothing for modifiers it does not carry.
+function assembleGlShadedFragmentBody(orderedModifiers, registry) {
+    let declarations = '';
+    let normal = '';
+    let diffuse = '';
+    let specular = '';
+    let emissive = '';
+    let effect = '';
+    for (let index = 0; index < orderedModifiers.length; index++) {
+        const modifier = orderedModifiers[index];
+        const snippet = resolveModifier(registry, modifier.kind);
+        if (snippet === null || snippet.slot === ModifierSlot.Vertex)
+            continue;
+        if (snippet.declarations !== undefined)
+            declarations += `${snippet.declarations(modifier, index)}\n`;
+        const contribution = `${snippet.contribution(modifier, index)}\n`;
+        if (snippet.slot === ModifierSlot.Normal)
+            normal += contribution;
+        else if (snippet.slot === ModifierSlot.Diffuse)
+            diffuse += contribution;
+        else if (snippet.slot === ModifierSlot.Specular)
+            specular += contribution;
+        else if (snippet.slot === ModifierSlot.Emissive)
+            emissive += contribution;
+        else if (snippet.slot === ModifierSlot.Effect)
+            effect += contribution;
+    }
+    return SHADED_FRAGMENT_TEMPLATE.replace('//@DECLARATIONS', dedupeGlShadedDeclarations(declarations))
+        .replace('//@NORMAL', normal)
+        .replace('//@DIFFUSE', diffuse)
+        .replace('//@SPECULAR', specular)
+        .replace('//@EMISSIVE', emissive)
+        .replace('//@EFFECT', effect);
+}
+// Assembles the ShadedMaterial vertex body for an ordered modifier stack: only the VERTEX-slot
+// modifiers contribute here (they deform the geometry). Their declarations go at the top-level
+// //@VERTEX_DECLARATIONS hook and their contributions at the //@VERTEX hook — after localPosition/
+// localNormal are computed (post-skin) but before the model transform, so displacement composes with
+// skinning. Non-vertex slots are skipped (they inject into the fragment body). An empty vertex set
+// leaves both hooks empty, yielding the plain vertex program.
+function assembleGlShadedVertexBody(orderedModifiers, registry) {
+    let declarations = '';
+    let vertex = '';
+    for (let index = 0; index < orderedModifiers.length; index++) {
+        const modifier = orderedModifiers[index];
+        const snippet = resolveModifier(registry, modifier.kind);
+        if (snippet === null || snippet.slot !== ModifierSlot.Vertex)
+            continue;
+        if (snippet.declarations !== undefined)
+            declarations += `${snippet.declarations(modifier, index)}\n`;
+        vertex += `${snippet.contribution(modifier, index)}\n`;
+    }
+    return SHADED_VERTEX_BODY.replace('//@VERTEX_DECLARATIONS', dedupeGlShadedDeclarations(declarations)).replace('//@VERTEX', vertex);
+}
+// Collapses duplicate declaration lines in an assembled modifier declaration block, preserving the
+// order of first appearance and dropping later exact repeats. Per-instance uniforms are unique (each
+// name carries its stack-index suffix, e.g. `u_fogColor_2`), so they always survive; the SHARED
+// un-suffixed lines a snippet declares — the IBL environment samplers an env-reflect modifier reads,
+// or the value-noise helper a procedural dissolve declares — collapse to one when two modifiers of the
+// same kind appear in one stack, avoiding a GLSL redefinition error. Blank lines are kept verbatim so
+// helper-function bodies (whose braces span lines) stay intact.
+function dedupeGlShadedDeclarations(declarations) {
+    const seen = new Set();
+    let result = '';
+    for (const line of declarations.split('\n')) {
+        const trimmed = line.trim();
+        const isSharedDeclaration = trimmed.startsWith('uniform ') && !/_\d+\b/.test(trimmed);
+        if (isSharedDeclaration) {
+            if (seen.has(trimmed))
+                continue;
+            seen.add(trimmed);
+        }
+        result += `${line}\n`;
+    }
+    return result;
+}
+// Builds the leading "#version 300 es\n#define ..." block shared by the vertex and fragment stages
+// for a base key. Modifier variants are NOT #defines — they are injected as GLSL by
+// assembleGlShadedFragmentBody — so only the base map/alpha flags appear here.
+function buildGlShadedDefineSource(key) {
+    let defines = `#version 300 es\n#define MAX_FORWARD_LIGHTS ${MAX_FORWARD_LIGHTS}\n`;
+    if (key.alphaMaskEnabled)
+        defines += '#define ALPHA_MASK\n';
+    if (key.hasDiffuseMap)
+        defines += '#define HAS_DIFFUSE_MAP\n';
+    if (key.hasSpecularMap)
+        defines += '#define HAS_SPECULAR_MAP\n';
+    if (key.hasNormalMap)
+        defines += '#define HAS_NORMAL_MAP\n';
+    if (key.hasUvTransform)
+        defines += '#define HAS_UV_TRANSFORM\n';
+    if (key.hasSkin)
+        defines += '#define HAS_SKIN\n';
+    return defines;
+}
+const SHADED_VERTEX_BODY = `
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec3 a_normal;
+layout(location = 2) in vec4 a_tangent;
+layout(location = 3) in vec2 a_uv0;
+
+uniform mat4 u_viewProjection;
+uniform mat4 u_model;
+uniform mat3 u_normalMatrix;
+uniform float u_time;
+${GL_UV_TRANSFORM_VERTEX_GLSL}
+out vec3 v_worldPosition;
+out vec3 v_normal;
+out vec4 v_tangent;
+out vec2 v_uv0;
+
+//@VERTEX_DECLARATIONS
+
+void main() {
+#ifdef HAS_SKIN
+  mat4 skin = skinMatrix();
+  vec4 localPosition = skin * vec4(a_position, 1.0);
+  vec3 localNormal = mat3(skin) * a_normal;
+  vec3 localTangent = mat3(skin) * a_tangent.xyz;
+#else
+  vec4 localPosition = vec4(a_position, 1.0);
+  vec3 localNormal = a_normal;
+  vec3 localTangent = a_tangent.xyz;
+#endif
+  vec2 vertexUv = a_uv0;
+
+  // Vertex slot: read/write \`localPosition\` (the pre-model local vertex) and \`localNormal\`; the
+  // procedural cases scroll by \`u_time\` and read \`vertexUv\` (the raw uv, before the uv transform).
+  //@VERTEX
+
+  vec4 worldPosition = u_model * localPosition;
+  v_worldPosition = worldPosition.xyz;
+  v_normal = u_normalMatrix * localNormal;
+  v_tangent = vec4(u_normalMatrix * localTangent, a_tangent.w);
+  v_uv0 = applyUvTransform(a_uv0);
+  gl_Position = u_viewProjection * worldPosition;
+}
+`;
+// The ShadedMaterial fragment: a classic diffuse + half-vector-specular base over the shared light
+// block, with five modifier slot hooks. The base is a self-contained blinn-phong assembly (the third
+// such assembly over GL_MESH_LIGHT_BLOCK_GLSL, alongside classic + PBR); the //@HOOK markers are
+// substituted with injected modifier GLSL at compile time. The variables each hook may read/write
+// are documented at the marker — this is the injection contract a GL modifier snippet targets.
+const SHADED_FRAGMENT_TEMPLATE = `
+precision highp float;
+
+in vec3 v_worldPosition;
+in vec3 v_normal;
+in vec4 v_tangent;
+in vec2 v_uv0;
+
+uniform vec4 u_diffuse;
+uniform vec4 u_specular;
+uniform float u_shininess;
+uniform float u_normalScale;
+uniform float u_alphaCutoff;
+uniform float u_time;
+${GL_MESH_LIGHT_BLOCK_GLSL}
+
+#ifdef HAS_DIFFUSE_MAP
+uniform sampler2D u_diffuseMap;
+#endif
+#ifdef HAS_SPECULAR_MAP
+uniform sampler2D u_specularMap;
+#endif
+#ifdef HAS_NORMAL_MAP
+uniform sampler2D u_normalMap;
+#endif
+
+uniform float u_objectAlpha;
+
+out vec4 fragColor;
+
+// sRgb albedo texels are gamma-encoded; decode to linear before lighting.
+vec3 srgbToLinear(vec3 c) {
+  vec3 lo = c / 12.92;
+  vec3 hi = pow((c + 0.055) / 1.055, vec3(2.4));
+  return mix(lo, hi, step(0.04045, c));
+}
+
+// Deterministic 2D value noise, declared in the base so any Effect-slot modifier (the procedural
+// dissolve mask) can call it without redeclaring a function — a GLSL compiler drops it when no
+// modifier references it, so a plain ShadedMaterial pays nothing for it.
+float shadedHashNoise(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+float shadedValueNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  float a = shadedHashNoise(i + vec2(0.0, 0.0));
+  float b = shadedHashNoise(i + vec2(1.0, 0.0));
+  float c = shadedHashNoise(i + vec2(0.0, 1.0));
+  float d = shadedHashNoise(i + vec2(1.0, 1.0));
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+// Diffuse + half-vector (BlinnPhong) specular for ONE light. Every light type routes through this so
+// they never fork the shading model — the caller supplies the surface->light direction and the
+// (attenuated) radiance.
+vec3 shadeShadedLight(vec3 normal, vec3 lightDir, vec3 lightColor, vec3 diffuseRgb, vec3 specularColor, float shininess) {
+  float nDotL = max(dot(normal, lightDir), 0.0);
+  vec3 result = diffuseRgb * nDotL * lightColor;
+  if (nDotL > 0.0) {
+    vec3 viewDir = normalize(u_cameraPosition - v_worldPosition);
+    vec3 halfVec = normalize(lightDir + viewDir);
+    float specAngle = max(dot(normal, halfVec), 0.0);
+    result += pow(specAngle, max(shininess, 1.0)) * specularColor * lightColor;
+  }
+  return result;
+}
+
+//@DECLARATIONS
+
+void main() {
+  vec4 diffuse = u_diffuse;
+#ifdef HAS_DIFFUSE_MAP
+  vec4 sampledDiffuse = texture(u_diffuseMap, v_uv0);
+  diffuse.rgb *= srgbToLinear(sampledDiffuse.rgb);
+  diffuse.a *= sampledDiffuse.a;
+#endif
+
+  vec3 geometricNormal = normalize(v_normal);
+  if (!gl_FrontFacing) geometricNormal = -geometricNormal;
+  // Gram-Schmidt-reorthogonalize the interpolated tangent against the interpolated normal before
+  // building the TBN: linear interpolation across a triangle leaves v_tangent no longer perpendicular
+  // to v_normal, and skipping this step skews the tangent frame — the normal-map artifact this base
+  // shader previously exhibited. Mirrors the PBR prelude's TBN construction exactly.
+  vec3 tangent = normalize(v_tangent.xyz - geometricNormal * dot(v_tangent.xyz, geometricNormal));
+  vec3 bitangent = cross(geometricNormal, tangent) * v_tangent.w;
+  mat3 tbn = mat3(tangent, bitangent, geometricNormal);
+
+  vec3 normal = geometricNormal;
+#ifdef HAS_NORMAL_MAP
+  vec3 baseTangentNormal = texture(u_normalMap, v_uv0).xyz * 2.0 - 1.0;
+  baseTangentNormal.xy *= u_normalScale;
+  normal = normalize(tbn * baseTangentNormal);
+#endif
+
+  // Normal slot: read/write \`normal\` (the world-space shading normal). \`tbn\` maps tangent- to
+  // world-space; \`v_uv0\` and \`u_time\` drive scrolling perturbations.
+  //@NORMAL
+
+  vec3 specularColor = u_specular.rgb;
+#ifdef HAS_SPECULAR_MAP
+  specularColor *= srgbToLinear(texture(u_specularMap, v_uv0).rgb);
+#endif
+  float shininess = u_shininess;
+
+  // Diffuse slot: read/write \`diffuse\` (vec4 linear albedo + alpha).
+  //@DIFFUSE
+  // Specular slot: read/write \`specularColor\` (linear) and \`shininess\`.
+  //@SPECULAR
+
+#ifdef ALPHA_MASK
+  if (diffuse.a < u_alphaCutoff) discard;
+#endif
+
+  vec3 radiance = vec3(0.0);
+
+  // Directional light: -direction is the surface->light vector; modulated by the shared shadow term.
+  if (u_directionalCount > 0.5) {
+    vec3 lightDir = normalize(-u_directional.xyz);
+    float shadow = sampleDirectionalShadow(v_worldPosition);
+    radiance += shadeShadedLight(normal, lightDir, u_directionalRadiance.rgb, diffuse.rgb, specularColor, shininess) * shadow;
+  }
+
+  // Point lights: surface->light direction with a smooth inverse-square range falloff.
+  for (int i = 0; i < MAX_FORWARD_LIGHTS; i++) {
+    if (i >= u_pointCount) break;
+    vec3 toLight = u_pointLights[i * 2 + 0].xyz - v_worldPosition;
+    float dist2 = dot(toLight, toLight);
+    vec3 lightDir = toLight * inversesqrt(max(dist2, 1e-8));
+    float atten = rangeWindow(dist2, u_pointLights[i * 2 + 1].w) / max(dist2, 1e-4);
+    radiance += shadeShadedLight(normal, lightDir, u_pointLights[i * 2 + 1].rgb * atten, diffuse.rgb, specularColor, shininess);
+  }
+
+  // Spot lights: point attenuation times a smooth cone falloff between the inner/outer cosines.
+  for (int i = 0; i < MAX_FORWARD_LIGHTS; i++) {
+    if (i >= u_spotCount) break;
+    vec3 toLight = u_spotLights[i * 4 + 0].xyz - v_worldPosition;
+    float dist2 = dot(toLight, toLight);
+    vec3 lightDir = toLight * inversesqrt(max(dist2, 1e-8));
+    float atten = rangeWindow(dist2, u_spotLights[i * 4 + 1].w) / max(dist2, 1e-4);
+    float cone = smoothstep(u_spotLights[i * 4 + 3].y, u_spotLights[i * 4 + 3].x,
+                            dot(normalize(u_spotLights[i * 4 + 2].xyz), -lightDir));
+    radiance += shadeShadedLight(normal, lightDir, u_spotLights[i * 4 + 1].rgb * atten * cone, diffuse.rgb, specularColor, shininess);
+  }
+
+  // Ambient term: flat irradiance over the diffuse albedo.
+  if (u_ambientCount > 0.5) {
+    radiance += diffuse.rgb * u_ambientRadiance;
+  }
+
+  // Hemisphere fill: sky/ground gradient blended by the normal's vertical component.
+  for (int i = 0; i < MAX_FORWARD_LIGHTS; i++) {
+    if (i >= u_hemisphereCount) break;
+    float f = 0.5 + 0.5 * dot(normal, u_hemisphereLights[i * 3 + 2].xyz);
+    radiance += mix(u_hemisphereLights[i * 3 + 1].rgb, u_hemisphereLights[i * 3 + 0].rgb, f) * diffuse.rgb;
+  }
+
+  // Emissive slot: add self-illumination into \`emissive\` (linear radiance). \`normal\`, the light
+  // uniforms, and \`v_uv0\` are available for facing gates and masks.
+  vec3 emissive = vec3(0.0);
+  //@EMISSIVE
+  radiance += emissive;
+
+  // Effect slot: post-process the shaded \`radiance\` (view-dependent rim, tint, etc). \`viewDir\` is
+  // the world-space surface->camera direction; \`normal\` and \`v_uv0\` are available.
+  vec3 viewDir = normalize(u_cameraPosition - v_worldPosition);
+  //@EFFECT
+
+  fragColor = vec4(radiance, diffuse.a);
+  fragColor.a *= u_objectAlpha;
+}
+`;
+// A shared frozen empty registry used as the no-snippets fallback when a state has never had a
+// modifier snippet registered, so ensureGlShadedProgram allocates nothing per bind.
+const EMPTY_MODIFIER_REGISTRY = createModifierRegistry();
+//# sourceMappingURL=glShadedPrelude.js.map

package/dist/glShadedPrelude.js.map

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

package/dist/glShadowMap.d.ts

@@ -0,0 +1,3 @@
+import type { Camera3D, GlRenderState, Node3D } from '@flighthq/types';
+export declare function drawGlScene3DShadowMap(state: GlRenderState, scene: Readonly<Node3D>, shadowCamera: Readonly<Camera3D>): void;
+//# sourceMappingURL=glShadowMap.d.ts.map

package/dist/glShadowMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glShadowMap.d.ts","sourceRoot":"","sources":["../src/glShadowMap.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAQ,MAAM,EAA+B,MAAM,iBAAiB,CAAC;AAmB1G,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAC/B,IAAI,CA0FN"}

package/dist/glShadowMap.js

@@ -0,0 +1,150 @@
+import { getCamera3DViewProjectionMatrix4 } from '@flighthq/camera';
+import { createMatrix4 } from '@flighthq/geometry';
+import { hasMeshGeometrySkin } from '@flighthq/mesh';
+import { forEachNodeDescendant, getNodeWorldMatrix4 } from '@flighthq/node';
+import { createGlRenderTarget, uploadGlSkinPaletteTexture } from '@flighthq/render-gl';
+import { compileGlProgram, ensureGlScene3DProgram, GL_SKIN_VERTEX_DECLARATIONS_GLSL, SKIN_PALETTE_TEXTURE_UNIT, } from './glMeshProgram';
+import { ensureGlMeshUpload } from './glMeshUpload';
+import { ensureGlSkinPalette, getGlScene3DRuntime } from './glScene3DRuntime';
+// The directional shadow recipe's first pass: render scene depth from the light's point of view into a
+// sampleable depth render target (the shadow map), and record it + the light view-projection on the
+// scene runtime. The subsequent drawGlScene3D's lit binds (bindGlMeshLightBlock) read that to PCF-sample
+// the shadow during shading. Shadows are opt-in: an app that never calls this leaves runtime.shadow
+// null, so existing scenes render unchanged.
+//
+// `shadowCamera` is the orthographic light camera (see camera's configureDirectionalShadowCamera3D). All
+// meshes are drawn (no frustum cull — an off-screen caster can still shadow the visible scene).
+export function drawGlScene3DShadowMap(state, scene, shadowCamera) {
+    const gl = state.gl;
+    const runtime = getGlScene3DRuntime(state);
+    if (runtime.shadowTarget === null) {
+        runtime.shadowTarget = createGlRenderTarget(state, {
+            depth: 'depth-stencil-sampled',
+            height: SHADOW_MAP_SIZE,
+            width: SHADOW_MAP_SIZE,
+        });
+    }
+    const target = runtime.shadowTarget;
+    const matrix = runtime.shadow?.matrix ?? createMatrix4();
+    getCamera3DViewProjectionMatrix4(matrix, shadowCamera, 1);
+    const rigidProgram = ensureGlScene3DProgram(state, 'shadow:depth', compileShadowDepthProgram);
+    // Compiled lazily on the first GPU-skinned caster so a scene without skinned meshes never pays for it.
+    let skinnedProgram = null;
+    const prevFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+    const prevViewport = gl.getParameter(gl.VIEWPORT);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, target.framebuffer);
+    gl.viewport(0, 0, target.width, target.height);
+    gl.enable(gl.DEPTH_TEST);
+    gl.depthFunc(gl.LESS);
+    gl.depthMask(true);
+    // Render back faces into the depth map (cull front). On a closed caster the recorded depth is the
+    // surface's far side, so the lit front faces compare against it and self-shadow acne disappears
+    // without a large depth bias. Open receivers (the ground plane) simply contribute nothing here,
+    // which is harmless — nothing lies beneath them to receive their cast.
+    gl.enable(gl.CULL_FACE);
+    gl.cullFace(gl.FRONT);
+    gl.clear(gl.DEPTH_BUFFER_BIT | gl.COLOR_BUFFER_BIT);
+    // u_viewProjection is per program (default uniforms persist per program object), so it is set on each
+    // program switch; u_model is per caster. boundProgram tracks the last program bound to avoid redundant
+    // useProgram + view-projection uploads across a run of same-kind casters.
+    let boundProgram = null;
+    forEachNodeDescendant(scene, (node) => {
+        // A drawable node carries geometry (structural, like prepareScene3DRender's mesh test).
+        const mesh = node;
+        if (mesh.geometry == null)
+            return;
+        // The caster is already at its CURRENT pose when this pass runs: the app drives prepareScene3DMorph +
+        // prepareScene3DSkinning before prepareScene3DRender, so morph is blended into geometry.vertices and the
+        // skin palette is current before either depth or forward draw. This pass just reads that pose, so an
+        // animated caster casts its animated silhouette without the depth pass re-deforming (and lagging or
+        // double-driving the forward pass). GPU skinning still deforms in the vertex shader from the bone
+        // palette, so a skinned caster needs the HAS_SKIN depth variant + the palette bound.
+        const skinned = mesh.skin != null && hasMeshGeometrySkin(mesh.geometry);
+        const program = skinned
+            ? (skinnedProgram ??= ensureGlScene3DProgram(state, 'shadow:depth:skin', compileShadowDepthSkinnedProgram))
+            : rigidProgram;
+        if (program !== boundProgram) {
+            gl.useProgram(program.program);
+            gl.uniformMatrix4fv(program.locViewProjection, false, matrix.m);
+            boundProgram = program;
+        }
+        gl.uniformMatrix4fv(program.locModel, false, getNodeWorldMatrix4(mesh).m);
+        if (skinned) {
+            // Upload the mesh's bone palette into the shared RGBA32F skin texture and bind it, exactly as
+            // drawGlMeshSubset does for the forward pass, so the depth deformation matches the shaded one.
+            const jointMatrices = mesh.skin.skeleton.jointMatrices;
+            gl.activeTexture(gl.TEXTURE0 + SKIN_PALETTE_TEXTURE_UNIT);
+            uploadGlSkinPaletteTexture(gl, ensureGlSkinPalette(state), jointMatrices, (jointMatrices.length / 16) | 0);
+            gl.uniform1i(program.locJointTexture ?? null, SKIN_PALETTE_TEXTURE_UNIT);
+        }
+        // gpuSkinned = skinned: a skinned draw uploads the static bind pose (the shader deforms it via the
+        // palette) and wires the joints0/weights0 attributes; a rigid draw uploads geometry.vertices as-is.
+        const upload = ensureGlMeshUpload(state, mesh.geometry, skinned);
+        gl.bindVertexArray(upload.vao);
+        if (upload.indexBuffer !== null) {
+            gl.drawElements(upload.primitiveMode, upload.indexCount, upload.indexType, 0);
+        }
+        else {
+            gl.drawArrays(upload.primitiveMode, 0, upload.indexCount);
+        }
+    });
+    // Restore the active texture unit the forward pass assumes (0); a skinned caster left it on the palette unit.
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, prevFramebuffer);
+    gl.viewport(prevViewport[0], prevViewport[1], prevViewport[2], prevViewport[3]);
+    // Restore the default cull state the forward scene pass renders under (culling off, back-face mode).
+    gl.disable(gl.CULL_FACE);
+    gl.cullFace(gl.BACK);
+    runtime.shadow = { matrix, texture: target.depthTexture };
+}
+function compileShadowDepthProgram(gl) {
+    const program = compileGlProgram(gl, SHADOW_DEPTH_VERTEX, SHADOW_DEPTH_FRAGMENT);
+    return {
+        locModel: gl.getUniformLocation(program, 'u_model'),
+        locNormalMatrix: null,
+        locViewProjection: gl.getUniformLocation(program, 'u_viewProjection'),
+        program,
+    };
+}
+// The HAS_SKIN depth variant: the same depth pass, but the vertex is deformed by the bone palette via
+// skinMatrix() before the model/view-projection transform — the exact deformation the forward HAS_SKIN
+// vertex shader applies, so a skinned caster's recorded depth matches its shaded silhouette.
+function compileShadowDepthSkinnedProgram(gl) {
+    const program = compileGlProgram(gl, SHADOW_DEPTH_SKINNED_VERTEX, SHADOW_DEPTH_FRAGMENT);
+    return {
+        locJointTexture: gl.getUniformLocation(program, 'u_jointTexture'),
+        locModel: gl.getUniformLocation(program, 'u_model'),
+        locNormalMatrix: null,
+        locViewProjection: gl.getUniformLocation(program, 'u_viewProjection'),
+        program,
+    };
+}
+const SHADOW_MAP_SIZE = 1024;
+const SHADOW_DEPTH_VERTEX = `#version 300 es
+layout(location = 0) in vec3 a_position;
+uniform mat4 u_viewProjection;
+uniform mat4 u_model;
+void main() {
+  gl_Position = u_viewProjection * u_model * vec4(a_position, 1.0);
+}
+`;
+// The skin declarations (joints0/weights0 attributes, the palette texture, and skinMatrix()) are spliced
+// ahead of the body exactly as the family vertex shaders splice them; model * skinMatrix() matches the
+// forward path's `worldPosition = u_model * (skin * position)`.
+const SHADOW_DEPTH_SKINNED_VERTEX = `#version 300 es
+${GL_SKIN_VERTEX_DECLARATIONS_GLSL}
+layout(location = 0) in vec3 a_position;
+uniform mat4 u_viewProjection;
+uniform mat4 u_model;
+void main() {
+  gl_Position = u_viewProjection * u_model * skinMatrix() * vec4(a_position, 1.0);
+}
+`;
+const SHADOW_DEPTH_FRAGMENT = `#version 300 es
+precision highp float;
+out vec4 fragColor;
+void main() {
+  fragColor = vec4(1.0);
+}
+`;
+//# sourceMappingURL=glShadowMap.js.map

package/dist/glShadowMap.js.map

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

package/dist/glToonPrelude.d.ts

@@ -0,0 +1,7 @@
+import type { GlToonDefineKey, GlToonProgram, GlRenderState } from '@flighthq/types';
+export declare function buildGlToonDefineKey(key: Readonly<GlToonDefineKey>): string;
+export declare function compileGlToonProgram(gl: WebGL2RenderingContext, key: Readonly<GlToonDefineKey>): GlToonProgram;
+export declare function ensureGlToonProgram(state: GlRenderState, key: Readonly<GlToonDefineKey>): GlToonProgram;
+export declare function getGlToonFragmentSourceForKey(key: Readonly<GlToonDefineKey>): string;
+export declare function getGlToonVertexSourceForKey(key: Readonly<GlToonDefineKey>): string;
+//# sourceMappingURL=glToonPrelude.d.ts.map

package/dist/glToonPrelude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glToonPrelude.d.ts","sourceRoot":"","sources":["../src/glToonPrelude.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAarF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,MAAM,CAI3E;AAOD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,sBAAsB,EAAE,GAAG,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,aAAa,CAe9G;AAKD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,aAAa,CAUvG;AAGD,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,MAAM,CAEpF;AAGD,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,MAAM,CAGlF"}