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

package/dist/glLitProgram.js

@@ -0,0 +1,211 @@
+import { MAX_FORWARD_LIGHTS, SCENE_LIGHT_HEMISPHERE_OFFSET, SCENE_LIGHT_HEMISPHERE_STRIDE, SCENE_LIGHT_POINT_OFFSET, SCENE_LIGHT_POINT_STRIDE, SCENE_LIGHT_SPOT_OFFSET, SCENE_LIGHT_SPOT_STRIDE, } from '@flighthq/types';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+// The texture unit the directional shadow map binds to — above the material texture units (a material
+// uses at most baseColor/normal/metallicRoughness/occlusion/emissive ⇒ units 0–4). The IBL set sits
+// above the shadow map: irradiance/prefiltered cubemaps + the BRDF LUT on units 9/10/11.
+const SHADOW_MAP_TEXTURE_UNIT = 8;
+const IBL_IRRADIANCE_TEXTURE_UNIT = 9;
+const IBL_PREFILTERED_TEXTURE_UNIT = 10;
+const IBL_BRDF_TEXTURE_UNIT = 11;
+const _iblPlaceholders = new WeakMap();
+// The Scene3DLightBlock.version last uploaded into each program's light uniforms. Keyed by program
+// because default uniforms are per-program state; freed with the program when it is GC'd.
+const _uploadedLightVersion = new WeakMap();
+const _uploadedLightBlock = new WeakMap();
+// Uploads the packed light block to a lit program's standard light uniforms, then binds the active
+// directional shadow (set by drawGlScene3DShadowMap on the scene runtime) or disables shadowing. The
+// block layout (std140) mirrors Scene3DLightBlock.data exactly: directional { direction.xyz @0, _pad,
+// radiance.rgb @4, _pad } then ambient { radiance.rgb @8, _pad }. Radiance is already linear and
+// premultiplied at pack time. The count uniforms (0 or 1) gate each term. Every lit family calls this
+// from bind() — it is the one place light + shadow data reach GL.
+export function bindGlMeshLightBlock(state, program, lights) {
+    const gl = state.gl;
+    // The light uniforms are default (non-block) uniforms, which persist on the program object across
+    // useProgram switches and frames, so re-uploading an unchanged block is wasted work. packScene3DLightBlock
+    // only advances `version` on an actual change, so skip the upload when this program already holds the
+    // current version. Tracked per program (not per state) because each program keeps its own uniform
+    // values — a version cached on one program says nothing about another. Shadow and IBL binds below are
+    // NOT gated: they carry per-frame texture binds that must run every draw regardless of the light block.
+    if (_uploadedLightBlock.get(program) !== lights || _uploadedLightVersion.get(program) !== lights.version) {
+        const data = lights.data;
+        gl.uniform4f(program.locDirectional, data[0], data[1], data[2], 0);
+        gl.uniform4f(program.locDirectionalRadiance, data[4], data[5], data[6], 0);
+        gl.uniform3f(program.locAmbientRadiance, data[8], data[9], data[10]);
+        gl.uniform1f(program.locDirectionalCount, lights.directionalCount);
+        gl.uniform1f(program.locAmbientCount, lights.ambientCount);
+        // Punctual light arrays: upload the whole MAX_FORWARD_LIGHTS-wide slice as flat vec4 arrays (the
+        // shader loops each up to its count uniform). Subarray views over `data` — no copy — sliced at the
+        // same std140 offsets the CPU packer wrote. Classic/PBR programs both declare these; a program that
+        // resolves a location to null (none does today) simply no-ops the upload.
+        gl.uniform4fv(program.locPointLights, data.subarray(SCENE_LIGHT_POINT_OFFSET, SCENE_LIGHT_POINT_OFFSET + SCENE_LIGHT_POINT_STRIDE * MAX_FORWARD_LIGHTS));
+        gl.uniform4fv(program.locSpotLights, data.subarray(SCENE_LIGHT_SPOT_OFFSET, SCENE_LIGHT_SPOT_OFFSET + SCENE_LIGHT_SPOT_STRIDE * MAX_FORWARD_LIGHTS));
+        gl.uniform4fv(program.locHemisphereLights, data.subarray(SCENE_LIGHT_HEMISPHERE_OFFSET, SCENE_LIGHT_HEMISPHERE_OFFSET + SCENE_LIGHT_HEMISPHERE_STRIDE * MAX_FORWARD_LIGHTS));
+        gl.uniform1i(program.locPointCount, lights.pointCount);
+        gl.uniform1i(program.locSpotCount, lights.spotCount);
+        gl.uniform1i(program.locHemisphereCount, lights.hemisphereCount);
+        _uploadedLightBlock.set(program, lights);
+        _uploadedLightVersion.set(program, lights.version);
+    }
+    const runtime = getGlScene3DRuntime(state);
+    const shadow = runtime.shadow;
+    if (shadow !== null) {
+        gl.activeTexture(gl.TEXTURE0 + SHADOW_MAP_TEXTURE_UNIT);
+        gl.bindTexture(gl.TEXTURE_2D, shadow.texture);
+        gl.uniform1i(program.locShadowMap, SHADOW_MAP_TEXTURE_UNIT);
+        gl.uniformMatrix4fv(program.locShadowMatrix, false, shadow.matrix.m);
+        gl.uniform1f(program.locShadowEnabled, 1);
+    }
+    else {
+        gl.uniform1f(program.locShadowEnabled, 0);
+    }
+    // Image-based lighting (PBR families only; classic/toon programs resolve these locations to null so
+    // the binds are harmless no-ops). Bound here so every PBR draw samples the same baked environment.
+    const ibl = runtime.ibl;
+    if (ibl !== null) {
+        gl.activeTexture(gl.TEXTURE0 + IBL_IRRADIANCE_TEXTURE_UNIT);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, ibl.irradianceCube);
+        gl.uniform1i(program.locIblIrradiance, IBL_IRRADIANCE_TEXTURE_UNIT);
+        gl.activeTexture(gl.TEXTURE0 + IBL_PREFILTERED_TEXTURE_UNIT);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, ibl.prefilteredCube);
+        gl.uniform1i(program.locIblPrefiltered, IBL_PREFILTERED_TEXTURE_UNIT);
+        gl.activeTexture(gl.TEXTURE0 + IBL_BRDF_TEXTURE_UNIT);
+        gl.bindTexture(gl.TEXTURE_2D, ibl.brdfLut);
+        gl.uniform1i(program.locIblBrdf, IBL_BRDF_TEXTURE_UNIT);
+        gl.uniform1f(program.locIblEnabled, 1);
+        gl.uniform1f(program.locIblIntensity, ibl.intensity);
+        gl.uniform1f(program.locIblMaxMip, ibl.prefilteredMipCount - 1);
+        gl.activeTexture(gl.TEXTURE0);
+    }
+    else {
+        // Even with IBL disabled, the PBR shader still *declares* the cube/2D IBL samplers, and a draw is
+        // invalid if a samplerCube and a sampler2D resolve to the same (default) texture unit 0. Bind
+        // correctly-typed 1x1 placeholders on the dedicated IBL units so the sampler types never collide
+        // with the material's unit-0 sampler — the dynamic u_iblEnabled gate keeps them unsampled.
+        const placeholders = ensureGlIblPlaceholders(state);
+        gl.activeTexture(gl.TEXTURE0 + IBL_IRRADIANCE_TEXTURE_UNIT);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, placeholders.cube);
+        gl.uniform1i(program.locIblIrradiance, IBL_IRRADIANCE_TEXTURE_UNIT);
+        gl.activeTexture(gl.TEXTURE0 + IBL_PREFILTERED_TEXTURE_UNIT);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, placeholders.cube);
+        gl.uniform1i(program.locIblPrefiltered, IBL_PREFILTERED_TEXTURE_UNIT);
+        gl.activeTexture(gl.TEXTURE0 + IBL_BRDF_TEXTURE_UNIT);
+        gl.bindTexture(gl.TEXTURE_2D, placeholders.lut);
+        gl.uniform1i(program.locIblBrdf, IBL_BRDF_TEXTURE_UNIT);
+        gl.uniform1f(program.locIblEnabled, 0);
+        gl.activeTexture(gl.TEXTURE0);
+    }
+}
+// Lazily creates (and caches per state) the 1x1 placeholder cube + 2D textures bound to the IBL units
+// when no environment is baked. They exist only to give the PBR shader's IBL samplers a complete,
+// correctly-typed binding so a draw is valid; they are never sampled (the u_iblEnabled gate is 0).
+function ensureGlIblPlaceholders(state) {
+    let placeholders = _iblPlaceholders.get(state);
+    if (placeholders !== undefined)
+        return placeholders;
+    const gl = state.gl;
+    // Create on an IBL unit, never the active unit — the caller has the shadow map bound on unit 8, and
+    // binding here on the active unit would clobber it (the "black scene" bug). The else branch rebinds
+    // units 9/10/11 with proper activeTexture calls immediately after, so unit choice here only needs to
+    // avoid the shadow/material units.
+    gl.activeTexture(gl.TEXTURE0 + IBL_IRRADIANCE_TEXTURE_UNIT);
+    const black = new Uint8Array([0, 0, 0, 255]);
+    const cube = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_CUBE_MAP, cube);
+    for (let face = 0; face < 6; face++) {
+        gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, black);
+    }
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    const lut = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, lut);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, black);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    placeholders = { cube, lut };
+    _iblPlaceholders.set(state, placeholders);
+    return placeholders;
+}
+// Resolves the standard lit uniform locations from a linked program, so each lit family's compile
+// spreads these in rather than repeating the getUniformLocation calls. The names match
+// GL_MESH_LIGHT_BLOCK_GLSL — change them together.
+export function resolveGlLitLocations(gl, program) {
+    return {
+        locAmbientCount: gl.getUniformLocation(program, 'u_ambientCount'),
+        locAmbientRadiance: gl.getUniformLocation(program, 'u_ambientRadiance'),
+        locCameraPosition: gl.getUniformLocation(program, 'u_cameraPosition'),
+        locDirectional: gl.getUniformLocation(program, 'u_directional'),
+        locDirectionalCount: gl.getUniformLocation(program, 'u_directionalCount'),
+        locDirectionalRadiance: gl.getUniformLocation(program, 'u_directionalRadiance'),
+        locHemisphereCount: gl.getUniformLocation(program, 'u_hemisphereCount'),
+        locHemisphereLights: gl.getUniformLocation(program, 'u_hemisphereLights'),
+        locIblBrdf: gl.getUniformLocation(program, 'u_iblBrdf'),
+        locIblEnabled: gl.getUniformLocation(program, 'u_iblEnabled'),
+        locIblIntensity: gl.getUniformLocation(program, 'u_iblIntensity'),
+        locIblIrradiance: gl.getUniformLocation(program, 'u_iblIrradiance'),
+        locIblMaxMip: gl.getUniformLocation(program, 'u_iblMaxMip'),
+        locIblPrefiltered: gl.getUniformLocation(program, 'u_iblPrefiltered'),
+        locPointCount: gl.getUniformLocation(program, 'u_pointCount'),
+        locPointLights: gl.getUniformLocation(program, 'u_pointLights'),
+        locShadowEnabled: gl.getUniformLocation(program, 'u_shadowEnabled'),
+        locShadowMap: gl.getUniformLocation(program, 'u_shadowMap'),
+        locShadowMatrix: gl.getUniformLocation(program, 'u_shadowMatrix'),
+        locSpotCount: gl.getUniformLocation(program, 'u_spotCount'),
+        locSpotLights: gl.getUniformLocation(program, 'u_spotLights'),
+    };
+}
+// The GLSL 300 es declaration of the standard forward-light + shadow uniforms and the shared
+// shadow-sampling helper, included once in every lit fragment prelude. Keeping it here keeps the GPU
+// declaration and the CPU upload (bindGlMeshLightBlock) in lockstep. A lit family that wants shadows
+// multiplies its directional contribution by sampleDirectionalShadow(worldPos).
+export const GL_MESH_LIGHT_BLOCK_GLSL = `
+uniform vec4 u_directional;          // xyz = light travel direction (surface->light is -xyz)
+uniform vec4 u_directionalRadiance;  // rgb = linear radiance, premultiplied by intensity
+uniform vec3 u_ambientRadiance;      // linear ambient irradiance
+uniform float u_directionalCount;    // 0 or 1 — gates the directional term
+uniform float u_ambientCount;        // 0 or 1 — gates the ambient term
+uniform vec3 u_cameraPosition;       // world-space camera position for view-dependent terms
+uniform sampler2D u_shadowMap;       // directional shadow depth map
+uniform mat4 u_shadowMatrix;         // world -> shadow light-clip
+uniform float u_shadowEnabled;       // 0 or 1 — gates shadow sampling
+
+// Punctual (point/spot/hemisphere) forward-light arrays. Fixed MAX_FORWARD_LIGHTS-wide; each count
+// uniform bounds its loop. Layout matches Scene3DLightBlock.data (packScene3DLightBlock) byte-for-byte:
+//   point[i]      = u_pointLights[i*2+0]={pos.xyz,range}, [i*2+1]={radiance.rgb,invSqrRange}
+//   spot[i]       = u_spotLights[i*4+0..1] as point, [i*4+2]={dir.xyz,_}, [i*4+3]={cosInner,cosOuter,_,_}
+//   hemisphere[i] = u_hemisphereLights[i*3+0]={sky.rgb,_}, [i*3+1]={ground.rgb,_}, [i*3+2]={up.xyz,_}
+uniform vec4 u_pointLights[MAX_FORWARD_LIGHTS * 2];
+uniform vec4 u_spotLights[MAX_FORWARD_LIGHTS * 4];
+uniform vec4 u_hemisphereLights[MAX_FORWARD_LIGHTS * 3];
+uniform int u_pointCount;
+uniform int u_spotCount;
+uniform int u_hemisphereCount;
+
+// Smooth inverse-square range window (glTF/UE4): 1 near the light, eased to 0 at the range. invSqrRange
+// is 1/range^2 (0 = infinite range, no cutoff). dist2 is the squared surface->light distance.
+float rangeWindow(float dist2, float invSqrRange) {
+  float factor = dist2 * invSqrRange;
+  float windowed = clamp(1.0 - factor * factor, 0.0, 1.0);
+  return windowed * windowed;
+}
+
+// Directional shadow factor at a world position: 1.0 fully lit, 0.0 fully shadowed, with 3x3 PCF.
+// Fragments outside the shadow frustum are treated as lit.
+float sampleDirectionalShadow(vec3 worldPos) {
+  if (u_shadowEnabled < 0.5) return 1.0;
+  vec4 clip = u_shadowMatrix * vec4(worldPos, 1.0);
+  vec3 ndc = clip.xyz / clip.w;
+  vec3 uvz = ndc * 0.5 + 0.5;
+  if (uvz.x < 0.0 || uvz.x > 1.0 || uvz.y < 0.0 || uvz.y > 1.0 || uvz.z > 1.0) return 1.0;
+  float current = uvz.z - 0.0025;
+  vec2 texel = 1.0 / vec2(textureSize(u_shadowMap, 0));
+  float sum = 0.0;
+  for (int x = -1; x <= 1; ++x) {
+    for (int y = -1; y <= 1; ++y) {
+      float closest = texture(u_shadowMap, uvz.xy + vec2(float(x), float(y)) * texel).r;
+      sum += current <= closest ? 1.0 : 0.0;
+    }
+  }
+  return sum / 9.0;
+}
+`;
+//# sourceMappingURL=glLitProgram.js.map

