@flighthq/render-gl 0.2.0 → 0.2.1-next.410.a23f189

package/dist/glCompressedTexture.d.ts

@@ -0,0 +1,8 @@
+import type { GlCompressedTextureDecoder, GlCompressedTextureSupport, GlRenderState, TextureContainer, TextureContainerFormat } from '@flighthq/types';
+export declare function detectGlCompressedTextureSupport(gl: WebGL2RenderingContext): GlCompressedTextureSupport;
+export declare function getGlCompressedTextureFormat(gl: WebGL2RenderingContext, format: TextureContainerFormat): number;
+export declare function hasGlCompressedTextureFormat(support: Readonly<GlCompressedTextureSupport>, format: TextureContainerFormat): boolean;
+export declare function registerGlCompressedTextureDecoder(state: GlRenderState, decode: GlCompressedTextureDecoder | null): void;
+export declare function registerGlCompressedTextureUpload(state: GlRenderState, uploader?: null): void;
+export declare function uploadGlCompressedTextureContainer(gl: WebGL2RenderingContext, container: Readonly<TextureContainer>, payload: Readonly<Uint8Array>, decode?: GlCompressedTextureDecoder): boolean;
+//# sourceMappingURL=glCompressedTexture.d.ts.map

package/dist/glCompressedTexture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glCompressedTexture.d.ts","sourceRoot":"","sources":["../src/glCompressedTexture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,0BAA0B,EAC1B,aAAa,EAEb,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAmBzB,wBAAgB,gCAAgC,CAAC,EAAE,EAAE,sBAAsB,GAAG,0BAA0B,CAWvG;AAQD,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,sBAAsB,EAAE,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAqG/G;AAKD,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,QAAQ,CAAC,0BAA0B,CAAC,EAC7C,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAuCT;AAOD,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,0BAA0B,GAAG,IAAI,GACxC,IAAI,CAEN;AASD,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,CAE7F;AAiBD,wBAAgB,kCAAkC,CAChD,EAAE,EAAE,sBAAsB,EAC1B,SAAS,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EACrC,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC7B,MAAM,CAAC,EAAE,0BAA0B,GAClC,OAAO,CA0DT"}

package/dist/glCompressedTexture.js

@@ -0,0 +1,270 @@
+import { getGlRenderStateRuntime } from './glRenderState';
+// GPU-native block-compressed texture upload for WebGL2: hand a parsed TextureContainer (KTX2 / DDS /
+// ATF) plus its byte payload and this pushes every mip level straight to the GPU with
+// `compressedTexImage2D` — no CPU decode — when the device exposes the matching
+// `WEBGL_compressed_texture_*` extension. When it does not, an optional RGBA decode seam turns each
+// level into plain pixels the portable `texImage2D` path uploads, so an asset still renders on
+// hardware missing that block format (desktop S3TC/BPTC vs mobile ETC2/ASTC).
+//
+// Detection is done once per context via `detectGlCompressedTextureSupport`; the format→GL-enum
+// mapping reads the live extension objects, so the enum constants come from the browser, not a baked
+// table. Basis intermediate formats (`etc1s`/`uastc`) are NOT uploaded here — they must be transcoded
+// to a concrete BCn/ETC/ASTC format first (see the deferred `@flighthq/texture-transcode` seam).
+// Probes which block-compressed families the WebGL2 context can upload natively, from its
+// `WEBGL_compressed_texture_*` extensions. Call once per context and cache the result; each `getExtension`
+// activates the extension so the enum constants become readable by `getGlCompressedTextureFormat`.
+export function detectGlCompressedTextureSupport(gl) {
+    return {
+        astc: gl.getExtension('WEBGL_compressed_texture_astc') !== null,
+        bptc: gl.getExtension('EXT_texture_compression_bptc') !== null,
+        etc: gl.getExtension('WEBGL_compressed_texture_etc') !== null,
+        pvrtc: gl.getExtension('WEBGL_compressed_texture_pvrtc') !== null,
+        rgtc: gl.getExtension('EXT_texture_compression_rgtc') !== null,
+        s3tc: gl.getExtension('WEBGL_compressed_texture_s3tc') !== null &&
+            gl.getExtension('WEBGL_compressed_texture_s3tc_srgb') !== null,
+    };
+}
+// Resolves the GL `internalformat` enum for a container format from the device's live compression
+// extensions, or -1 when the device cannot upload that format natively (missing extension, or an
+// uncompressed / Basis-intermediate format that is not a `compressedTexImage2D` target). The returned
+// number is the exact enum `compressedTexImage2D` expects, read off the extension object so it matches
+// the running browser. Requires the relevant extension to already be enabled (call
+// `detectGlCompressedTextureSupport` first).
+export function getGlCompressedTextureFormat(gl, format) {
+    const s3tc = gl.getExtension('WEBGL_compressed_texture_s3tc');
+    const s3tcSrgb = gl.getExtension('WEBGL_compressed_texture_s3tc_srgb');
+    const rgtc = gl.getExtension('EXT_texture_compression_rgtc');
+    const bptc = gl.getExtension('EXT_texture_compression_bptc');
+    const etc = gl.getExtension('WEBGL_compressed_texture_etc');
+    const astc = gl.getExtension('WEBGL_compressed_texture_astc');
+    const pvrtc = gl.getExtension('WEBGL_compressed_texture_pvrtc');
+    const enumFromExt = (ext, key) => typeof ext?.[key] === 'number' ? ext[key] : -1;
+    switch (format) {
+        case 'bc1':
+            return enumFromExt(s3tc, 'COMPRESSED_RGBA_S3TC_DXT1_EXT');
+        case 'bc1Srgb':
+            return enumFromExt(s3tcSrgb, 'COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT');
+        case 'bc2':
+            return enumFromExt(s3tc, 'COMPRESSED_RGBA_S3TC_DXT3_EXT');
+        case 'bc2Srgb':
+            return enumFromExt(s3tcSrgb, 'COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT');
+        case 'bc3':
+            return enumFromExt(s3tc, 'COMPRESSED_RGBA_S3TC_DXT5_EXT');
+        case 'bc3Srgb':
+            return enumFromExt(s3tcSrgb, 'COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT');
+        case 'bc4':
+            return enumFromExt(rgtc, 'COMPRESSED_RED_RGTC1_EXT');
+        case 'bc4Snorm':
+            return enumFromExt(rgtc, 'COMPRESSED_SIGNED_RED_RGTC1_EXT');
+        case 'bc5':
+            return enumFromExt(rgtc, 'COMPRESSED_RED_GREEN_RGTC2_EXT');
+        case 'bc5Snorm':
+            return enumFromExt(rgtc, 'COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT');
+        case 'bc6hUfloat':
+            return enumFromExt(bptc, 'COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT');
+        case 'bc6hSfloat':
+            return enumFromExt(bptc, 'COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT');
+        case 'bc7':
+            return enumFromExt(bptc, 'COMPRESSED_RGBA_BPTC_UNORM_EXT');
+        case 'bc7Srgb':
+            return enumFromExt(bptc, 'COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT');
+        case 'etc1':
+        case 'etc2Rgb':
+            return enumFromExt(etc, 'COMPRESSED_RGB8_ETC2');
+        case 'etc2RgbSrgb':
+            return enumFromExt(etc, 'COMPRESSED_SRGB8_ETC2');
+        case 'etc2Rgba':
+            return enumFromExt(etc, 'COMPRESSED_RGBA8_ETC2_EAC');
+        case 'etc2RgbaSrgb':
+            return enumFromExt(etc, 'COMPRESSED_SRGB8_ALPHA8_ETC2_EAC');
+        case 'etc2RgbA1':
+            return enumFromExt(etc, 'COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2');
+        case 'etc2RgbA1Srgb':
+            return enumFromExt(etc, 'COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2');
+        case 'eacR11':
+            return enumFromExt(etc, 'COMPRESSED_R11_EAC');
+        case 'eacR11Snorm':
+            return enumFromExt(etc, 'COMPRESSED_SIGNED_R11_EAC');
+        case 'eacRg11':
+            return enumFromExt(etc, 'COMPRESSED_RG11_EAC');
+        case 'eacRg11Snorm':
+            return enumFromExt(etc, 'COMPRESSED_SIGNED_RG11_EAC');
+        case 'pvrtc2bppRgb':
+            return enumFromExt(pvrtc, 'COMPRESSED_RGB_PVRTC_2BPPV1_IMG');
+        case 'pvrtc2bppRgba':
+            return enumFromExt(pvrtc, 'COMPRESSED_RGBA_PVRTC_2BPPV1_IMG');
+        case 'pvrtc4bppRgb':
+            return enumFromExt(pvrtc, 'COMPRESSED_RGB_PVRTC_4BPPV1_IMG');
+        case 'pvrtc4bppRgba':
+            return enumFromExt(pvrtc, 'COMPRESSED_RGBA_PVRTC_4BPPV1_IMG');
+        case 'astc4x4':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_4x4_KHR');
+        case 'astc5x4':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_5x4_KHR');
+        case 'astc5x5':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_5x5_KHR');
+        case 'astc6x5':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_6x5_KHR');
+        case 'astc6x6':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_6x6_KHR');
+        case 'astc8x5':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_8x5_KHR');
+        case 'astc8x6':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_8x6_KHR');
+        case 'astc8x8':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_8x8_KHR');
+        case 'astc10x5':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_10x5_KHR');
+        case 'astc10x6':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_10x6_KHR');
+        case 'astc10x8':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_10x8_KHR');
+        case 'astc10x10':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_10x10_KHR');
+        case 'astc12x10':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_12x10_KHR');
+        case 'astc12x12':
+            return enumFromExt(astc, 'COMPRESSED_RGBA_ASTC_12x12_KHR');
+        default:
+            // Uncompressed and Basis-intermediate formats have no compressedTexImage2D enum.
+            return -1;
+    }
+}
+// True when the device's detected support covers a container format's family — the cheap, GL-free gate
+// an asset pipeline uses to pick which of several shipped encodings to upload, without touching the
+// context. `srgb` twins ride the same extension as their unorm base, so both report against one flag.
+export function hasGlCompressedTextureFormat(support, format) {
+    switch (format) {
+        case 'bc1':
+        case 'bc1Srgb':
+        case 'bc2':
+        case 'bc2Srgb':
+        case 'bc3':
+        case 'bc3Srgb':
+            return support.s3tc;
+        case 'bc4':
+        case 'bc4Snorm':
+        case 'bc5':
+        case 'bc5Snorm':
+            return support.rgtc;
+        case 'bc6hUfloat':
+        case 'bc6hSfloat':
+        case 'bc7':
+        case 'bc7Srgb':
+            return support.bptc;
+        case 'etc1':
+        case 'etc2Rgb':
+        case 'etc2RgbSrgb':
+        case 'etc2Rgba':
+        case 'etc2RgbaSrgb':
+        case 'etc2RgbA1':
+        case 'etc2RgbA1Srgb':
+        case 'eacR11':
+        case 'eacR11Snorm':
+        case 'eacRg11':
+        case 'eacRg11Snorm':
+            return support.etc;
+        case 'pvrtc2bppRgb':
+        case 'pvrtc2bppRgba':
+        case 'pvrtc4bppRgb':
+        case 'pvrtc4bppRgba':
+            return support.pvrtc;
+        default:
+            return isAstcFormat(format) ? support.astc : false;
+    }
+}
+// Installs the RGBA fallback decoder used when the device cannot upload a compressed container's format
+// natively — the seam that lets an S3TC/BPTC asset still render on mobile ETC2/ASTC hardware (and vice
+// versa) by decoding each level to plain pixels. Opt-in and last-write-wins: a state that never draws a
+// compressed texture the device lacks never installs one, so the decoder (and any WASM block-codec it
+// wraps) tree-shakes out. Pass null to clear a previously installed decoder.
+export function registerGlCompressedTextureDecoder(state, decode) {
+    getGlRenderStateRuntime(state).compressedTextureDecoder = decode;
+}
+// Installs the block-compressed upload seam on a render state, opting the ~40-format
+// uploadGlCompressedTextureContainer path into the bundle only for a state that actually draws a
+// compressed texture. The 2D display draw path (uploadGlDisplayTexture) reads the installed handler off
+// the runtime and skips a compressed-only resource when none is registered, so a plain element/data
+// bitmap never carries the compression enum table. Opt-in and last-write-wins; pass null to clear a
+// previously installed uploader. The installed handler bridges a compressed ImageResource to
+// uploadGlCompressedTextureContainer, threading through any registered RGBA decode fallback.
+export function registerGlCompressedTextureUpload(state, uploader) {
+    getGlRenderStateRuntime(state).compressedTextureUpload = uploader === null ? null : uploadGlCompressedImageResource;
+}
+// Uploads every stored sub-image of a compressed container to the texture the caller has bound. Takes
+// the GPU-native `compressedTexImage2D`/`compressedTexImage3D` path when the device supports the
+// container's format; otherwise, if a `decode` seam is supplied, decompresses each 2D level to RGBA and
+// uploads it through the portable pixel path. Returns `true` when the container was uploaded (either
+// path), `false` when the format is neither natively supported nor decodable, or when the container is
+// still supercompressed (`supercompression !== 'None'`) — a sentinel, not a throw, so a caller falls
+// back to a different asset (or inflates/transcodes first). The caller owns creating/binding the
+// texture (to gl.TEXTURE_2D, gl.TEXTURE_CUBE_MAP, or gl.TEXTURE_2D_ARRAY per the container's shape) and
+// setting sampler/mip state; this uploads only the container's own sub-images.
+//
+// `container.levels` is the flat subresource list in `mip + (face + layer * faces) * mipLevels` order;
+// each flat index is decoded back to (mip, face, layer) so a cubemap's six faces land on
+// gl.TEXTURE_CUBE_MAP_POSITIVE_X + face and an array's layers slice into a gl.TEXTURE_2D_ARRAY. The
+// RGBA decode fallback covers only the plain 2D case (faces === 1, layers === 1); a compressed cubemap
+// or array with no native support reports failure rather than a partial 2D upload.
+export function uploadGlCompressedTextureContainer(gl, container, payload, decode) {
+    // A still-wrapped supercompressed payload (Zstd/ZLIB deflate or BasisLZ transcode) is not block data;
+    // uploading it as if it were would push corrupt pixels. Fail the sentinel and let the caller inflate
+    // or transcode through the deferred seam first.
+    if (container.supercompression !== 'None')
+        return false;
+    const nativeFormat = getGlCompressedTextureFormat(gl, container.format);
+    const faces = container.faces;
+    const layers = container.layers;
+    const mipLevels = container.mipLevels;
+    if (nativeFormat !== -1) {
+        // An array texture is immutable storage: allocate the whole mip chain × depth once with
+        // texStorage3D, then blit each layer's slice into its depth slot (layers are non-contiguous in the
+        // layer-major flat list, so per-subresource upload is required; compressedTexImage3D cannot
+        // allocate a null store the way the 2D path does).
+        if (layers > 1) {
+            gl.texStorage3D(gl.TEXTURE_2D_ARRAY, mipLevels, nativeFormat, container.width, container.height, layers);
+        }
+        for (let index = 0; index < container.levels.length; index += 1) {
+            const entry = container.levels[index];
+            const view = new Uint8Array(payload.buffer, payload.byteOffset + entry.byteOffset, entry.byteLength);
+            const mip = index % mipLevels;
+            const faceLayer = (index - mip) / mipLevels;
+            const face = faceLayer % faces;
+            const layer = (faceLayer - face) / faces;
+            if (layers > 1) {
+                gl.compressedTexSubImage3D(gl.TEXTURE_2D_ARRAY, mip, 0, 0, layer, entry.width, entry.height, 1, nativeFormat, view);
+            }
+            else {
+                const target = faces === 6 ? gl.TEXTURE_CUBE_MAP_POSITIVE_X + face : gl.TEXTURE_2D;
+                gl.compressedTexImage2D(target, mip, nativeFormat, entry.width, entry.height, 0, view);
+            }
+        }
+        return true;
+    }
+    // RGBA decode fallback: plain 2D only. A cubemap/array with no native block support is not decoded
+    // face-by-face here — report failure so the caller supplies a different encoding.
+    if (decode === undefined || faces !== 1 || layers !== 1)
+        return false;
+    for (let mip = 0; mip < container.levels.length; mip += 1) {
+        const entry = container.levels[mip];
+        const view = new Uint8Array(payload.buffer, payload.byteOffset + entry.byteOffset, entry.byteLength);
+        const rgba = decode(container.format, entry.width, entry.height, view);
+        if (rgba === null)
+            return false;
+        gl.texImage2D(gl.TEXTURE_2D, mip, gl.RGBA, entry.width, entry.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, rgba);
+    }
+    return true;
+}
+function isAstcFormat(format) {
+    return format.startsWith('astc');
+}
+// The installed GlCompressedTextureUploader: bridges a compressed ImageResource to the container upload,
+// threading through any registered RGBA decode fallback. Returns false when the resource carries no
+// compressed payload so the display path leaves the texture as-is rather than uploading garbage.
+function uploadGlCompressedImageResource(gl, image, decode) {
+    const compressed = image.compressed;
+    if (compressed === null)
+        return false;
+    return uploadGlCompressedTextureContainer(gl, compressed.container, compressed.payload, decode ?? undefined);
+}
+//# sourceMappingURL=glCompressedTexture.js.map

