@ringozz/godot 4.7.2-614 → 4.7.2-616

package/src/runtime.ts

@@ -1,107 +1,107 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-/** Shared runtime: platform-specific native-module selection lives in
- *  `boot.ts` (desktop) / `boot.browser.ts` (web, via the `exports` `./boot`
- *  entry's `browser` condition). `_mod` is the native module — the desktop
- *  addon's `module.exports` or the wasm module's `.default`.
- *
- *  The boot leaf is imported by **package self-reference** (`@ringozz/godot/boot`),
- *  not by relative path: a bare specifier resolves through this package's own
- *  `exports` map (whose `./boot` entry's `browser` condition selects
- *  `boot.browser.ts` on web) exactly like the entrypoint's
- *  `import { preloadGodot } from '@ringozz/godot/boot'`, so both sides land on the
- *  same absolute path and share ONE `boot.browser.ts` module instance. (A relative
- *  `./boot.ts` import would let a consumer's bundler realpath it into
- *  `node_modules/.bun/...` while the entrypoint keeps the `node_modules/@ringozz/godot`
- *  path — two instances, and the preload handoff below would read `null`.)
- */
-import { getNativeModule } from '@ringozz/godot/boot';
-const { default: _mod } = getNativeModule() as any;
-
-/** Godot instance */
-import type { GodotInstance } from '../gen/classes/GodotInstance.ts';
-export const getGodot = _mod.getGodot as () => GodotInstance;
-
-/** Base constructor for all Godot object wrappers. */
-export interface GodotVar {
-    free(): void;
-}
-export const GodotVar = _mod.GodotVar as (new (...args: unknown[]) => GodotVar) & {
-    assign<T extends GodotVar>(target: T, props: Record<string, unknown>): T;
-};
-
-/** Unified entry point:
- *  - _C(this,    methodId, ...args)    → instance method
- *  - _C(classId, methodId, ...args)    → static method
- *  - _C(null,    methodId, ...args)    → singleton lookup (_getInstance) or internal
- *  - _C(0n,      methodId, ...args)    → utility function (BigInt tags the call;
- *                                         arg types resolve by name at runtime)
- */
-export const _C = _mod._C as (...args: unknown[]) => unknown;
-
-/** Resolve a string name to its integer handle. */
-export const _S = _mod._S as (name: string) => number;
-
-/** Register Godot object wrapper. */
-export const _R = _mod._R as (typeId: number, ctor: Function) => string;
-
-/**
- * Value-type dispatch on tuple receivers: `_V(typeId, methodId, receiver, ...args)`.
- * `methodId == SX_valueCtor` constructs (`_V(typeId, ctorSentinel, ctorIndex, ...args)`),
- * negative ids are operators, non-negative ids are builtin methods.
- */
-export const _V = _mod._V as (...args: unknown[]) => unknown;
-
-/**
- * Build a typed value-type Variant for a Variant-typed slot by resolving the
- * property's type from the node; returns a GodotVar carrier the consuming `_C`
- * unwraps. Used by react-hooks' useTween (tweenProperty final_val).
- */
-export const toValueType = _mod.toValueType as (node: GodotVar, propName: string, value: unknown) => unknown;
-
-/** Stage bytes into the web MEMFS (Godot's `copyToFS`); undefined on desktop. */
-export const stageFile = (_mod as any).stageFile as ((path: string, bytes: Uint8Array) => void) | undefined;
-
-/** Get a Signal value from an Object by signal name, or connect a callback when 3rd arg given. */
-export const _G = _mod._G as (target: GodotVar, signalNameId: number, callback?: unknown) => unknown;
-
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/requestAnimationFrame) */
-export const requestAnimationFrame = _mod.requestAnimationFrame as typeof globalThis.requestAnimationFrame ?? globalThis.requestAnimationFrame;
-
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/cancelAnimationFrame) */
-export const cancelAnimationFrame = _mod.cancelAnimationFrame as typeof globalThis.cancelAnimationFrame ?? globalThis.cancelAnimationFrame;
-
-// One-shot callbacks of in-flight `_P` awaits. The connection's JSCallable holds
-// only a weak reference to the callback, so without this the function could be
-// GC'd before the signal fires. A module root is the only retention Bun reliably
-// traces: neither `_P`'s closure cells nor a Set attached to the signal's object
-// wrapper survive a full GC while the await is pending (the await machinery
-// discards the promise `_P` returns, and Bun may collect the emitter's wrapper).
-// Removed as soon as the signal fires or the connect fails.
-const pendingCallbacks = new Set<(...args: any[]) => void>();
-
-/** Make a Signal PromiseLike: connects a one-shot callback that resolves with the args tuple. */
-export function _P(signal: any, onfulfilled?: any, onrejected?: any) {
-    return new Promise<any>((resolve, reject) => {
-        if (signal.isNull()) {
-            reject(new Error('Cannot await a null Signal'));
-            return;
-        }
-        const cb = (...args: any[]) => {
-            pendingCallbacks.delete(cb);
-            signal.disconnect(cb);
-            resolve(args);
-        };
-        pendingCallbacks.add(cb);
-        const res = signal.connect(cb);
-        if (res !== 0) {
-            pendingCallbacks.delete(cb);
-            reject(new Error('Failed to connect signal: error code ' + res));
-        }
-    }).then(onfulfilled, onrejected);
-}
-
-/** Cleanup callbacks run once by `runGodot` just before the engine is freed; may be async. */
-export const cleanupHooks: Set<() => void | Promise<void>> = new Set();
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+/** Shared runtime: platform-specific native-module selection lives in
+ *  `boot.ts` (desktop) / `boot.browser.ts` (web, via the `exports` `./boot`
+ *  entry's `browser` condition). `_mod` is the native module — the desktop
+ *  addon's `module.exports` or the wasm module's `.default`.
+ *
+ *  The boot leaf is imported by **package self-reference** (`@ringozz/godot/boot`),
+ *  not by relative path: a bare specifier resolves through this package's own
+ *  `exports` map (whose `./boot` entry's `browser` condition selects
+ *  `boot.browser.ts` on web) exactly like the entrypoint's
+ *  `import { preloadGodot } from '@ringozz/godot/boot'`, so both sides land on the
+ *  same absolute path and share ONE `boot.browser.ts` module instance. (A relative
+ *  `./boot.ts` import would let a consumer's bundler realpath it into
+ *  `node_modules/.bun/...` while the entrypoint keeps the `node_modules/@ringozz/godot`
+ *  path — two instances, and the preload handoff below would read `null`.)
+ */
+import { getNativeModule } from '@ringozz/godot/boot';
+const { default: _mod } = getNativeModule() as any;
+
+/** Godot instance */
+import type { GodotInstance } from '../gen/classes/GodotInstance.ts';
+export const getGodot = _mod.getGodot as () => GodotInstance;
+
+/** Base constructor for all Godot object wrappers. */
+export interface GodotVar {
+    free(): void;
+}
+export const GodotVar = _mod.GodotVar as (new (...args: unknown[]) => GodotVar) & {
+    assign<T extends GodotVar>(target: T, props: Record<string, unknown>): T;
+};
+
+/** Unified entry point:
+ *  - _C(this,    methodId, ...args)    → instance method
+ *  - _C(classId, methodId, ...args)    → static method
+ *  - _C(null,    methodId, ...args)    → singleton lookup (_getInstance) or internal
+ *  - _C(0n,      methodId, ...args)    → utility function (BigInt tags the call;
+ *                                         arg types resolve by name at runtime)
+ */
+export const _C = _mod._C as (...args: unknown[]) => unknown;
+
+/** Resolve a string name to its integer handle. */
+export const _S = _mod._S as (name: string) => number;
+
+/** Register Godot object wrapper. */
+export const _R = _mod._R as (typeId: number, ctor: Function) => string;
+
+/**
+ * Value-type dispatch on tuple receivers: `_V(typeId, methodId, receiver, ...args)`.
+ * `methodId == SX_valueCtor` constructs (`_V(typeId, ctorSentinel, ctorIndex, ...args)`),
+ * negative ids are operators, non-negative ids are builtin methods.
+ */
+export const _V = _mod._V as (...args: unknown[]) => unknown;
+
+/**
+ * Build a typed value-type Variant for a Variant-typed slot by resolving the
+ * property's type from the node; returns a GodotVar carrier the consuming `_C`
+ * unwraps. Used by react-hooks' useTween (tweenProperty final_val).
+ */
+export const toValueType = _mod.toValueType as (node: GodotVar, propName: string, value: unknown) => unknown;
+
+/** Stage bytes into the web MEMFS (Godot's `copyToFS`); undefined on desktop. */
+export const stageFile = (_mod as any).stageFile as ((path: string, bytes: Uint8Array) => void) | undefined;
+
+/** Get a Signal value from an Object by signal name, or connect a callback when 3rd arg given. */
+export const _G = _mod._G as (target: GodotVar, signalNameId: number, callback?: unknown) => unknown;
+
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/requestAnimationFrame) */
+export const requestAnimationFrame = _mod.requestAnimationFrame as typeof globalThis.requestAnimationFrame ?? globalThis.requestAnimationFrame;
+
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/cancelAnimationFrame) */
+export const cancelAnimationFrame = _mod.cancelAnimationFrame as typeof globalThis.cancelAnimationFrame ?? globalThis.cancelAnimationFrame;
+
+// One-shot callbacks of in-flight `_P` awaits. The connection's JSCallable holds
+// only a weak reference to the callback, so without this the function could be
+// GC'd before the signal fires. A module root is the only retention Bun reliably
+// traces: neither `_P`'s closure cells nor a Set attached to the signal's object
+// wrapper survive a full GC while the await is pending (the await machinery
+// discards the promise `_P` returns, and Bun may collect the emitter's wrapper).
+// Removed as soon as the signal fires or the connect fails.
+const pendingCallbacks = new Set<(...args: any[]) => void>();
+
+/** Make a Signal PromiseLike: connects a one-shot callback that resolves with the args tuple. */
+export function _P(signal: any, onfulfilled?: any, onrejected?: any) {
+    return new Promise<any>((resolve, reject) => {
+        if (signal.isNull()) {
+            reject(new Error('Cannot await a null Signal'));
+            return;
+        }
+        const cb = (...args: any[]) => {
+            pendingCallbacks.delete(cb);
+            signal.disconnect(cb);
+            resolve(args);
+        };
+        pendingCallbacks.add(cb);
+        const res = signal.connect(cb);
+        if (res !== 0) {
+            pendingCallbacks.delete(cb);
+            reject(new Error('Failed to connect signal: error code ' + res));
+        }
+    }).then(onfulfilled, onrejected);
+}
+
+/** Cleanup callbacks run once by `runGodot` just before the engine is freed; may be async. */
+export const cleanupHooks: Set<() => void | Promise<void>> = new Set();

package/src/web-image.ts

@@ -1,117 +1,153 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-// Web-only: decode the embedded PNG/WebP blobs of a `.ctex` CompressedTexture2D
-// container with the browser's `createImageBitmap`, and rebuild the container as
-// a raw RGBA8 `DATA_FORMAT_IMAGE` ctex — so no image codec runs in wasm on web.
-// Anything that isn't a PNG/WebP-embedded ctex is returned unchanged.
-
-const CTEX_MAGIC = 'GST2';
-const DATA_FORMAT_IMAGE = 0;
-const DATA_FORMAT_PNG = 1;
-const DATA_FORMAT_WEBP = 2;
-const FORMAT_RGBA8 = 5;
-const FORMAT_BIT_STREAM = 1 << 22;
-
-// Outer header: magic(4) version(4) w(4) h(4) df(4) mipmap_limit(4) reserved(12).
-const OUTER_HEADER_SIZE = 36;
-// Sub-header: data_format(4) w(2) h(2) mipmaps(4) format(4).
-const SUB_HEADER_OFFSET = OUTER_HEADER_SIZE;
-const SUB_HEADER_SIZE = 16;
-const BLOB_TABLE_OFFSET = SUB_HEADER_OFFSET + SUB_HEADER_SIZE;
-
-interface DecodedBitmap {
-	width: number;
-	height: number;
-	data: Uint8Array;
-}
-
-async function decodeWebBitmap(blob: Uint8Array<ArrayBuffer>, type: string): Promise<DecodedBitmap> {
-	const bmp = await createImageBitmap(new Blob([blob], { type }), {
-		colorSpaceConversion: 'none',
-		premultiplyAlpha: 'none',
-	});
-	try {
-		const canvas = new OffscreenCanvas(bmp.width, bmp.height);
-		const ctx = canvas.getContext('2d', { colorSpace: 'srgb', willReadFrequently: true }) as
-			| OffscreenCanvasRenderingContext2D
-			| null;
-		if (!ctx) {
-			throw new Error('web-image: no 2d context for OffscreenCanvas');
-		}
-		ctx.drawImage(bmp, 0, 0);
-		const img = ctx.getImageData(0, 0, bmp.width, bmp.height);
-		return { width: bmp.width, height: bmp.height, data: new Uint8Array(img.data.buffer, img.data.byteOffset, img.data.byteLength) };
-	} finally {
-		bmp.close();
-	}
-}
-
-/**
- * Decodes the embedded PNG/WebP blobs of a `.ctex` file with the browser's
- * `createImageBitmap` and rebuilds it as a raw RGBA8 (`DATA_FORMAT_IMAGE`)
- * container. Non-ctex bytes, streamable textures, and `DATA_FORMAT_IMAGE` /
- * `DATA_FORMAT_BASIS_UNIVERSAL` containers are returned unchanged. Throws if an
- * embedded blob can't be decoded or its dimensions don't match the expected
- * mipmap layout, so a would-be undecodable texture fails loudly at materialize
- * time. A no-op outside browsers (no `createImageBitmap`).
- */
-export async function decodeCtex(bytes: Uint8Array): Promise<Uint8Array> {
-	if (
-		typeof createImageBitmap !== 'function' ||
-		bytes.length < SUB_HEADER_OFFSET + SUB_HEADER_SIZE ||
-		String.fromCharCode(...bytes.subarray(0, 4)) !== CTEX_MAGIC
-	) {
-		return bytes;
-	}
-	const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	if (dv.getUint32(16, true) & FORMAT_BIT_STREAM) {
-		return bytes; // streamable layout differs; leave it to the engine
-	}
-	const dataFormat = dv.getUint32(SUB_HEADER_OFFSET, true);
-	if (dataFormat !== DATA_FORMAT_PNG && dataFormat !== DATA_FORMAT_WEBP) {
-		return bytes; // raw and BASIS_UNIVERSAL containers pass through
-	}
-	const w = dv.getUint16(SUB_HEADER_OFFSET + 4, true);
-	const h = dv.getUint16(SUB_HEADER_OFFSET + 6, true);
-	const mipmaps = dv.getUint32(SUB_HEADER_OFFSET + 8, true);
-	const type = dataFormat === DATA_FORMAT_WEBP ? 'image/webp' : 'image/png';
-
-	let ofs = BLOB_TABLE_OFFSET;
-	const levels: Uint8Array[] = [];
-	for (let i = 0; i <= mipmaps; i++) {
-		if (ofs + 4 > bytes.length) {
-			throw new Error(`web-image: truncated ctex at mipmap ${i}`);
-		}
-		const size = dv.getUint32(ofs, true);
-		ofs += 4;
-		if (ofs + size > bytes.length) {
-			throw new Error(`web-image: truncated ctex blob at mipmap ${i}`);
-		}
-		const bmp = await decodeWebBitmap(bytes.slice(ofs, ofs + size), type);
-		ofs += size;
-		const ew = Math.max(w >> i, 1);
-		const eh = Math.max(h >> i, 1);
-		if (bmp.width !== ew || bmp.height !== eh) {
-			throw new Error(`web-image: mipmap ${i} decoded as ${bmp.width}x${bmp.height}, expected ${ew}x${eh}`);
-		}
-		levels.push(bmp.data);
-	}
-
-	const dataSize = levels.reduce((n, level) => n + level.length, 0);
-	const out = new Uint8Array(BLOB_TABLE_OFFSET + dataSize);
-	out.set(bytes.subarray(0, OUTER_HEADER_SIZE)); // outer header verbatim
-	const odv = new DataView(out.buffer);
-	odv.setUint32(SUB_HEADER_OFFSET, DATA_FORMAT_IMAGE, true);
-	odv.setUint16(SUB_HEADER_OFFSET + 4, w, true);
-	odv.setUint16(SUB_HEADER_OFFSET + 6, h, true);
-	odv.setUint32(SUB_HEADER_OFFSET + 8, mipmaps, true);
-	odv.setUint32(SUB_HEADER_OFFSET + 12, FORMAT_RGBA8, true);
-	let p = BLOB_TABLE_OFFSET;
-	for (const level of levels) {
-		out.set(level, p);
-		p += level.length;
-	}
-	return out;
-}
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+// Web-only: decode the embedded PNG/WebP blobs of a `.ctex` CompressedTexture2D
+// container with the browser's `createImageBitmap`, and rebuild the container as
+// a raw RGBA8 `DATA_FORMAT_IMAGE` ctex — so no image codec runs in wasm on web.
+// Anything that isn't a PNG/WebP-embedded ctex is returned unchanged.
+//
+// The mipmap blobs are codec-decoded **concurrently** (Promise.all), then
+// rasterized serially into one reused OffscreenCanvas, so wall time is dominated
+// by the full-res level's decode instead of the serial sum of every level.
+
+const CTEX_MAGIC = 'GST2';
+const DATA_FORMAT_IMAGE = 0;
+const DATA_FORMAT_PNG = 1;
+const DATA_FORMAT_WEBP = 2;
+const FORMAT_RGBA8 = 5;
+const FORMAT_BIT_STREAM = 1 << 22;
+
+// Outer header: magic(4) version(4) w(4) h(4) df(4) mipmap_limit(4) reserved(12).
+const OUTER_HEADER_SIZE = 36;
+// Sub-header: data_format(4) w(2) h(2) mipmaps(4) format(4).
+const SUB_HEADER_OFFSET = OUTER_HEADER_SIZE;
+const SUB_HEADER_SIZE = 16;
+const BLOB_TABLE_OFFSET = SUB_HEADER_OFFSET + SUB_HEADER_SIZE;
+
+// One encoded mipmap's byte range inside the container, plus the RGBA
+// dimensions its decoded pixels must have (`w>>i` clamped to 1).
+interface MipEntry {
+	offset: number;
+	size: number;
+	width: number;
+	height: number;
+}
+
+function decodeBitmap(blob: Uint8Array<ArrayBuffer>, type: string): Promise<ImageBitmap> {
+	return createImageBitmap(new Blob([blob], { type }), {
+		colorSpaceConversion: 'none',
+		premultiplyAlpha: 'none',
+	});
+}
+
+// Rasterizes an ImageBitmap into a raw RGBA8 buffer, drawing into the caller's
+// shared canvas (resized per level) so one canvas serves every mipmap.
+function rasterize(canvas: OffscreenCanvas, bmp: ImageBitmap): Uint8Array {
+	const ctx = canvas.getContext('2d', { colorSpace: 'srgb', willReadFrequently: true }) as
+		| OffscreenCanvasRenderingContext2D
+		| null;
+	if (!ctx) {
+		throw new Error('web-image: no 2d context for OffscreenCanvas');
+	}
+	canvas.width = bmp.width;
+	canvas.height = bmp.height;
+	ctx.drawImage(bmp, 0, 0);
+	const img = ctx.getImageData(0, 0, bmp.width, bmp.height);
+	return new Uint8Array(img.data.buffer, img.data.byteOffset, img.data.byteLength);
+}
+
+/**
+ * Decodes the embedded PNG/WebP blobs of a `.ctex` file with the browser's
+ * `createImageBitmap` and rebuilds it as a raw RGBA8 (`DATA_FORMAT_IMAGE`)
+ * container. Non-ctex bytes, streamable textures, and `DATA_FORMAT_IMAGE` /
+ * `DATA_FORMAT_BASIS_UNIVERSAL` containers are returned unchanged. Throws if an
+ * embedded blob can't be decoded or its dimensions don't match the expected
+ * mipmap layout, so a would-be undecodable texture fails loudly at materialize
+ * time. A no-op outside browsers (no `createImageBitmap`). Mip levels are
+ * decoded concurrently; the returned container's pixel data is ordered largest
+ * to smallest, matching the input blob table.
+ */
+export async function decodeCtex(bytes: Uint8Array): Promise<Uint8Array> {
+	if (
+		typeof createImageBitmap !== 'function' ||
+		bytes.length < SUB_HEADER_OFFSET + SUB_HEADER_SIZE ||
+		String.fromCharCode(...bytes.subarray(0, 4)) !== CTEX_MAGIC
+	) {
+		return bytes;
+	}
+	const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (dv.getUint32(16, true) & FORMAT_BIT_STREAM) {
+		return bytes; // streamable layout differs; leave it to the engine
+	}
+	const dataFormat = dv.getUint32(SUB_HEADER_OFFSET, true);
+	if (dataFormat !== DATA_FORMAT_PNG && dataFormat !== DATA_FORMAT_WEBP) {
+		return bytes; // raw and BASIS_UNIVERSAL containers pass through
+	}
+	const w = dv.getUint16(SUB_HEADER_OFFSET + 4, true);
+	const h = dv.getUint16(SUB_HEADER_OFFSET + 6, true);
+	const mipmaps = dv.getUint32(SUB_HEADER_OFFSET + 8, true);
+	const type = dataFormat === DATA_FORMAT_WEBP ? 'image/webp' : 'image/png';
+
+	// Phase 1: bounds-check the blob table so every level's byte range is known
+	// before any decode starts (a malformed container fails fast, no decode).
+	const mips: MipEntry[] = [];
+	let ofs = BLOB_TABLE_OFFSET;
+	for (let i = 0; i <= mipmaps; i++) {
+		if (ofs + 4 > bytes.length) {
+			throw new Error(`web-image: truncated ctex at mipmap ${i}`);
+		}
+		const size = dv.getUint32(ofs, true);
+		ofs += 4;
+		if (ofs + size > bytes.length) {
+			throw new Error(`web-image: truncated ctex blob at mipmap ${i}`);
+		}
+		mips.push({ offset: ofs, size, width: Math.max(w >> i, 1), height: Math.max(h >> i, 1) });
+		ofs += size;
+	}
+
+	// Phase 2: codec-decode all levels concurrently — the dominant cost now
+	// overlaps instead of summing. Views (not copies) go into the Blob, which
+	// materializes them once.
+	// `decodeBitmap` feeds the Blob ctor, which needs an ArrayBuffer-backed view.
+	const bitmaps = await Promise.all(
+		mips.map((m) => decodeBitmap(bytes.subarray(m.offset, m.offset + m.size) as Uint8Array<ArrayBuffer>, type)),
+	);
+
+	// Phase 3: validate dimensions and rasterize serially into one shared
+	// canvas; close() on an already-closed bitmap is a no-op, so a throw
+	// mid-loop still releases every bitmap via the finally.
+	const levels: Uint8Array[] = new Array(mips.length);
+	const canvas = new OffscreenCanvas(w, h);
+	try {
+		for (let i = 0; i < mips.length; i++) {
+			const bmp = bitmaps[i];
+			if (bmp.width !== mips[i].width || bmp.height !== mips[i].height) {
+				throw new Error(
+					`web-image: mipmap ${i} decoded as ${bmp.width}x${bmp.height}, expected ${mips[i].width}x${mips[i].height}`,
+				);
+			}
+			levels[i] = rasterize(canvas, bmp);
+		}
+	} finally {
+		for (const bmp of bitmaps) {
+			bmp.close();
+		}
+	}
+
+	const dataSize = levels.reduce((n, level) => n + level.length, 0);
+	const out = new Uint8Array(BLOB_TABLE_OFFSET + dataSize);
+	out.set(bytes.subarray(0, OUTER_HEADER_SIZE)); // outer header verbatim
+	const odv = new DataView(out.buffer);
+	odv.setUint32(SUB_HEADER_OFFSET, DATA_FORMAT_IMAGE, true);
+	odv.setUint16(SUB_HEADER_OFFSET + 4, w, true);
+	odv.setUint16(SUB_HEADER_OFFSET + 6, h, true);
+	odv.setUint32(SUB_HEADER_OFFSET + 8, mipmaps, true);
+	odv.setUint32(SUB_HEADER_OFFSET + 12, FORMAT_RGBA8, true);
+	let p = BLOB_TABLE_OFFSET;
+	for (const level of levels) {
+		out.set(level, p);
+		p += level.length;
+	}
+	return out;
+}