package/dist/glLitProgram.js.map

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

package/dist/glMatcapPrelude.d.ts

@@ -0,0 +1,8 @@
+import type { GlMatcapDefineKey, GlMatcapProgram, LinearColor, GlRenderState, Texture } from '@flighthq/types';
+export declare function bindGlMatcapSurface(state: GlRenderState, program: Readonly<GlMatcapProgram>, tint: Readonly<LinearColor>, matcap: Readonly<Texture> | null, alphaCutoff: number): void;
+export declare function buildGlMatcapDefineKey(key: Readonly<GlMatcapDefineKey>): string;
+export declare function compileGlMatcapProgram(gl: WebGL2RenderingContext, key: Readonly<GlMatcapDefineKey>): GlMatcapProgram;
+export declare function ensureGlMatcapProgram(state: GlRenderState, key: Readonly<GlMatcapDefineKey>): GlMatcapProgram;
+export declare function getGlMatcapFragmentSourceForKey(key: Readonly<GlMatcapDefineKey>): string;
+export declare function getGlMatcapVertexSourceForKey(key: Readonly<GlMatcapDefineKey>): string;
+//# sourceMappingURL=glMatcapPrelude.d.ts.map

package/dist/glMatcapPrelude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glMatcapPrelude.d.ts","sourceRoot":"","sources":["../src/glMatcapPrelude.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAM/G,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC3B,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EAChC,WAAW,EAAE,MAAM,GAClB,IAAI,CAUN;AAID,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAE/E;AAID,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,sBAAsB,EAAE,GAAG,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,eAAe,CAYpH;AAID,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,eAAe,CAI7G;AAGD,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAExF;AAGD,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAEtF"}

package/dist/glMatcapPrelude.js

@@ -0,0 +1,118 @@
+import { hasImageResourcePixels } from '@flighthq/image';
+import { bindGlImageResourceTexture } from '@flighthq/render-gl';
+import { compileGlProgram, ensureGlScene3DProgram } from './glMeshProgram';
+// Uploads the resolved matcap surface uniforms: the linear tint (already sRgb-decoded on the CPU),
+// the optional matcap texture on texture unit 0, and the alpha-mask cutoff. The caller has already
+// selected the program (beginGlMeshDraw), set the view-projection, and uploaded u_view.
+export function bindGlMatcapSurface(state, program, tint, matcap, alphaCutoff) {
+    const gl = state.gl;
+    gl.uniform4f(program.locTint, tint[0], tint[1], tint[2], tint[3]);
+    gl.uniform1f(program.locAlphaCutoff, alphaCutoff);
+    if (matcap !== null && matcap.image !== null && hasImageResourcePixels(matcap.image)) {
+        gl.activeTexture(gl.TEXTURE0);
+        bindGlImageResourceTexture(state, matcap.image, matcap.sampler);
+        gl.uniform1i(program.locMatcap, 0);
+    }
+}
+// A short, stable, order-independent string identity for a matcap 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 buildGlMatcapDefineKey(key) {
+    return `${key.alphaMaskEnabled ? 'm' : '-'}${key.hasMatcap ? 't' : '-'}`;
+}
+// Compiles the matcap shader for a define key, links it, and resolves its uniform locations. Pure GL
+// work — no caching — used by ensureGlMatcapProgram.
+export function compileGlMatcapProgram(gl, key) {
+    const program = compileGlProgram(gl, getGlMatcapVertexSourceForKey(key), getGlMatcapFragmentSourceForKey(key));
+    return {
+        locAlphaCutoff: gl.getUniformLocation(program, 'u_alphaCutoff'),
+        locMatcap: gl.getUniformLocation(program, 'u_matcap'),
+        locModel: gl.getUniformLocation(program, 'u_model'),
+        locNormalMatrix: gl.getUniformLocation(program, 'u_normalMatrix'),
+        locTint: gl.getUniformLocation(program, 'u_tint'),
+        locView: gl.getUniformLocation(program, 'u_view'),
+        locViewProjection: gl.getUniformLocation(program, 'u_viewProjection'),
+        program,
+    };
+}
+// Resolves the matcap program for a define key, compiling and caching it on first use through the
+// shared scene program cache under the `matcap:` family namespace.
+export function ensureGlMatcapProgram(state, key) {
+    return ensureGlScene3DProgram(state, `matcap:${buildGlMatcapDefineKey(key)}`, (gl) => compileGlMatcapProgram(gl, key));
+}
+// The full fragment source for a define key (define block + body), ready to hand to the GL compiler.
+export function getGlMatcapFragmentSourceForKey(key) {
+    return buildDefineSource(key) + MATCAP_FRAGMENT_BODY;
+}
+// The full vertex source for a define key (define block + body), ready to hand to the GL compiler.
+export function getGlMatcapVertexSourceForKey(key) {
+    return buildDefineSource(key) + MATCAP_VERTEX_BODY;
+}
+function buildDefineSource(key) {
+    let defines = '#version 300 es\n';
+    if (key.alphaMaskEnabled)
+        defines += '#define ALPHA_MASK\n';
+    if (key.hasMatcap)
+        defines += '#define HAS_MATCAP\n';
+    return defines;
+}
+const MATCAP_VERTEX_BODY = `
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec3 a_normal;
+
+uniform mat4 u_viewProjection;
+uniform mat4 u_model;
+uniform mat4 u_view;
+uniform mat3 u_normalMatrix;
+
+out vec3 v_viewNormal;
+
+void main() {
+  // u_normalMatrix takes the object normal into world space (handles model rotation/scale);
+  // mat3(u_view) rotates it into view space. Normalized in the fragment scene2d.
+  v_viewNormal = mat3(u_view) * (u_normalMatrix * a_normal);
+  gl_Position = u_viewProjection * u_model * vec4(a_position, 1.0);
+}
+`;
+const MATCAP_FRAGMENT_BODY = `
+precision highp float;
+
+in vec3 v_viewNormal;
+
+uniform vec4 u_tint;
+#ifdef HAS_MATCAP
+uniform sampler2D u_matcap;
+#endif
+#ifdef ALPHA_MASK
+uniform float u_alphaCutoff;
+#endif
+
+uniform float u_objectAlpha;
+
+out vec4 fragColor;
+
+// sRgb texels are gamma-encoded; decode to linear before use. u_tint is already linear (decoded on
+// the CPU at bind), so only the sampled matcap needs decoding.
+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));
+}
+
+void main() {
+  vec4 color = u_tint;
+#ifdef HAS_MATCAP
+  // The view-space normal projected to 2D indexes the prebaked-lit sphere: uv = n.xy * 0.5 + 0.5.
+  vec3 viewNormal = normalize(v_viewNormal);
+  vec2 matcapUv = viewNormal.xy * 0.5 + 0.5;
+  vec4 sampled = texture(u_matcap, matcapUv);
+  color.rgb *= srgbToLinear(sampled.rgb);
+  color.a *= sampled.a;
+#endif
+#ifdef ALPHA_MASK
+  if (color.a < u_alphaCutoff) discard;
+#endif
+  fragColor = color;
+  fragColor.a *= u_objectAlpha;
+}
+`;
+//# sourceMappingURL=glMatcapPrelude.js.map