package/dist/glCompressedTexture.js.map

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

package/dist/glDraw.d.ts

@@ -1,7 +1,9 @@
-import type { GlBitmapShader, GlBlendRealization, GlRenderState } from '@flighthq/types';
+import type { GlBitmapShader, GlBlendRealization, GlRenderState, ImageResource, SamplerLike, VideoTexture } from '@flighthq/types';
 import { BlendMode } from '@flighthq/types';
 export declare function applyGlBlendMode(state: GlRenderState, blendMode: BlendMode | null): void;
-export declare function bindGlTexture(state: GlRenderState, imageSource: CanvasImageSource): WebGLTexture;
+export declare function bindGlImageResourceTexture(state: GlRenderState, image: Readonly<ImageResource>, sampler?: Readonly<SamplerLike> | null): WebGLTexture;
+export declare function bindGlTexture(state: GlRenderState, imageSource: CanvasImageSource, sampler?: Readonly<SamplerLike> | null): WebGLTexture;
+export declare function bindGlVideoTexture(state: GlRenderState, videoTexture: Readonly<VideoTexture>, sampler?: Readonly<SamplerLike> | null): WebGLTexture;
 export declare function createGlTexture(state: GlRenderState): WebGLTexture;
 export declare function drawGlQuad(state: GlRenderState, x0: number, y0: number, x1: number, y1: number, u0: number, v0: number, u1: number, v1: number): void;
 export declare function enableGlBlendModeSupport(state: GlRenderState): void;

