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

package/dist/glClassicPrelude.js

@@ -0,0 +1,288 @@
+import { MAX_FORWARD_LIGHTS } 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';
+// A short, stable, order-independent string identity for a classic define key, used as the program-
+// cache key. The lighting model is encoded first (l/p/b) so the three models never collide, followed
+// by the feature flags. Two keys with the same model + flags produce the same string and so share a
+// compiled program.
+export function buildGlClassicDefineKey(key) {
+    const model = key.lightingModel === 'phong' ? 'p' : key.lightingModel === 'blinnphong' ? 'b' : 'l';
+    return `${model}${key.alphaMaskEnabled ? 'm' : '-'}${key.hasDiffuseMap ? 'd' : '-'}${key.hasSpecularMap ? 's' : '-'}${key.hasNormalMap ? 'n' : '-'}${key.hasAlphaMap ? 'a' : '-'}${key.hasUvTransform ? 'u' : '-'}${key.hasSkin ? 'k' : '-'}`;
+}
+// Compiles the classic uber-shader for a define key, links it, and resolves its uniform locations.
+// Pure GL work — no caching — used by ensureGlClassicProgram. Throws on a compile/link failure, which
+// is a programmer error (a malformed prelude), not an expected runtime condition.
+export function compileGlClassicProgram(gl, key) {
+    const vertexSource = getGlClassicVertexSourceForKey(key);
+    const fragmentSource = getGlClassicFragmentSourceForKey(key);
+    const program = compileGlProgram(gl, vertexSource, fragmentSource);
+    return {
+        ...resolveGlLitLocations(gl, program),
+        program,
+        locAlphaCutoff: gl.getUniformLocation(program, 'u_alphaCutoff'),
+        locAlphaMap: gl.getUniformLocation(program, 'u_alphaMap'),
+        locJointTexture: gl.getUniformLocation(program, 'u_jointTexture'),
+        locDiffuse: gl.getUniformLocation(program, 'u_diffuse'),
+        locDiffuseMap: gl.getUniformLocation(program, 'u_diffuseMap'),
+        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'),
+        locViewProjection: gl.getUniformLocation(program, 'u_viewProjection'),
+    };
+}
+// Resolves the classic program for a define key, compiling and caching it on first use through the
+// shared scene program cache under the `classic:` family namespace, so each model + feature variant
+// is compiled at most once per state and reused every frame.
+export function ensureGlClassicProgram(state, key) {
+    // 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,
+    };
+    return ensureGlScene3DProgram(state, `classic:${buildGlClassicDefineKey(fullKey)}`, (gl) => compileGlClassicProgram(gl, fullKey));
+}
+// The fragment shader body (everything after the "#version 300 es" + defines block). Implements the
+// classic Lambert diffuse term plus an optional Phong / BlinnPhong specular lobe over one directional
+// + one ambient light, and writes linear HDR radiance to fragColor.
+export function getGlClassicFragmentSource() {
+    return CLASSIC_FRAGMENT_BODY;
+}
+// The full fragment source for a define key (define block + body), ready to hand to the GL compiler.
+export function getGlClassicFragmentSourceForKey(key) {
+    return buildGlClassicDefineSource(key) + CLASSIC_FRAGMENT_BODY;
+}
+// The vertex shader body (everything after the "#version 300 es" + defines block). Transforms the
+// canonical mesh vertex (position/normal/tangent/uv0) by the model and view-projection matrices and
+// passes world-space position, normal, tangent, and uv to the fragment scene2d — the same vertex shape
+// as the PBR family.
+export function getGlClassicVertexSource() {
+    return CLASSIC_VERTEX_BODY;
+}
+// The full vertex source for a define key (define block + optional skin declarations + body), ready to
+// hand to the GL compiler. The skin GLSL is vertex-only (its `in` attributes are illegal in a fragment
+// shader), so it is spliced here rather than into the shared define block.
+export function getGlClassicVertexSourceForKey(key) {
+    const skin = key.hasSkin ? GL_SKIN_VERTEX_DECLARATIONS_GLSL : '';
+    return buildGlClassicDefineSource(key) + skin + CLASSIC_VERTEX_BODY;
+}
+// Builds the leading "#version 300 es\n#define ..." block for a classic define key, to be prepended
+// to the vertex and fragment prelude bodies before compile. Pure string assembly; the same key always
+// yields the same source, which is what makes the program cache by define key sound.
+function buildGlClassicDefineSource(key) {
+    let defines = `#version 300 es\n#define MAX_FORWARD_LIGHTS ${MAX_FORWARD_LIGHTS}\n`;
+    if (key.lightingModel === 'phong')
+        defines += '#define LIGHTING_PHONG\n';
+    if (key.lightingModel === 'blinnphong')
+        defines += '#define LIGHTING_BLINNPHONG\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.hasAlphaMap)
+        defines += '#define HAS_ALPHA_MAP\n';
+    if (key.hasUvTransform)
+        defines += '#define HAS_UV_TRANSFORM\n';
+    if (key.hasSkin)
+        defines += '#define HAS_SKIN\n';
+    return defines;
+}
+const CLASSIC_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;
+${GL_UV_TRANSFORM_VERTEX_GLSL}
+out vec3 v_worldPosition;
+out vec3 v_normal;
+out vec4 v_tangent;
+out vec2 v_uv0;
+
+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
+  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;
+}
+`;
+// LIGHTING_PHONG / LIGHTING_BLINNPHONG select the specular geometry; neither define = Lambert (no
+// specular branch). u_specular / u_shininess / u_normalMap / u_normalScale exist only when a specular
+// model is compiled in, so they are guarded by the same #ifdef as their use.
+const CLASSIC_FRAGMENT_BODY = `
+precision highp float;
+
+in vec3 v_worldPosition;
+in vec3 v_normal;
+in vec4 v_tangent;
+in vec2 v_uv0;
+
+uniform vec4 u_diffuse;
+uniform float u_alphaCutoff;
+${GL_MESH_LIGHT_BLOCK_GLSL}
+#if defined(LIGHTING_PHONG) || defined(LIGHTING_BLINNPHONG)
+uniform vec4 u_specular;
+uniform float u_shininess;
+uniform float u_normalScale;
+#endif
+
+#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
+#ifdef HAS_ALPHA_MAP
+uniform sampler2D u_alphaMap;
+#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));
+}
+
+// The classic shading for ONE light: Lambert diffuse plus the optional Phong/BlinnPhong specular
+// lobe. Every light type (directional, point, spot) routes through this one BRDF so they never fork
+// the shading model — the caller supplies the surface->light direction and the light's (attenuated,
+// cone-scaled) radiance. Specular reads the view vector and material specular/shininess from globals.
+vec3 shadeClassicLight(vec3 normal, vec3 lightDir, vec3 lightColor, vec3 diffuseRgb) {
+  float nDotL = max(dot(normal, lightDir), 0.0);
+  vec3 result = diffuseRgb * nDotL * lightColor;
+#if defined(LIGHTING_PHONG) || defined(LIGHTING_BLINNPHONG)
+  if (nDotL > 0.0) {
+    vec3 viewDir = normalize(u_cameraPosition - v_worldPosition);
+    vec3 specularColor = u_specular.rgb;
+  #ifdef HAS_SPECULAR_MAP
+    specularColor *= srgbToLinear(texture(u_specularMap, v_uv0).rgb);
+  #endif
+  #ifdef LIGHTING_PHONG
+    // Phong: reflection-vector specular.
+    vec3 reflectDir = reflect(-lightDir, normal);
+    float specAngle = max(dot(reflectDir, viewDir), 0.0);
+  #else
+    // BlinnPhong: half-vector specular.
+    vec3 halfVec = normalize(lightDir + viewDir);
+    float specAngle = max(dot(normal, halfVec), 0.0);
+  #endif
+    float specular = pow(specAngle, max(u_shininess, 1.0));
+    result += specular * specularColor * lightColor;
+  }
+#endif
+  return result;
+}
+
+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
+
+  // Dedicated coverage (opacity) map: its green channel is linear data, multiplied into alpha before
+  // the alpha-mask cutoff so 'mask' cutout and 'blend' transparency both see the combined coverage.
+#ifdef HAS_ALPHA_MAP
+  diffuse.a *= texture(u_alphaMap, v_uv0).g;
+#endif
+
+#ifdef ALPHA_MASK
+  if (diffuse.a < u_alphaCutoff) discard;
+#endif
+
+  vec3 geometricNormal = normalize(v_normal);
+  if (!gl_FrontFacing) geometricNormal = -geometricNormal;
+
+  vec3 normal = geometricNormal;
+#ifdef HAS_NORMAL_MAP
+  vec3 tangent = normalize(v_tangent.xyz);
+  vec3 bitangent = cross(geometricNormal, tangent) * v_tangent.w;
+  vec3 tangentNormal = texture(u_normalMap, v_uv0).xyz * 2.0 - 1.0;
+  tangentNormal.xy *= u_normalScale;
+  mat3 tbn = mat3(tangent, bitangent, geometricNormal);
+  normal = normalize(tbn * tangentNormal);
+#endif
+
+  vec3 radiance = vec3(0.0);
+
+  // Directional light: -direction is the surface-to-light vector (light travels along direction).
+  // Only the directional term is shadow-mapped (mirrors the PBR path); point/spot/ambient stay unshadowed.
+  // sampleDirectionalShadow returns 1.0 when no shadow map is bound (u_shadowEnabled == 0), so a classic
+  // scene that never calls drawGlScene3DShadowMap is unchanged.
+  if (u_directionalCount > 0.5) {
+    vec3 lightDir = normalize(-u_directional.xyz);
+    radiance += shadeClassicLight(normal, lightDir, u_directionalRadiance.rgb, diffuse.rgb)
+                * sampleDirectionalShadow(v_worldPosition);
+  }
+
+  // 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 += shadeClassicLight(normal, lightDir, u_pointLights[i * 2 + 1].rgb * atten, diffuse.rgb);
+  }
+
+  // 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 += shadeClassicLight(normal, lightDir, u_spotLights[i * 4 + 1].rgb * atten * cone, diffuse.rgb);
+  }
+
+  // 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;
+  }
+
+  fragColor = vec4(radiance, diffuse.a);
+  fragColor.a *= u_objectAlpha;
+}
+`;
+//# sourceMappingURL=glClassicPrelude.js.map

package/dist/glClassicPrelude.js.map

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

package/dist/glDebugPrelude.d.ts

@@ -0,0 +1,9 @@
+import type { GlDebugProgram, GlDebugDefineKey, GlRenderState, Texture } from '@flighthq/types';
+export declare function bindGlDebugNormalMap(state: GlRenderState, program: Readonly<GlDebugProgram>, normalMap: Readonly<Texture> | null, normalScale: number): void;
+export declare function bindGlDebugRange(state: GlRenderState, program: Readonly<GlDebugProgram>, near: number, far: number): void;
+export declare function buildGlDebugDefineKey(key: Readonly<GlDebugDefineKey>): string;
+export declare function compileGlDebugProgram(gl: WebGL2RenderingContext, key: Readonly<GlDebugDefineKey>): GlDebugProgram;
+export declare function ensureGlDebugProgram(state: GlRenderState, key: Readonly<GlDebugDefineKey>): GlDebugProgram;
+export declare function getGlDebugFragmentSourceForKey(key: Readonly<GlDebugDefineKey>): string;
+export declare function getGlDebugVertexSourceForKey(key: Readonly<GlDebugDefineKey>): string;
+//# sourceMappingURL=glDebugPrelude.d.ts.map

package/dist/glDebugPrelude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glDebugPrelude.d.ts","sourceRoot":"","sources":["../src/glDebugPrelude.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAMhG,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,EACjC,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EACnC,WAAW,EAAE,MAAM,GAClB,IAAI,CASN;AAKD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,EACjC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GACV,IAAI,CAIN;AAID,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAE7E;AAID,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,sBAAsB,EAAE,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,cAAc,CAYjH;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,cAAc,CAE1G;AAGD,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAEtF;AAGD,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAEpF"}

package/dist/glDebugPrelude.js

@@ -0,0 +1,143 @@
+import { hasImageResourcePixels } from '@flighthq/image';
+import { bindGlImageResourceTexture } from '@flighthq/render-gl';
+import { compileGlProgram, ensureGlScene3DProgram } from './glMeshProgram';
+// Binds the optional tangent-space normal map (on texture unit 0) and its scale for the normal-mode
+// debug material. The caller has already selected the program (beginGlMeshDraw) and set the
+// view-projection. A no-op when no map is bound; depth mode never calls this.
+export function bindGlDebugNormalMap(state, program, normalMap, normalScale) {
+    const gl = state.gl;
+    gl.uniform1f(program.locNormalScale, normalScale);
+    if (normalMap !== null && normalMap.image !== null && hasImageResourcePixels(normalMap.image)) {
+        gl.activeTexture(gl.TEXTURE0);
+        bindGlImageResourceTexture(state, normalMap.image, normalMap.sampler);
+        gl.uniform1i(program.locNormalMap, 0);
+    }
+}
+// Uploads the depth-mode linearization range (the [near, far] eye-space window mapped to [0, 1]).
+// The caller has already selected the program and set the view-projection. Normal mode never calls
+// this.
+export function bindGlDebugRange(state, program, near, far) {
+    const gl = state.gl;
+    gl.uniform1f(program.locNear, near);
+    gl.uniform1f(program.locFar, far);
+}
+// A short, stable, order-independent string identity for a debug define key, used as the program-
+// cache key. Two keys with the same flags produce the same string and so share a compiled program.
+export function buildGlDebugDefineKey(key) {
+    return `${key.mode === 'depth' ? 'd' : 'n'}${key.hasNormalMap ? 'm' : '-'}`;
+}
+// Compiles the debug shader for a define key, links it, and resolves its uniform locations. Pure GL
+// work — no caching — used by ensureGlDebugProgram.
+export function compileGlDebugProgram(gl, key) {
+    const program = compileGlProgram(gl, getGlDebugVertexSourceForKey(key), getGlDebugFragmentSourceForKey(key));
+    return {
+        locFar: gl.getUniformLocation(program, 'u_far'),
+        locModel: gl.getUniformLocation(program, 'u_model'),
+        locNear: gl.getUniformLocation(program, 'u_near'),
+        locNormalMap: gl.getUniformLocation(program, 'u_normalMap'),
+        locNormalMatrix: gl.getUniformLocation(program, 'u_normalMatrix'),
+        locNormalScale: gl.getUniformLocation(program, 'u_normalScale'),
+        locViewProjection: gl.getUniformLocation(program, 'u_viewProjection'),
+        program,
+    };
+}
+// Resolves the debug program for a define key, compiling and caching it on first use through the
+// shared scene program cache under the `debug:` family namespace.
+export function ensureGlDebugProgram(state, key) {
+    return ensureGlScene3DProgram(state, `debug:${buildGlDebugDefineKey(key)}`, (gl) => compileGlDebugProgram(gl, key));
+}
+// The full fragment source for a define key (define block + body), ready to hand to the GL compiler.
+export function getGlDebugFragmentSourceForKey(key) {
+    return buildDefineSource(key) + DEBUG_FRAGMENT_BODY;
+}
+// The full vertex source for a define key (define block + body), ready to hand to the GL compiler.
+export function getGlDebugVertexSourceForKey(key) {
+    return buildDefineSource(key) + DEBUG_VERTEX_BODY;
+}
+function buildDefineSource(key) {
+    let defines = '#version 300 es\n';
+    if (key.mode === 'depth')
+        defines += '#define DEPTH_MODE\n';
+    else
+        defines += '#define NORMAL_MODE\n';
+    if (key.hasNormalMap)
+        defines += '#define HAS_NORMAL_MAP\n';
+    return defines;
+}
+const DEBUG_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;
+
+out vec3 v_worldPosition;
+out vec3 v_normal;
+out vec4 v_tangent;
+out vec2 v_uv0;
+
+void main() {
+  vec4 worldPosition = u_model * vec4(a_position, 1.0);
+  v_worldPosition = worldPosition.xyz;
+  v_normal = u_normalMatrix * a_normal;
+  v_tangent = vec4(u_normalMatrix * a_tangent.xyz, a_tangent.w);
+  v_uv0 = a_uv0;
+  gl_Position = u_viewProjection * worldPosition;
+}
+`;
+const DEBUG_FRAGMENT_BODY = `
+precision highp float;
+
+in vec3 v_worldPosition;
+in vec3 v_normal;
+in vec4 v_tangent;
+in vec2 v_uv0;
+
+#ifdef DEPTH_MODE
+uniform float u_near;
+uniform float u_far;
+#endif
+#ifdef NORMAL_MODE
+uniform float u_normalScale;
+#ifdef HAS_NORMAL_MAP
+uniform sampler2D u_normalMap;
+#endif
+#endif
+
+uniform float u_objectAlpha;
+
+out vec4 fragColor;
+
+void main() {
+#ifdef DEPTH_MODE
+  // Linear view-space distance is the perspective w: 1.0 / gl_FragCoord.w == w_clip == eye distance.
+  // This is camera-agnostic (no camera near/far needed); map it across the material's [u_near, u_far]
+  // visualization window to grayscale [0, 1].
+  float eyeDepth = 1.0 / gl_FragCoord.w;
+  float d = clamp((eyeDepth - u_near) / max(u_far - u_near, 1e-6), 0.0, 1.0);
+  fragColor = vec4(vec3(d), 1.0);
+#endif
+#ifdef NORMAL_MODE
+  // Visualize the WORLD-space surface normal (the geometric normal carried through u_normalMatrix).
+  vec3 geometricNormal = normalize(v_normal);
+  if (!gl_FrontFacing) geometricNormal = -geometricNormal;
+
+  vec3 normal = geometricNormal;
+#ifdef HAS_NORMAL_MAP
+  vec3 tangent = normalize(v_tangent.xyz);
+  vec3 bitangent = cross(geometricNormal, tangent) * v_tangent.w;
+  vec3 tangentNormal = texture(u_normalMap, v_uv0).xyz * 2.0 - 1.0;
+  tangentNormal.xy *= u_normalScale;
+  mat3 tbn = mat3(tangent, bitangent, geometricNormal);
+  normal = normalize(tbn * tangentNormal);
+#endif
+
+  fragColor = vec4(normal * 0.5 + 0.5, 1.0);
+#endif
+  fragColor.a *= u_objectAlpha;
+}
+`;
+//# sourceMappingURL=glDebugPrelude.js.map