package/dist/glMatcapPrelude.js.map

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

package/dist/glMeshMaterialRegistry.d.ts

@@ -0,0 +1,5 @@
+import type { GlMeshMaterialRenderer, GlRenderState, Kind, Material } from '@flighthq/types';
+export declare function getGlMeshMaterialRenderer(state: GlRenderState, kind: Kind): GlMeshMaterialRenderer | null;
+export declare function registerGlMeshMaterialRenderer(state: GlRenderState, kind: Kind, renderer: GlMeshMaterialRenderer): void;
+export declare function resolveGlMeshMaterialRenderer(state: GlRenderState, material: Readonly<Material> | null): GlMeshMaterialRenderer | null;
+//# sourceMappingURL=glMeshMaterialRegistry.d.ts.map

package/dist/glMeshMaterialRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glMeshMaterialRegistry.d.ts","sourceRoot":"","sources":["../src/glMeshMaterialRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAQ7F,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,GAAG,sBAAsB,GAAG,IAAI,CAEzG;AAMD,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,sBAAsB,GAC/B,IAAI,CAEN;AAMD,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,GAClC,sBAAsB,GAAG,IAAI,CAO/B"}

package/dist/glMeshMaterialRegistry.js

@@ -0,0 +1,29 @@
+import { DefaultMaterialKind } from '@flighthq/types';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+// Returns the 3D mesh-material renderer registered for a kind on this state, or null. The 3D scene
+// analog of getGlMaterialRenderer; reads scene-gl's own per-state registry (sceneMeshMaterialRegistry),
+// distinct from the 2D materialRendererMap.
+export function getGlMeshMaterialRenderer(state, kind) {
+    return getGlScene3DRuntime(state).materialRegistry.get(kind) ?? null;
+}
+// Registers a 3D mesh-material renderer against a material kind on this state. Opt-in: drawScene3D
+// only draws subsets whose material kind (or DefaultMaterialKind) has a renderer here. Call
+// registerStandardPbrGlMaterial for the built-in StandardPbr path. Mirrors registerGlMaterialRenderer
+// but writes scene-gl's separate 3D registry.
+export function registerGlMeshMaterialRenderer(state, kind, renderer) {
+    getGlScene3DRuntime(state).materialRegistry.set(kind, renderer);
+}
+// Resolves a mesh subset's material to its registered 3D renderer: by the material's kind, else the
+// renderer registered for DefaultMaterialKind, else null. drawScene3D skips a subset whose material
+// resolves to null (no built-in fallback — every material, including the default, enters only
+// through registration). Mirrors resolveGlMaterialRenderer over the 3D registry.
+export function resolveGlMeshMaterialRenderer(state, material) {
+    const registry = getGlScene3DRuntime(state).materialRegistry;
+    if (material !== null) {
+        const renderer = registry.get(material.kind);
+        if (renderer !== undefined)
+            return renderer;
+    }
+    return registry.get(DefaultMaterialKind) ?? null;
+}
+//# sourceMappingURL=glMeshMaterialRegistry.js.map