package/dist/glDraw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glDraw.d.ts","sourceRoot":"","sources":["../src/glDraw.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACzF,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAU5C,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAQxF;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,GAAG,YAAY,CA2BhG;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CAYlE;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,aAAa,EACpB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,IAAI,CA0BN;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAGnE;AAKD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAExF;AAKD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAEtE;AAKD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,kBAAkB,GAAG,IAAI,CAGrH;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,aAAa,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,IAAI,CAcN;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAW5G;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAShF"}
+{"version":3,"file":"glDraw.d.ts","sourceRoot":"","sources":["../src/glDraw.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAClB,aAAa,EAEb,aAAa,EACb,WAAW,EAGX,YAAY,EACb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAY5C,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAQxF;AASD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,EAC9B,OAAO,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,GACrC,YAAY,CAiBd;AAWD,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,iBAAiB,EAC9B,OAAO,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,GACrC,YAAY,CA+Bd;AAWD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,aAAa,EACpB,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,EACpC,OAAO,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,GACrC,YAAY,CAgBd;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,YAAY,CAYlE;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,aAAa,EACpB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,IAAI,CA0BN;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAGnE;AAKD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAExF;AAKD,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAEtE;AAKD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,kBAAkB,GAAG,IAAI,CAGrH;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,aAAa,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,IAAI,CAcN;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAe5G;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAShF"}

package/dist/glDraw.js

@@ -1,6 +1,8 @@
 import { BlendMode } from '@flighthq/types';
 import { getGlRenderStateRuntime } from './glRenderState';
 import { setGlAttributes, setGlMatrixFromValues } from './glShader';
+import { uploadGlTextureData, uploadGlTextureElement } from './glTextureUpload';
+import { uploadGlTextureVideoFrame } from './glTextureVideoUpload';
 // Applies the blend mode's registered fixed-function realization to the GL context, skipping the
 // work when the mode is unchanged. A mode with no registered realization (an unregistered vendor
 // mode, or a built-in with no fixed-function equivalent such as Overlay) degrades to normal
@@ -16,19 +18,48 @@ export function applyGlBlendMode(state, blendMode) {
     gl.blendEquation(gl[realization.equation ?? 'FUNC_ADD']);
     gl.blendFunc(gl[realization.src], gl[realization.dst]);
 }
-export function bindGlTexture(state, imageSource) {
+// Binds (uploading + caching on first use, re-uploading when the pixels change) the GL texture for an
+// ImageResource — a bitmap, sprite atlas, or material map — and applies the sampler's full state. The
+// resource-level sibling of bindGlTexture (which takes a raw element): it accepts an element-backed OR a
+// data-only generated Surface (source-or-data upload via uploadGlDisplayTexture), and caches by the
+// resource entity in imageResourceTextureCache, keyed with the uploaded `version` so an in-place Surface
+// edit (which bumps version) re-uploads without the caller tracking it. Sampler state is re-applied every
+// bind so a resource reused by two materials with different samplers follows the current draw.
+export function bindGlImageResourceTexture(state, image, sampler) {
+    const runtime = getGlRenderStateRuntime(state);
+    const gl = state.gl;
+    const cache = runtime.imageResourceTextureCache;
+    let entry = cache.get(image);
+    if (entry === undefined) {
+        entry = { texture: gl.createTexture(), version: -1 };
+        cache.set(image, entry);
+    }
+    gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+    runtime.currentTexture = entry.texture;
+    if (entry.version !== image.version) {
+        uploadGlDisplayTexture(state, image);
+        entry.version = image.version;
+    }
+    applyGlSamplerState(state, runtime, entry.texture, sampler ?? null);
+    return entry.texture;
+}
+// Binds (uploading + caching on first use) the GL texture for an image source and applies the given
+// sampler's full sampling state — wrap, min/mag filter, anisotropy, and a generated mip chain — to
+// the bound texture. Sampler state is re-applied on every bind, not baked at creation, because the GL
+// texture is cached by image source alone: one image reused by two materials with different samplers
+// (e.g. a map bound as both normal and metallic-roughness with different sampling) shares one GL
+// texture, so its sampling must follow the current draw rather than whoever uploaded it first. WebGL2
+// allows REPEAT and mipmaps on NPOT textures, so no power-of-two constraint applies. Callers without a
+// sampler (2D bitmap/text/sprite) get the historical default: the state's allowSmoothing filter,
+// clamp-to-edge, and no mip chain. See applyGlSamplerState.
+export function bindGlTexture(state, imageSource, sampler) {
     const runtime = getGlRenderStateRuntime(state);
     const gl = state.gl;
     const textureCache = runtime.textureCache;
     let texture = textureCache.get(imageSource);
     if (!texture) {
-        const filter = state.allowSmoothing ? gl.LINEAR : gl.NEAREST;
         texture = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, texture);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
         // Both image and canvas sources present straight (un-premultiplied) alpha to texImage2D, so
         // premultiply on upload to match the premultiplied (ONE, ONE_MINUS_SRC_ALPHA) blend used
         // everywhere — uploaded images, canvas-backed shapes/text, and render-target composites. (A
@@ -39,12 +70,47 @@ export function bindGlTexture(state, imageSource) {
         textureCache.set(imageSource, texture);
         runtime.currentTexture = texture;
     }
-    else if (runtime.currentTexture !== texture) {
+    else {
+        // Always rebind on a cache hit, never skip on runtime.currentTexture. That tracker is the last
+        // texture bound to whatever unit was active THEN, but callers change the active unit between binds
+        // (a material binds its maps to units 0..4 via gl.activeTexture). Binding one image source to two
+        // units — e.g. a map reused as both normal and metallic-roughness — would otherwise leave the
+        // second unit unbound. A rebind is one cheap GL call; the sprite batch binds once per batch, so the
+        // dropped skip costs nothing meaningful.
         gl.bindTexture(gl.TEXTURE_2D, texture);
         runtime.currentTexture = texture;
     }
+    // texture is the active TEXTURE_2D binding in every path above; apply this draw's sampler state here
+    // so a cache hit picks it up instead of the first uploader's.
+    applyGlSamplerState(state, runtime, texture, sampler ?? null);
     return texture;
 }
+// Binds the GL texture for a VideoTexture and re-uploads the backing element's current frame only when
+// its `frameId` has advanced past the one last uploaded — the dynamic, per-frame sibling of
+// bindGlImageResourceTexture (settled ImageResource) and bindGlTexture (raw element). The GL texture is
+// cached by the VideoTexture entity in the runtime's videoTextureCache (lazily created), so it persists
+// across frames while the frameId dirty-gate keeps a paused or stalled stream from re-uploading. Applies
+// the VideoTexture's sampler every bind so a stream shared by two samplers follows the current draw.
+// Leaves the texture bound at the active unit for the caller to sample. Callers advance `frameId` via
+// advanceVideoTexture when the element reports a fresh decoded frame; this reads the current frame
+// through uploadGlTextureElement's zero-copy element fast-path.
+export function bindGlVideoTexture(state, videoTexture, sampler) {
+    const runtime = getGlRenderStateRuntime(state);
+    const gl = state.gl;
+    const cache = (runtime.videoTextureCache ??= new WeakMap());
+    let entry = cache.get(videoTexture);
+    if (entry === undefined) {
+        entry = { texture: gl.createTexture(), uploadedFrameId: -1 };
+        cache.set(videoTexture, entry);
+    }
+    gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+    runtime.currentTexture = entry.texture;
+    // Straight-alpha element under premultiplied blend would blow out RGB; match the bitmap/element path.
+    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+    entry.uploadedFrameId = uploadGlTextureVideoFrame(gl, videoTexture, entry.uploadedFrameId);
+    applyGlSamplerState(state, runtime, entry.texture, sampler ?? videoTexture.sampler ?? null);
+    return entry.texture;
+}
 export function createGlTexture(state) {
     const runtime = getGlRenderStateRuntime(state);
     const gl = state.gl;
@@ -116,14 +182,19 @@ export function setGlQuadMatrixFromOffset(state, a, b, c, d, tx, ty, dx, dy) {
 export function updateGlTexture(state, texture, canvas) {
     const runtime = getGlRenderStateRuntime(state);
     const gl = state.gl;
-    if (runtime.currentTexture !== texture) {
-        gl.bindTexture(gl.TEXTURE_2D, texture);
-        runtime.currentTexture = texture;
-    }
+    // Always rebind before uploading — runtime.currentTexture is unit-blind (see bindGlTexture), so a
+    // skip could upload into whatever is bound on the currently-active unit instead of `texture`.
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    runtime.currentTexture = texture;
     // Browsers pass canvas pixel data to Gl as straight (unmultiplied) alpha.
     // Premultiply on upload so the texture matches the (ONE, ONE_MINUS_SRC_ALPHA) blend mode.
     gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, canvas);
+    // Refresh the mip chain if this texture carries one (a canvas/video that opted into mipmaps); the
+    // re-uploaded base level would otherwise leave stale lower mips. The 2D default has no chain, so
+    // the common per-frame canvas/video upload skips the cost.
+    if (runtime.mipmappedTextures?.has(texture))
+        gl.generateMipmap(gl.TEXTURE_2D);
 }
 export function useGlProgram(state, shader) {
     const runtime = getGlRenderStateRuntime(state);
@@ -135,15 +206,144 @@ export function useGlProgram(state, shader) {
         runtime.currentProgram = program;
     }
 }
+// Uploads an ImageResource into the currently-bound texture for the 2D display pipeline. The element
+// fast-path premultiplies via UNPACK_PREMULTIPLY_ALPHA_WEBGL (straight-alpha element under a premultiplied
+// (ONE, ONE_MINUS_SRC_ALPHA) blend would otherwise blow a 40%-white shape to opaque white). That flag is
+// ignored for raw-data (ArrayBufferView) uploads, so straight-alpha `data` is premultiplied on the CPU
+// first; opaque data (alpha 255, e.g. a normal/roughness map) premultiplies to itself, so this is a no-op
+// there. The data path is what makes a memory-generated Surface a first-class 2D texture. A resource that
+// carries only a block-`compressed` payload (no element or data) uploads through the GPU-native compressed
+// path — falling back to the state's registered RGBA decoder when the device lacks the block format.
+function uploadGlDisplayTexture(state, image) {
+    const gl = state.gl;
+    if (image.source !== null) {
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+        uploadGlTextureElement(gl, gl.TEXTURE_2D, image.source);
+        return;
+    }
+    if (image.data === null && image.compressed !== null) {
+        // The compressed-container upload path is an opt-in seam (registerGlCompressedTextureUpload), so a
+        // state that only draws element/data bitmaps never carries its ~40-format enum table. When unset,
+        // skip rather than upload garbage — the texture stays empty until an uploader is registered.
+        const runtime = getGlRenderStateRuntime(state);
+        runtime.compressedTextureUpload?.(gl, image, runtime.compressedTextureDecoder ?? null);
+        return;
+    }
+    const data = image.alphaType === 'straight' ? premultiplyStraightRgba8(image.data) : image.data;
+    uploadGlTextureData(gl, gl.TEXTURE_2D, image.width, image.height, data);
+}
+// Returns a new premultiplied rgba8 buffer from a straight-alpha one (rgb *= a/255). Allocates, but runs
+// only on a texture upload (cache miss or content change), never in the per-frame draw path.
+function premultiplyStraightRgba8(data) {
+    const out = new Uint8ClampedArray(data.length);
+    for (let i = 0; i < data.length; i += 4) {
+        const a = data[i + 3];
+        out[i] = (data[i] * a) / 255;
+        out[i + 1] = (data[i + 1] * a) / 255;
+        out[i + 2] = (data[i + 2] * a) / 255;
+        out[i + 3] = a;
+    }
+    return out;
+}
+// Applies a sampler's wrap, filtering, anisotropy, and mip chain to the currently-bound TEXTURE_2D.
+// Without a sampler it falls back to the state's allowSmoothing flag with clamp-to-edge and no mips —
+// the 2D bitmap/sprite default. With one, every field comes from the descriptor. The mip chain is
+// generated once per texture (tracked in runtime.mipmappedTextures) the first time a mip-sampling
+// filter asks for it, so a shared texture first bound without mips and later with them still generates
+// its chain. Filtering and wrap are set every bind (cheap) so a texture shared across samplers follows
+// the current draw; only the one-time mip generation is gated.
+function applyGlSamplerState(state, runtime, texture, sampler) {
+    const gl = state.gl;
+    if (!sampler) {
+        const filter = state.allowSmoothing ? gl.LINEAR : gl.NEAREST;
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        return;
+    }
+    const useMips = sampler.mipmaps && isGlMipmapFilter(sampler.minFilter);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, glMinFilterValue(gl, sampler.minFilter, useMips));
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, glMagFilterValue(gl, sampler.magFilter));
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, glTextureWrapValue(gl, sampler.wrapU));
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, glTextureWrapValue(gl, sampler.wrapV));
+    const ext = ensureGlAnisotropyExt(state, runtime);
+    if (ext) {
+        // Clamp the requested level to [1, hardware max]; 1 disables anisotropy and also resets a texture
+        // that a previous anisotropic sampler left elevated.
+        const level = Math.max(1, Math.min(sampler.anisotropy, runtime.maxAnisotropy ?? 1));
+        gl.texParameterf(gl.TEXTURE_2D, ext.TEXTURE_MAX_ANISOTROPY_EXT, level);
+    }
+    if (useMips) {
+        const mipped = (runtime.mipmappedTextures ??= new WeakSet());
+        if (!mipped.has(texture)) {
+            gl.generateMipmap(gl.TEXTURE_2D);
+            mipped.add(texture);
+        }
+    }
+}
+// Resolves and caches EXT_texture_filter_anisotropic on the runtime: anisotropyExt is undefined until
+// first queried, then the extension object or null when unsupported, and maxAnisotropy caches the
+// hardware cap. Returns null when anisotropic filtering is unavailable.
+function ensureGlAnisotropyExt(state, runtime) {
+    let ext = runtime.anisotropyExt;
+    if (ext === undefined) {
+        ext = state.gl.getExtension('EXT_texture_filter_anisotropic');
+        runtime.anisotropyExt = ext;
+        runtime.maxAnisotropy = ext ? state.gl.getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1;
+    }
+    return ext;
+}
+// Maps a magnification TextureFilter to its WebGL2 constant. Magnification never samples mips, so the
+// mip-variant names collapse to their base LINEAR/NEAREST.
+function glMagFilterValue(gl, filter) {
+    return filter.startsWith('nearest') ? gl.NEAREST : gl.LINEAR;
+}
+// Maps a minification TextureFilter to its WebGL2 constant. When useMips is false (mipmaps disabled or
+// a non-mip filter) the mip-variant names collapse to their base LINEAR/NEAREST, so a filter that
+// names a mip level never selects an absent chain (which would render the texture black).
+function glMinFilterValue(gl, filter, useMips) {
+    if (!useMips)
+        return filter.startsWith('nearest') ? gl.NEAREST : gl.LINEAR;
+    switch (filter) {
+        case 'linear-mipmap-linear':
+            return gl.LINEAR_MIPMAP_LINEAR;
+        case 'linear-mipmap-nearest':
+            return gl.LINEAR_MIPMAP_NEAREST;
+        case 'nearest-mipmap-linear':
+            return gl.NEAREST_MIPMAP_LINEAR;
+        case 'nearest-mipmap-nearest':
+            return gl.NEAREST_MIPMAP_NEAREST;
+        case 'nearest':
+            return gl.NEAREST;
+        default:
+            return gl.LINEAR;
+    }
+}
+// True for the mip-sampling minification filters; the two non-mip modes ('linear'/'nearest') sample
+// only the base level and need no mip chain.
+function isGlMipmapFilter(filter) {
+    return filter !== 'linear' && filter !== 'nearest';
+}
+// Maps a sampler wrap mode to its WebGL2 texture-wrap constant; clamp-to-edge is the fallback. REPEAT
+// tiles the sampled uv, which is what makes setTextureUvScale / a repeat sampler actually tile.
+function glTextureWrapValue(gl, wrap) {
+    if (wrap === 'repeat')
+        return gl.REPEAT;
+    if (wrap === 'mirror-repeat')
+        return gl.MIRRORED_REPEAT;
+    return gl.CLAMP_TO_EDGE;
+}
 const NORMAL_BLEND = { src: 'ONE', dst: 'ONE_MINUS_SRC_ALPHA' };
 // The built-in blend modes registerDefaultGlBlendModes installs, each with its fixed-function