package/dist/glDebugPrelude.js.map

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

package/dist/glEnvironmentCube.d.ts

@@ -0,0 +1,5 @@
+import type { Environment, GlRenderState, ImageResource } from '@flighthq/types';
+export declare function ensureGlEnvironmentSourceCube(state: GlRenderState, environment: Readonly<Environment>): WebGLTexture | null;
+export declare function getGlCubeFaceTarget(gl: WebGL2RenderingContext, face: number): number;
+export declare function updateGlEnvironmentCubeFace(state: GlRenderState, face: number, image: Readonly<ImageResource>): boolean;
+//# sourceMappingURL=glEnvironmentCube.d.ts.map

package/dist/glEnvironmentCube.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEnvironmentCube.d.ts","sourceRoot":"","sources":["../src/glEnvironmentCube.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAa9F,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,GACjC,YAAY,GAAG,IAAI,CAsBrB;AAID,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,sBAAsB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpF;AAQD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,GAC7B,OAAO,CAQT"}

package/dist/glEnvironmentCube.js

@@ -0,0 +1,65 @@
+import { uploadGlTextureImageResource } from '@flighthq/render-gl';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+// Uploads an Environment's source radiance cubemap (six ImageResource faces) to a GL cubemap texture,
+// caching it on the scene runtime. Returns null when the environment has no complete cube — all six
+// faces bound with pixels, either a decoded `source` element or raw `data` — which callers treat as
+// "no environment this frame". Each face uploads through whichever representation it carries: the
+// element overload for a `source`, or the raw-pixel overload for a data-only face (a generated
+// Surface, e.g. the skybox's rotateSurface180 path, which never allocates a canvas). The upload is
+// keyed by identity: re-uploaded only when the cached texture is absent (a changed cube must drop the
+// cache first via destroyGlEnvironment). sRGB faces are decoded to linear by the shaders that sample
+// them, matching the renderer's sRGB-passthrough convention.
+export function ensureGlEnvironmentSourceCube(state, environment) {
+    const runtime = getGlScene3DRuntime(state);
+    if (runtime.environmentSourceCube !== null)
+        return runtime.environmentSourceCube;
+    const cube = environment.environment;
+    if (cube === null || !hasGlCubeFacePixels(cube))
+        return null;
+    const gl = state.gl;
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_CUBE_MAP, texture);
+    for (let face = 0; face < 6; face++) {
+        uploadGlTextureImageResource(gl, getGlCubeFaceTarget(gl, face), cube.faces[face]);
+    }
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE);
+    gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
+    runtime.environmentSourceCube = texture;
+    return texture;
+}
+// The cubemap face target in CubeTexture.faces order (+X, -X, +Y, -Y, +Z, -Z), which is exactly
+// gl.TEXTURE_CUBE_MAP_POSITIVE_X + face. Face loops call this rather than hardcoding the GL enum math.
+export function getGlCubeFaceTarget(gl, face) {
+    return gl.TEXTURE_CUBE_MAP_POSITIVE_X + face;
+}
+// Restamps a single face of the already-built source cube in place, uploading whichever representation the
+// image carries (element or generated `data`). This is the incremental counterpart of the all-six
+// ensureGlEnvironmentSourceCube — for dynamic cube content (reflection probes, a live sky face, or a
+// generated data face mixed into loaded ones) without dropping and rebuilding the whole cube. `face` is the
+// CubeFace* index (+X, -X, +Y, -Y, +Z, -Z). Returns false when no cube has been built yet — the caller
+// must call ensureGlEnvironmentSourceCube first.
+export function updateGlEnvironmentCubeFace(state, face, image) {
+    const texture = getGlScene3DRuntime(state).environmentSourceCube;
+    if (texture === null)
+        return false;
+    const gl = state.gl;
+    gl.bindTexture(gl.TEXTURE_CUBE_MAP, texture);
+    uploadGlTextureImageResource(gl, getGlCubeFaceTarget(gl, face), image);
+    gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
+    return true;
+}
+// A face is uploadable when it carries pixels in either representation: a decoded `source` element or
+// raw CPU `data` (a generated Surface). A cube is complete only when all six faces are uploadable.
+function hasGlCubeFacePixels(cube) {
+    for (let face = 0; face < 6; face++) {
+        const image = cube.faces[face];
+        if (image == null || (image.source == null && image.data == null))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=glEnvironmentCube.js.map

package/dist/glEnvironmentCube.js.map

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

package/dist/glEnvironmentIblBake.d.ts

@@ -0,0 +1,4 @@
+import type { Environment, GlRenderState } from '@flighthq/types';
+export declare function bakeGlEnvironmentIbl(state: GlRenderState, environment: Readonly<Environment>): void;
+export declare function destroyGlEnvironmentIblBakePrograms(state: GlRenderState): void;
+//# sourceMappingURL=glEnvironmentIblBake.d.ts.map

package/dist/glEnvironmentIblBake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glEnvironmentIblBake.d.ts","sourceRoot":"","sources":["../src/glEnvironmentIblBake.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAelE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,CAiCnG;AAOD,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAU9E"}