package/dist/glMeshMaterialRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glMeshMaterialRegistry.js","sourceRoot":"","sources":["../src/glMeshMaterialRegistry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAEzD,mGAAmG;AACnG,wGAAwG;AACxG,4CAA4C;AAC5C,MAAM,UAAU,yBAAyB,CAAC,KAAoB,EAAE,IAAU;IACxE,OAAO,mBAAmB,CAAC,KAAK,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;AACvE,CAAC;AAED,mGAAmG;AACnG,4FAA4F;AAC5F,sGAAsG;AACtG,8CAA8C;AAC9C,MAAM,UAAU,8BAA8B,CAC5C,KAAoB,EACpB,IAAU,EACV,QAAgC;IAEhC,mBAAmB,CAAC,KAAK,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AAClE,CAAC;AAED,oGAAoG;AACpG,oGAAoG;AACpG,8FAA8F;AAC9F,iFAAiF;AACjF,MAAM,UAAU,6BAA6B,CAC3C,KAAoB,EACpB,QAAmC;IAEnC,MAAM,QAAQ,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC,gBAAgB,CAAC;IAC7D,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtB,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,QAAQ,KAAK,SAAS;YAAE,OAAO,QAAQ,CAAC;IAC9C,CAAC;IACD,OAAO,QAAQ,CAAC,GAAG,CAAC,mBAAmB,CAAC,IAAI,IAAI,CAAC;AACnD,CAAC"}

package/dist/glMeshProgram.d.ts

@@ -0,0 +1,14 @@
+import type { GlMeshProgram, Camera3D, GlRenderState, MeshGeometry, Scene3DRenderProxy, TextureLike, VideoTexture } from '@flighthq/types';
+export declare function beginGlMeshDraw(state: GlRenderState, program: Readonly<GlMeshProgram>, doubleSided: boolean): void;
+export declare function bindGlUvTransform(gl: WebGL2RenderingContext, program: Readonly<GlMeshProgram>, texture: Readonly<TextureLike | VideoTexture> | null): void;
+export declare function compileGlProgram(gl: WebGL2RenderingContext, vertexSource: string, fragmentSource: string): WebGLProgram;
+export declare function destroyGlMeshProgram(state: GlRenderState, program: Readonly<GlMeshProgram>): void;
+export declare function drawGlMeshSubset(state: GlRenderState, program: Readonly<GlMeshProgram>, proxy: Readonly<Scene3DRenderProxy>, geometry: Readonly<MeshGeometry>): void;
+export declare function ensureGlScene3DProgram<T extends GlMeshProgram>(state: GlRenderState, key: string, compile: (gl: WebGL2RenderingContext) => T): T;
+export declare function hasGlUvTransform(texture: Readonly<TextureLike | VideoTexture> | null): boolean;
+export declare function setGlMeshCameraPosition(gl: WebGL2RenderingContext, locCameraPosition: WebGLUniformLocation | null, camera: Readonly<Camera3D>): void;
+export declare function setGlMeshViewProjection(gl: WebGL2RenderingContext, locViewProjection: WebGLUniformLocation | null, camera: Readonly<Camera3D>): void;
+export declare const GL_UV_TRANSFORM_VERTEX_GLSL = "\n#ifdef HAS_UV_TRANSFORM\nuniform mat3 u_uvTransform;\nvec2 applyUvTransform(vec2 uv) { return (u_uvTransform * vec3(uv, 1.0)).xy; }\n#else\nvec2 applyUvTransform(vec2 uv) { return uv; }\n#endif\n";
+export declare const SKIN_PALETTE_TEXTURE_UNIT = 12;
+export declare const GL_SKIN_VERTEX_DECLARATIONS_GLSL = "\nlayout(location = 6) in vec4 a_joints0;\nlayout(location = 7) in vec4 a_weights0;\nuniform highp sampler2D u_jointTexture;\n\nmat4 fetchJointMatrix(int joint) {\n  int x = joint * 4;\n  return mat4(\n    texelFetch(u_jointTexture, ivec2(x, 0), 0),\n    texelFetch(u_jointTexture, ivec2(x + 1, 0), 0),\n    texelFetch(u_jointTexture, ivec2(x + 2, 0), 0),\n    texelFetch(u_jointTexture, ivec2(x + 3, 0), 0)\n  );\n}\n\nmat4 skinMatrix() {\n  return a_weights0.x * fetchJointMatrix(int(a_joints0.x))\n       + a_weights0.y * fetchJointMatrix(int(a_joints0.y))\n       + a_weights0.z * fetchJointMatrix(int(a_joints0.z))\n       + a_weights0.w * fetchJointMatrix(int(a_joints0.w));\n}\n";
+//# sourceMappingURL=glMeshProgram.d.ts.map

package/dist/glMeshProgram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glMeshProgram.d.ts","sourceRoot":"","sources":["../src/glMeshProgram.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EACb,QAAQ,EACR,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,WAAW,EACX,YAAY,EACb,MAAM,iBAAiB,CAAC;AAUzB,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI,CAelH;AAQD,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,sBAAsB,EAC1B,OAAO,EAAE,QAAQ,CAAC,aAAa,CAAC,EAChC,OAAO,EAAE,QAAQ,CAAC,WAAW,GAAG,YAAY,CAAC,GAAG,IAAI,GACnD,IAAI,CASN;AAKD,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,sBAAsB,EAC1B,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,GACrB,YAAY,CAEd;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,IAAI,CAEjG;AAMD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,QAAQ,CAAC,aAAa,CAAC,EAChC,KAAK,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EACnC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,GAC/B,IAAI,CAuCN;AAQD,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,aAAa,EAC5D,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,EAAE,EAAE,sBAAsB,KAAK,CAAC,GACzC,CAAC,CAQH;AAMD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,GAAG,YAAY,CAAC,GAAG,IAAI,GAAG,OAAO,CAE9F;AAKD,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,sBAAsB,EAC1B,iBAAiB,EAAE,oBAAoB,GAAG,IAAI,EAC9C,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,GACzB,IAAI,CAIN;AAKD,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,sBAAsB,EAC1B,iBAAiB,EAAE,oBAAoB,GAAG,IAAI,EAC9C,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,GACzB,IAAI,CAIN;AAQD,eAAO,MAAM,2BAA2B,0MAOvC,CAAC;AAKF,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAU5C,eAAO,MAAM,gCAAgC,krBAqB5C,CAAC"}

package/dist/glMeshProgram.js