-// realization. Overlay/HardLight/Difference/Invert are deliberately absent — they have no
-// fixed-function equivalent and need a shader pass.
+// realization — the cheap fixed-function set. The Porter-Duff coverage operators (Erase/Alpha/None/…) are
+// a CompositeEffect, the destination-reading blends (Overlay/HardLight/…) a BlendEffect, and rare
+// equations like Subtract are wired on demand via registerGlBlendMode — none belong in the node-property
+// set. Darken/Lighten are exact only for an opaque backdrop (MIN/MAX cannot carry the coverage-restore
+// term); realize them as a BlendEffect for transparent-edge correctness.
 const DEFAULT_GL_BLEND_MODES = [
     [BlendMode.Add, { src: 'ONE', dst: 'ONE' }],
     [BlendMode.Darken, { src: 'ONE', dst: 'ONE', equation: 'MIN' }],
-    [BlendMode.Erase, { src: 'ZERO', dst: 'ONE_MINUS_SRC_ALPHA' }],
-    [BlendMode.Layer, NORMAL_BLEND],
     [BlendMode.Lighten, { src: 'ONE', dst: 'ONE', equation: 'MAX' }],
     // Premultiplied multiply: result = src.rgb*dst + dst*(1-src.a). The (1-src.a) term restores the
     // destination where the source is transparent or partially covered (antialiased edges, the quad's
@@ -151,12 +351,7 @@ const DEFAULT_GL_BLEND_MODES = [
     // toward black — the straight-alpha (DST_COLOR, ZERO) form fringes there because this pipeline
     // uploads and shades premultiplied. Exact for an opaque backdrop.
     [BlendMode.Multiply, { src: 'DST_COLOR', dst: 'ONE_MINUS_SRC_ALPHA' }],
-    // No blending: result = src (the premultiplied source replaces the destination). For opaque
-    // content this matches Normal; unlike Normal it does not composite, so semi-transparent source
-    // pixels overwrite the backdrop instead of blending over it.
-    [BlendMode.None, { src: 'ONE', dst: 'ZERO' }],
     [BlendMode.Normal, NORMAL_BLEND],
     [BlendMode.Screen, { src: 'ONE', dst: 'ONE_MINUS_SRC_COLOR' }],
-    [BlendMode.Subtract, { src: 'ONE', dst: 'ONE', equation: 'FUNC_REVERSE_SUBTRACT' }],
 ];
 //# sourceMappingURL=glDraw.js.map