@woosh/meep-engine 3.14.2 → 3.14.3

package/src/shade/renderer/loader/usd/load_usd.js

@@ -19,10 +19,10 @@
  */
 
 import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
-import { parse_usda } from "./parse_usda.js";
-import { unpack_usdz } from "./unpack_usdz.js";
+import { parse_usda } from "../../../../format/scene/usd/parse_usda.js";
+import { unpack_usdz } from "../../../../format/scene/usd/unpack_usdz.js";
 import { usd_build_scene } from "./usd_build_scene.js";
-import { UsdParseError, UsdUnsupportedError } from "./UsdError.js";
+import { UsdParseError, UsdUnsupportedError } from "../../../../format/scene/usd/UsdError.js";
 import { defaultExtensionRegistry, UsdExtensionRegistry } from "./UsdExtensionRegistry.js";
 
 

package/src/shade/renderer/loader/usd/usd_build_scene.js

@@ -28,8 +28,8 @@ import { StandardShadeMaterial } from "../../material/StandardShadeMaterial.js";
 import { TransparencyMode } from "../../material/TransparencyMode.js";
 import { Mesh } from "../../scene/Mesh.js";
 import { Node3D } from "../../scene/Node3D.js";
-import { usd_compose_transform } from "./usd_compose_transform.js";
-import { usd_expand_face_varying, usd_triangulate } from "./usd_triangulate.js";
+import { usd_compose_transform } from "../../../../format/scene/usd/usd_compose_transform.js";
+import { usd_expand_face_varying, usd_triangulate } from "../../../../format/scene/usd/usd_triangulate.js";
 
 
 /**

package/src/shade/renderer/loader/usd/usd_decode_image.d.ts

@@ -9,15 +9,16 @@ export function decode_data_url(url: string): {
     data: Uint8Array;
 };
 /**
- * Decode a minimal PNG to raw RGBA pixels.
+ * Decode a PNG to 8-bit RGBA pixels.
  *
- * Supports: 8-bit RGB or RGBA, non-interlaced, single IDAT chunk.
- * This is sufficient for embedded USD texture assets (typically simple textures).
+ * Accepts anything `PNGReader` accepts; see the module comment for what that covers and how
+ * other layouts are brought to RGBA8. Errors from the reader (bad signature, truncated stream,
+ * corrupt deflate payload) propagate as thrown.
  *
- * @param {Uint8Array} png_bytes
+ * @param {Uint8Array|ArrayBuffer} png_bytes
  * @returns {{ width: number, height: number, channels: number, pixels: Uint8Array }}
  */
-export function decode_png(png_bytes: Uint8Array): {
+export function decode_png(png_bytes: Uint8Array | ArrayBuffer): {
     width: number;
     height: number;
     channels: number;

package/src/shade/renderer/loader/usd/usd_decode_image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usd_decode_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_decode_image.js"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,qCAHW,MAAM;cACQ,MAAM;UAAQ,UAAU;EAgChD;AASD;;;;;;;;GAQG;AACH,sCAHW,UAAU;WACC,MAAM;YAAU,MAAM;cAAY,MAAM;YAAU,UAAU;EAmHjF;AAGD;;;;;GAKG;AACH,2DAHW;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GACrE,YAAY,CAexB;6BAjM4B,+BAA+B"}
+{"version":3,"file":"usd_decode_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_decode_image.js"],"names":[],"mappings":"AA4BA;;;;;GAKG;AACH,qCAHW,MAAM;cACQ,MAAM;UAAQ,UAAU;EAgChD;AAGD;;;;;;;;;GASG;AACH,sCAHW,UAAU,GAAC,WAAW;WACX,MAAM;YAAU,MAAM;cAAY,MAAM;YAAU,UAAU;EA0DjF;AAGD;;;;;GAKG;AACH,2DAHW;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GACrE,YAAY,CAexB;6BAnI4B,+BAA+B"}

package/src/shade/renderer/loader/usd/usd_decode_image.js