@@ -0,0 +1,193 @@
+import { getCamera3DViewProjectionMatrix4 } from '@flighthq/camera';
+import { createMatrix3, createMatrix4, getMatrix4Position, inverseMatrix4 } from '@flighthq/geometry';
+import { createGlProgram, uploadGlSkinPaletteTexture } from '@flighthq/render-gl';
+import { getTextureUvMatrix, hasTextureUvTransform } from '@flighthq/texture';
+import { ensureGlMeshUpload } from './glMeshUpload';
+import { ensureGlSkinPalette, getGlScene3DRuntime } from './glScene3DRuntime';
+// The shared per-bind head for every mesh-material family: stores the family's program as the active
+// bind→draw handoff, selects it, and sets the depth + face-cull state a forward 3D draw needs (depth
+// test LESS + depth write on; back-face cull unless the material is double-sided). The render-effect
+// pipeline owns binding the rgba16f scene target and enabling depth at the framebuffer level; this
+// fixes the per-material test/write/cull so a renderer invoked without the full pipeline still
+// occludes correctly. A family's bind() calls this, then sets its own camera/material uniforms.
+export function beginGlMeshDraw(state, program, doubleSided) {
+    const gl = state.gl;
+    getGlScene3DRuntime(state).activeMeshProgram = program;
+    gl.useProgram(program.program);
+    gl.enable(gl.DEPTH_TEST);
+    gl.depthFunc(gl.LESS);
+    gl.depthMask(true);
+    if (doubleSided) {
+        gl.disable(gl.CULL_FACE);
+    }
+    else {
+        gl.enable(gl.CULL_FACE);
+        gl.cullFace(gl.BACK);
+    }
+}
+// Uploads a material's primary-texture uv transform to the HAS_UV_TRANSFORM vertex variant. Resolves
+// u_uvTransform lazily and caches it on the program (mirroring locObjectAlpha): a null location means
+// the compiled variant omits the uniform — the identity path — so this is a cheap no-op there, and a
+// null texture likewise skips. @flighthq/texture composes the KHR_texture_transform column-major, so
+// it uploads with transpose=false and `u_uvTransform * vec3(uv, 1.0)` matches the CPU
+// transformTextureUv reference.
+export function bindGlUvTransform(gl, program, texture) {
+    let loc = program.locUvTransform;
+    if (loc === undefined) {
+        loc = gl.getUniformLocation(program.program, 'u_uvTransform');
+        program.locUvTransform = loc;
+    }
+    if (loc === null || texture === null)
+        return;
+    getTextureUvMatrix(scratchUvMatrix, texture);
+    gl.uniformMatrix3fv(loc, false, scratchUvMatrix.m);
+}
+// Compiles a vertex + fragment source pair into a linked GL program. Shared by every family's
+// program compile. Throws on a compile or link failure, which is a programmer error (a malformed
+// prelude), not an expected runtime condition — correct preludes always compile.
+export function compileGlProgram(gl, vertexSource, fragmentSource) {
+    return createGlProgram(gl, vertexSource, fragmentSource, 'Mesh');
+}
+// Frees the linked GL program backing a mesh-material family program. The program object must not be
+// used after this call. Deleting an already-deleted GL program is a silent no-op, so destroying a
+// program that a sibling render state still aliases is safe. Frees only the shader — the caller drops
+// the program from its cache separately (see destroyGlScene3DRuntime, which does both).
+export function destroyGlMeshProgram(state, program) {
+    state.gl.deleteProgram(program.program);
+}
+// The shared per-draw tail for every mesh-material family: uploads the model + normal matrices from
+// the proxy, lazily uploads the geometry's GPU buffers (cached by geometry.version), and issues the
+// indexed (or array) draw over the proxy's subset range. Families call this from draw() after bind()
+// has selected and stored their program, so the geometry path lives in exactly one place.
+export function drawGlMeshSubset(state, program, proxy, geometry) {
+    const gl = state.gl;
+    gl.uniformMatrix4fv(program.locModel, false, proxy.worldMatrix.m);
+    if (program.locNormalMatrix !== null)
+        gl.uniformMatrix3fv(program.locNormalMatrix, false, proxy.normalMatrix.m);
+    // Resolve u_objectAlpha once per program (undefined until first draw), then upload the resolved
+    // per-object opacity when the shader declares it. A program whose fragment scene2d lacks the uniform
+    // caches a null location and skips silently, so families without it cost nothing beyond one lookup.
+    let locObjectAlpha = program.locObjectAlpha;
+    if (locObjectAlpha === undefined) {
+        locObjectAlpha = gl.getUniformLocation(program.program, 'u_objectAlpha');
+        program.locObjectAlpha = locObjectAlpha;
+    }
+    if (locObjectAlpha !== null)
+        gl.uniform1f(locObjectAlpha, proxy.alpha ?? 1);
+    // GPU skinning: upload the mesh's bone palette into the per-state RGBA32F data texture and bind it on
+    // the skin-palette texture unit for the HAS_SKIN variant. Only a skinned program has the location, and
+    // only a skinned mesh carries a palette; a mismatch (one without the other) simply skips the upload and
+    // the shader falls back to its rigid path. The joint count is the palette length / 16 (16 floats/mat4).
+    const jointMatrices = proxy.jointMatrices;
+    const gpuSkinned = program.locJointTexture != null && jointMatrices != null;
+    if (gpuSkinned) {
+        const palette = ensureGlSkinPalette(state);
+        gl.activeTexture(gl.TEXTURE0 + SKIN_PALETTE_TEXTURE_UNIT);
+        uploadGlSkinPaletteTexture(gl, palette, jointMatrices, (jointMatrices.length / 16) | 0);
+        gl.uniform1i(program.locJointTexture, SKIN_PALETTE_TEXTURE_UNIT);
+    }
+    // A GPU-skinned draw uploads the static bind pose (the shader deforms it via the palette), so the
+    // per-frame CPU pose updateMeshSkin also writes to geometry.vertices is not re-applied on top.
+    const upload = ensureGlMeshUpload(state, geometry, gpuSkinned);
+    const subset = proxy.subset;
+    if (upload.indexBuffer !== null) {
+        const elementSize = upload.indexType === gl.UNSIGNED_INT ? 4 : 2;
+        gl.drawElements(upload.primitiveMode, subset.indexCount, upload.indexType, subset.indexOffset * elementSize);
+    }
+    else {
+        gl.drawArrays(upload.primitiveMode, subset.indexOffset, subset.indexCount);
+    }
+}
+// Resolves a compiled program for a string cache key, compiling it via the factory on first use and
+// caching it on the scene runtime's per-state programCache. Every family routes its program through
+// this one cache; the key is namespaced by family + define key (for example `unlit:b-`), so distinct
+// families and feature variants compile at most once per state and never collide. The factory returns
+// the family's program record (locations resolved at compile time); the cast is sound because the key
+// namespace guarantees a given key always maps to the same family's program shape.
+export function ensureGlScene3DProgram(state, key, compile) {
+    const runtime = getGlScene3DRuntime(state);
+    let program = runtime.programCache.get(key);
+    if (program === undefined) {
+        program = compile(state.gl);
+        runtime.programCache.set(key, program);
+    }
+    return program;
+}
+// The HAS_UV_TRANSFORM define-key predicate every map-sampling family shares: true only when the
+// material's primary map is bound (an image is present, so it is actually sampled) AND carries a
+// non-identity uv transform. Gating on both keeps an untiled or unbound surface on the identity shader
+// variant, so it never pays for the uv-transform uniform or the extra vertex multiply.
+export function hasGlUvTransform(texture) {
+    return texture !== null && (!('image' in texture) || texture.image !== null) && hasTextureUvTransform(texture);
+}
+// Uploads the camera world position (the translation of the inverse view matrix) to a lit family's
+// u_cameraPosition. Lighting-independent families (unlit/debug) skip this — only families whose
+// fragment scene2d needs a view vector resolve and bind a camera-position location.
+export function setGlMeshCameraPosition(gl, locCameraPosition, camera) {
+    inverseMatrix4(scratchInverseView, camera.view);
+    getMatrix4Position(scratchCameraPosition, scratchInverseView);
+    gl.uniform3f(locCameraPosition, scratchCameraPosition.x, scratchCameraPosition.y, scratchCameraPosition.z);
+}
+// Uploads the camera view-projection matrix to a program's u_viewProjection. Every family's vertex
+// scene2d shares this transform; the perspective aspect falls back to 1 when zero (degenerate camera)
+// so a malformed projection never divides by zero.
+export function setGlMeshViewProjection(gl, locViewProjection, camera) {
+    const aspect = camera.projection.kind === 'perspective' ? camera.projection.aspect : 1;
+    getCamera3DViewProjectionMatrix4(scratchViewProjection, camera, aspect !== 0 ? aspect : 1);
+    gl.uniformMatrix4fv(locViewProjection, false, scratchViewProjection.m);
+}
+// Vertex-scene2d GLSL every map-sampling family interpolates into its vertex body ahead of `main`: the
+// guarded u_uvTransform uniform and an applyUvTransform() the body calls on a_uv0 instead of passing
+// it through. HAS_UV_TRANSFORM — set by a family's define block only when its primary texture carries a
+// non-identity transform (see hasTextureUvTransform) — gates both the uniform and the mat3 multiply, so
+// an untiled surface compiles the identity branch (inlined away) and pays nothing: the assembly never
+// taxes the primitive. u_uvTransform is column-major (see bindGlUvTransform).
+export const GL_UV_TRANSFORM_VERTEX_GLSL = `
+#ifdef HAS_UV_TRANSFORM
+uniform mat3 u_uvTransform;
+vec2 applyUvTransform(vec2 uv) { return (u_uvTransform * vec3(uv, 1.0)).xy; }
+#else
+vec2 applyUvTransform(vec2 uv) { return uv; }
+#endif
+`;
+// The GPU skin-palette bone texture is read from this texture unit — above the material maps (0–4), the
+// directional shadow map (8), and the IBL set (9/10/11), so a skinned lit draw never collides with any of
+// them. drawGlMeshSubset binds the palette texture here and sets u_jointTexture to this unit.
+export const SKIN_PALETTE_TEXTURE_UNIT = 12;
+// Vertex-scene2d GLSL the HAS_SKIN variant prepends before the family's vertex body: the joints0/weights0
+// influence attributes (locations 6/7, wired by ensureGlMeshUpload), the bone-palette DATA TEXTURE, and
+// the linear-blend `skinMatrix()` the body applies to position/normal/tangent. The palette is an RGBA32F
+// texture read with texelFetch (GLSL ES 3.0 core — no float-filter extension), one mat4 packed as four
+// consecutive texels (column 0..3) so joint j's column c is at texel (j*4 + c, 0). Replaces the old
+// `uniform mat4 u_jointMatrices[MAX_JOINTS]` array: the joint count is bounded by MAX_TEXTURE_SIZE, so
+// there is no `#define MAX_JOINTS` cap and no CPU fallback above a uniform-budget capacity. Vertex-only —
+// never added to a fragment source (the `in` attributes are illegal there).
+export const GL_SKIN_VERTEX_DECLARATIONS_GLSL = `
+layout(location = 6) in vec4 a_joints0;
+layout(location = 7) in vec4 a_weights0;
+uniform highp sampler2D u_jointTexture;
+
+mat4 fetchJointMatrix(int joint) {
+  int x = joint * 4;
+  return mat4(
+    texelFetch(u_jointTexture, ivec2(x, 0), 0),
+    texelFetch(u_jointTexture, ivec2(x + 1, 0), 0),
+    texelFetch(u_jointTexture, ivec2(x + 2, 0), 0),
+    texelFetch(u_jointTexture, ivec2(x + 3, 0), 0)
+  );
+}
+
+mat4 skinMatrix() {
+  return a_weights0.x * fetchJointMatrix(int(a_joints0.x))
+       + a_weights0.y * fetchJointMatrix(int(a_joints0.y))
+       + a_weights0.z * fetchJointMatrix(int(a_joints0.z))
+       + a_weights0.w * fetchJointMatrix(int(a_joints0.w));
+}
+`;
+const scratchViewProjection = createMatrix4();
+const scratchInverseView = createMatrix4();
+const scratchCameraPosition = { x: 0, y: 0, z: 0 };
+// Column-major uv matrix composed per bind and uploaded directly; reused across every
+// bindGlUvTransform call (single-threaded GL draw path).
+const scratchUvMatrix = createMatrix3();
+//# sourceMappingURL=glMeshProgram.js.map