@@ -1,384 +1,197 @@
-/**
- * Minimal image decoding for USD texture resolution.
- *
- * Supports:
- * - Data URL decoding (base64 → raw bytes)
- * - Minimal PNG decoding (8-bit RGB/RGBA, non-interlaced)
- *
- * This is intentionally minimal — handles the subset needed for
- * UsdUVTexture asset resolution in both browser and Node.js environments.
- *
- * @module usd_decode_image
- */
-
-import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
-import { ShadeTexture } from "../../texture/ShadeTexture.js";
-import { ShadeImage } from "../../texture/source/ShadeImage.js";
-
-
-/**
- * Decode a data URL into raw bytes.
- *
- * @param {string} url - Data URL (e.g. "data:image/png;base64,...")
- * @returns {{ mimeType: string, data: Uint8Array } | null}
- */
-export function decode_data_url(url) {
-
-    if (!url.startsWith("data:")) return null;
-
-    const comma_index = url.indexOf(",");
-
-    if (comma_index === -1) return null;
-
-    const header = url.slice(5, comma_index);
-    const body = url.slice(comma_index + 1);
-
-    const parts = header.split(";");
-    const mime_type = parts[0] || "application/octet-stream";
-    const is_base64 = parts.includes("base64");
-
-    let data;
-
-    if (is_base64) {
-        // Decode base64 — works in both Node.js and browser
-        const binary = atob(body);
-        data = new Uint8Array(binary.length);
-
-        for (let i = 0; i < binary.length; i++) {
-            data[i] = binary.charCodeAt(i);
-        }
-    } else {
-        data = new TextEncoder().encode(decodeURIComponent(body));
-    }
-
-    return { mimeType: mime_type, data };
-}
-
-
-// PNG constants
-const PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
-const PNG_COLOR_TYPE_RGB = 2;
-const PNG_COLOR_TYPE_RGBA = 6;
-
-
-/**
- * Decode a minimal PNG to raw RGBA pixels.
- *
- * Supports: 8-bit RGB or RGBA, non-interlaced, single IDAT chunk.
- * This is sufficient for embedded USD texture assets (typically simple textures).
- *
- * @param {Uint8Array} png_bytes
- * @returns {{ width: number, height: number, channels: number, pixels: Uint8Array }}
- */
-export function decode_png(png_bytes) {
-
-    // Verify PNG signature
-    for (let i = 0; i < 8; i++) {
-        if (png_bytes[i] !== PNG_SIGNATURE[i]) {
-            throw new Error("[USD] Invalid PNG signature");
-        }
-    }
-
-    // Read IHDR (first chunk after signature)
-    const ihdr_data_offset = 16; // 8 sig + 4 len + 4 type
-
-    const width = read_uint32_be(png_bytes, ihdr_data_offset);
-    const height = read_uint32_be(png_bytes, ihdr_data_offset + 4);
-    const bit_depth = png_bytes[ihdr_data_offset + 8];
-    const color_type = png_bytes[ihdr_data_offset + 9];
-    const interlace = png_bytes[ihdr_data_offset + 12];
-
-    if (bit_depth !== 8) {
-        throw new Error(`[USD] Unsupported PNG bit depth: ${bit_depth}`);
-    }
-
-    if (color_type !== PNG_COLOR_TYPE_RGB && color_type !== PNG_COLOR_TYPE_RGBA) {
-        throw new Error(`[USD] Unsupported PNG color type: ${color_type}`);
-    }
-
-    if (interlace !== 0) {
-        throw new Error("[USD] Interlaced PNGs not supported");
-    }
-
-    const channels = color_type === PNG_COLOR_TYPE_RGBA ? 4 : 3;
-
-    // Collect all IDAT chunk data
-    const idat_chunks = [];
-    let offset = 8; // skip signature
-
-    while (offset < png_bytes.length) {
-        const chunk_length = read_uint32_be(png_bytes, offset);
-        const chunk_type = String.fromCharCode(
-            png_bytes[offset + 4], png_bytes[offset + 5],
-            png_bytes[offset + 6], png_bytes[offset + 7]
-        );
-
-        if (chunk_type === "IDAT") {
-            idat_chunks.push(png_bytes.slice(offset + 8, offset + 8 + chunk_length));
-        }
-
-        if (chunk_type === "IEND") break;
-
-        // 4 (length) + 4 (type) + data + 4 (CRC)
-        offset += 12 + chunk_length;
-    }
-
-    // Concatenate IDAT data
-    const total_idat_len = idat_chunks.reduce((s, c) => s + c.length, 0);
-    const idat_data = new Uint8Array(total_idat_len);
-    let cursor = 0;
-
-    for (const chunk of idat_chunks) {
-        idat_data.set(chunk, cursor);
-        cursor += chunk.length;
-    }
-
-    // Decompress zlib (strip 2-byte header and 4-byte checksum, parse raw deflate)
-    const raw_data = inflate_simple(idat_data);
-
-    // Unfilter scanlines
-    const stride = channels;
-    const scanline_bytes = width * stride;
-    const pixels = new Uint8Array(width * height * 4); // always output RGBA
-
-    for (let y = 0; y < height; y++) {
-        const raw_offset = y * (1 + scanline_bytes); // +1 for filter byte
-        const filter_type = raw_data[raw_offset];
-
-        for (let x = 0; x < width; x++) {
-            const src = raw_offset + 1 + x * stride;
-            const dst = (y * width + x) * 4;
-
-            let r = raw_data[src];
-            let g = raw_data[src + 1];
-            let b = raw_data[src + 2];
-            let a = channels === 4 ? raw_data[src + 3] : 255;
-
-            // Apply PNG filter reconstruction
-            if (filter_type === 1) {
-                // Sub filter: add left neighbor
-                if (x > 0) {
-                    r += pixels[dst - 4];
-                    g += pixels[dst - 3];
-                    b += pixels[dst - 2];
-                    a += pixels[dst - 1];
-                }
-            } else if (filter_type === 2) {
-                // Up filter: add above neighbor
-                if (y > 0) {
-                    const above = dst - width * 4;
-                    r += pixels[above];
-                    g += pixels[above + 1];
-                    b += pixels[above + 2];
-                    a += pixels[above + 3];
-                }
-            }
-            // filter_type 0 = None (no transform needed)
-
-            pixels[dst] = r & 0xFF;
-            pixels[dst + 1] = g & 0xFF;
-            pixels[dst + 2] = b & 0xFF;
-            pixels[dst + 3] = a & 0xFF;
-        }
-    }
-
-    return { width, height, channels: 4, pixels };
-}
-
-
-/**
- * Create a ShadeTexture from decoded image data.
- *
- * @param {{ width: number, height: number, channels: number, pixels: Uint8Array }} decoded
- * @returns {ShadeTexture}
- */
-export function create_shade_texture_from_decoded(decoded) {
-    const image = ShadeImage.fromArrayBuffer(
-        decoded.pixels.buffer,
-        decoded.channels,
-        BinaryDataType.Uint8,
-        decoded.width,
-        decoded.height,
-        1
-    );
-
-    image.normalized = true;
-
-    return ShadeTexture.from(image);
-}
-
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-/**
- * Read a big-endian uint32 from a byte array.
- *
- * @param {Uint8Array} data
- * @param {number} offset
- * @returns {number}
- */
-function read_uint32_be(data, offset) {
-    return (data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3];
-}
-
-
-/**
- * Simple inflate (zlib decompress).
- *
- * Strips the 2-byte zlib header and 4-byte adler32 checksum,
- * then parses raw deflate blocks. Only supports uncompressed (stored)
- * and fixed Huffman blocks for small payloads.
- *
- * @param {Uint8Array} zlib_data
- * @returns {Uint8Array}
- */
-function inflate_simple(zlib_data) {
-    // Strip zlib header (2 bytes) and adler32 (4 bytes)
-    const deflate_data = zlib_data.subarray(2, zlib_data.length - 4);
-
-    return inflate_raw(deflate_data);
-}
-
-
-/**
- * Parse raw deflate blocks (RFC 1951).
- * Supports stored blocks (BTYPE=00) and fixed Huffman (BTYPE=01).
- *
- * @param {Uint8Array} data
- * @returns {Uint8Array}
- */
-function inflate_raw(data) {
-    const output = [];
-    let bit_pos = 0;
-
-    function read_bits(n) {
-        let val = 0;
-
-        for (let i = 0; i < n; i++) {
-            const byte_index = (bit_pos + i) >> 3;
-            const bit_index = (bit_pos + i) & 7;
-
-            if (data[byte_index] & (1 << bit_index)) {
-                val |= (1 << i);
-            }
-        }
-
-        bit_pos += n;
-
-        return val;
-    }
-
-    let bfinal = 0;
-
-    while (!bfinal) {
-        bfinal = read_bits(1);
-        const btype = read_bits(2);
-
-        if (btype === 0) {
-            // Stored block — align to byte boundary
-            bit_pos = ((bit_pos + 7) >> 3) << 3;
-
-            const len = read_bits(16);
-            read_bits(16); // nlen (skip)
-
-            const byte_start = bit_pos >> 3;
-
-            for (let i = 0; i < len; i++) {
-                output.push(data[byte_start + i]);
-            }
-
-            bit_pos += len * 8;
-
-        } else if (btype === 1) {
-            // Fixed Huffman codes
-            decode_huffman_block(read_bits.bind(null), output, true);
-
-        } else {
-            throw new Error("[USD] Dynamic Huffman blocks not supported in minimal PNG decoder");
-        }
-    }
-
-    return new Uint8Array(output);
-}
-
-
-/**
- * Decode a fixed Huffman block.
- *
- * @param {function(number):number} read_bits
- * @param {number[]} output
- */
-function decode_huffman_block(read_bits, output) {
-
-    // Fixed Huffman code lengths (RFC 1951, Section 3.2.6)
-    function decode_lit_len() {
-        // Read bits MSB-first for Huffman
-        let code = 0;
-
-        for (let i = 0; i < 7; i++) {
-            code = (code << 1) | read_bits(1);
-        }
-
-        if (code <= 23) {
-            // 7-bit codes: 256-279
-            return 256 + code;
-        }
-
-        code = (code << 1) | read_bits(1);
-
-        if (code >= 48 && code <= 191) {
-            // 8-bit codes: 0-143
-            return code - 48;
-        }
-
-        if (code >= 192 && code <= 199) {
-            // 8-bit codes: 280-287
-            return 280 + (code - 192);
-        }
-
-        code = (code << 1) | read_bits(1);
-
-        if (code >= 400 && code <= 511) {
-            // 9-bit codes: 144-255
-            return 144 + (code - 400);
-        }
-
-        throw new Error(`[USD] Invalid Huffman code: ${code}`);
-    }
-
-    // Length base values and extra bits (RFC 1951, Section 3.2.5)
-    const LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
-    const LENGTH_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
-    const DIST_BASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
-    const DIST_EXTRA = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
-
-    while (true) {
-        const sym = decode_lit_len();
-
-        if (sym < 256) {
-            output.push(sym);
-        } else if (sym === 256) {
-            break; // end of block
-        } else {
-            // Length-distance pair
-            const len_index = sym - 257;
-            const length = LENGTH_BASE[len_index] + read_bits(LENGTH_EXTRA[len_index]);
-
-            // Distance: fixed 5-bit code, MSB-first
-            let dist_code = 0;
-            for (let i = 0; i < 5; i++) {
-                dist_code = (dist_code << 1) | read_bits(1);
-            }
-
-            const distance = DIST_BASE[dist_code] + read_bits(DIST_EXTRA[dist_code]);
-
-            // Copy from output history
-            const copy_start = output.length - distance;
-            for (let i = 0; i < length; i++) {
-                output.push(output[copy_start + i]);
-            }
-        }
-    }
-}
+/**
+ * Image decoding for USD texture resolution.
+ *
+ * Two jobs, both small:
+ *
+ * - `decode_data_url` — a `data:` URL to raw bytes and a MIME type
+ * - `decode_png` — PNG bytes to 8-bit RGBA pixels, via the engine's PNG reader in
+ *   `format/image/png`. Every PNG that reader accepts is accepted here: all five colour types,
+ *   bit depths 1 through 16, Adam7 interlacing, `tRNS` transparency, and any number of `IDAT`
+ *   chunks holding a full zlib stream (stored, fixed and dynamic Huffman blocks alike).
+ *
+ * The output is always RGBA at 8 bits per channel, because that is what `ShadeImage` is handed
+ * downstream. Greyscale is broadcast to RGB, a missing alpha becomes opaque, 16-bit samples keep
+ * their high byte, and sub-8-bit greyscale is rescaled to the full byte range.
+ *
+ * `create_shade_texture_from_decoded` is the adapter from that record to a `ShadeTexture`. It
+ * lives here and not in `format/` on purpose: the loader imports the format tier, never the
+ * reverse (`src/format_tier_boundary.spec.js`).
+ *
+ * @module usd_decode_image
+ */
+
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
+import { PNGReader } from "../../../../format/image/png/PNGReader.js";
+import { ShadeTexture } from "../../texture/ShadeTexture.js";
+import { ShadeImage } from "../../texture/source/ShadeImage.js";
+
+
+/**
+ * Decode a data URL into raw bytes.
+ *
+ * @param {string} url - Data URL (e.g. "data:image/png;base64,...")
+ * @returns {{ mimeType: string, data: Uint8Array } | null}
+ */
+export function decode_data_url(url) {
+
+    if (!url.startsWith("data:")) return null;
+
+    const comma_index = url.indexOf(",");
+
+    if (comma_index === -1) return null;
+
+    const header = url.slice(5, comma_index);
+    const body = url.slice(comma_index + 1);
+
+    const parts = header.split(";");
+    const mime_type = parts[0] || "application/octet-stream";
+    const is_base64 = parts.includes("base64");
+
+    let data;
+
+    if (is_base64) {
+        // Decode base64 — works in both Node.js and browser
+        const binary = atob(body);
+        data = new Uint8Array(binary.length);
+
+        for (let i = 0; i < binary.length; i++) {
+            data[i] = binary.charCodeAt(i);
+        }
+    } else {
+        data = new TextEncoder().encode(decodeURIComponent(body));
+    }
+
+    return { mimeType: mime_type, data };
+}
+
+
+/**
+ * Decode a PNG to 8-bit RGBA pixels.
+ *
+ * Accepts anything `PNGReader` accepts; see the module comment for what that covers and how
+ * other layouts are brought to RGBA8. Errors from the reader (bad signature, truncated stream,
+ * corrupt deflate payload) propagate as thrown.
+ *
+ * @param {Uint8Array|ArrayBuffer} png_bytes
+ * @returns {{ width: number, height: number, channels: number, pixels: Uint8Array }}
+ */
+export function decode_png(png_bytes) {
+
+    const png = new PNGReader(to_array_buffer(png_bytes)).parse();
+
+    const width = png.getWidth();
+    const height = png.getHeight();
+    const bit_depth = png.getBitDepth();
+
+    // `data` is one sample per element at 8 bits and below (palette entries already looked up),
+    // and byte pairs in platform order at 16 bits
+    const { data, itemSize: item_size } = png.getUint8Data();
+
+    const pixel_count = width * height;
+
+    /** @type {ArrayLike<number>} */
+    let samples;
+    let sample_max;
+
+    if (bit_depth === 16) {
+        samples = new Uint16Array(data.buffer, data.byteOffset, pixel_count * item_size);
+        sample_max = 0xFFFF;
+    } else if (bit_depth < 8 && png.getColorType() !== PNG_COLOR_TYPE_PALETTE) {
+        // packed greyscale comes out as the depth coded it: 0..1, 0..3 or 0..15
+        samples = data;
+        sample_max = (1 << bit_depth) - 1;
+    } else {
+        samples = data;
+        sample_max = 0xFF;
+    }
+
+    const pixels = new Uint8Array(pixel_count * 4);
+
+    for (let i = 0; i < pixel_count; i++) {
+        const src = i * item_size;
+        const dst = i * 4;
+
+        let r, g, b, a;
+
+        if (item_size < 3) {
+            // greyscale, with or without alpha
+            r = g = b = samples[src];
+            a = item_size === 2 ? samples[src + 1] : sample_max;
+        } else {
+            r = samples[src];
+            g = samples[src + 1];
+            b = samples[src + 2];
+            a = item_size === 4 ? samples[src + 3] : sample_max;
+        }
+
+        pixels[dst] = to_byte(r, sample_max);
+        pixels[dst + 1] = to_byte(g, sample_max);
+        pixels[dst + 2] = to_byte(b, sample_max);
+        pixels[dst + 3] = to_byte(a, sample_max);
+    }
+
+    return { width, height, channels: 4, pixels };
+}
+
+
+/**
+ * Create a ShadeTexture from decoded image data.
+ *
+ * @param {{ width: number, height: number, channels: number, pixels: Uint8Array }} decoded
+ * @returns {ShadeTexture}
+ */
+export function create_shade_texture_from_decoded(decoded) {
+    const image = ShadeImage.fromArrayBuffer(
+        decoded.pixels.buffer,
+        decoded.channels,
+        BinaryDataType.Uint8,
+        decoded.width,
+        decoded.height,
+        1
+    );
+
+    image.normalized = true;
+
+    return ShadeTexture.from(image);
+}
+
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+const PNG_COLOR_TYPE_PALETTE = 3;
+
+/**
+ * Bring a sample in `0..max` to `0..255`.
+ *
+ * Exact for `max` of 255; the high byte for 65535; rounded for the packed depths, so that
+ * 1-bit white is 255 and not 254.
+ *
+ * @param {number} value
+ * @param {number} max
+ * @returns {number}
+ */
+function to_byte(value, max) {
+    if (max === 0xFF) return value;
+    if (max === 0xFFFF) return value >>> 8;
+
+    return Math.round(value * 255 / max);
+}
+
+/**
+ * `PNGReader` reads from an `ArrayBuffer` positioned at zero, so a view that does not span its
+ * whole buffer is copied out first.
+ *
+ * @param {Uint8Array|ArrayBuffer} bytes
+ * @returns {ArrayBuffer}
+ */
+function to_array_buffer(bytes) {
+    if (bytes instanceof ArrayBuffer) return bytes;
+
+    if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+        return bytes.buffer;
+    }
+
+    return bytes.slice().buffer;
+}

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -49,7 +49,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#140@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#131@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */