@woosh/meep-engine 3.14.2 → 3.14.4

package/src/shade/renderer/scene/optimization/deduplicate_images.js

@@ -1,94 +1,94 @@
-import { sampler2d_build_mipmap_chain } from "./sampler2d_build_mipmap_chain.js";
-import { sampler2d_compare } from "./sampler2d_compare.js";
-import { source_to_sampler2d } from "./source_to_sampler2d.js";
-
-/**
- *
- * @param {Object[]} lookup_input
- * @returns {Object[][]}
- */
-export function deduplicate_images(lookup_input) {
-
-    /**
-     *
-     * @type {Map<Object, Sampler2D[]>}
-     */
-    const sampler_2d_lookup = new Map();
-
-    for (const source of lookup_input) {
-
-        const sampler_2d = source_to_sampler2d(source);
-
-        if (sampler_2d === null) {
-            // not applicable, skip
-            continue;
-        }
-
-        const mipmap = sampler2d_build_mipmap_chain(sampler_2d);
-
-        sampler_2d_lookup.set(source, mipmap);
-    }
-
-    const SIMILARITY_THRESHOLD = 0.99;
-    /**
-     * How many mips from the source down to. 0 would compare the original image.
-     * @type {number}
-     */
-    const SIMILARITY_MIP_OFFSET = 1;
-
-    const comparable_set = Array.from(new Set(sampler_2d_lookup.keys()));
-
-    const duplicate_pairs = [];
-
-    for (let i = 0; i < comparable_set.length; i++) {
-        loop_b: for (let j = i + 1; j < comparable_set.length; j++) {
-
-            const source_a = comparable_set[i];
-            const source_b = comparable_set[j];
-
-            if (source_a === source_b) {
-                continue;
-            }
-
-            const mipmap_a = sampler_2d_lookup.get(source_a);
-            const mipmap_b = sampler_2d_lookup.get(source_b);
-
-            if (mipmap_b.length !== mipmap_a.length) {
-                continue;
-            }
-
-            let lowest_mip_level = 0;
-
-            if(mipmap_b.length < 3 + SIMILARITY_MIP_OFFSET){
-                // image is too small, comparing mips would introduce too much error
-                lowest_mip_level = 0;
-            }else{
-                lowest_mip_level = SIMILARITY_MIP_OFFSET;
-            }
-
-            // accelerate comparrison via mipmaps, can reject much faster and at worst we do 33% more work
-            for (let k = mipmap_a.length - 1; k >= lowest_mip_level; k--) {
-
-                const sampler_a = mipmap_a[k];
-                const sampler_b = mipmap_b[k];
-
-                const similarity = sampler2d_compare(sampler_a, sampler_b);
-
-                if (similarity < SIMILARITY_THRESHOLD) {
-                    continue loop_b;
-                }
-
-            }
-
-
-            // same
-
-            duplicate_pairs.push([
-                source_b, // <- discard
-                source_a // <- master record
-            ]);
-        }
-    }
-
-    return duplicate_pairs;
+import { sampler2d_build_mipmap_chain } from "./sampler2d_build_mipmap_chain.js";
+import { sampler2d_compare } from "../../../../engine/graphics/texture/sampler/compare/sampler2d_compare.js";
+import { source_to_sampler2d } from "./source_to_sampler2d.js";
+
+/**
+ *
+ * @param {Object[]} lookup_input
+ * @returns {Object[][]}
+ */
+export function deduplicate_images(lookup_input) {
+
+    /**
+     *
+     * @type {Map<Object, Sampler2D[]>}
+     */
+    const sampler_2d_lookup = new Map();
+
+    for (const source of lookup_input) {
+
+        const sampler_2d = source_to_sampler2d(source);
+
+        if (sampler_2d === null) {
+            // not applicable, skip
+            continue;
+        }
+
+        const mipmap = sampler2d_build_mipmap_chain(sampler_2d);
+
+        sampler_2d_lookup.set(source, mipmap);
+    }
+
+    const SIMILARITY_THRESHOLD = 0.99;
+    /**
+     * How many mips from the source down to. 0 would compare the original image.
+     * @type {number}
+     */
+    const SIMILARITY_MIP_OFFSET = 1;
+
+    const comparable_set = Array.from(new Set(sampler_2d_lookup.keys()));
+
+    const duplicate_pairs = [];
+
+    for (let i = 0; i < comparable_set.length; i++) {
+        loop_b: for (let j = i + 1; j < comparable_set.length; j++) {
+
+            const source_a = comparable_set[i];
+            const source_b = comparable_set[j];
+
+            if (source_a === source_b) {
+                continue;
+            }
+
+            const mipmap_a = sampler_2d_lookup.get(source_a);
+            const mipmap_b = sampler_2d_lookup.get(source_b);
+
+            if (mipmap_b.length !== mipmap_a.length) {
+                continue;
+            }
+
+            let lowest_mip_level = 0;
+
+            if(mipmap_b.length < 3 + SIMILARITY_MIP_OFFSET){
+                // image is too small, comparing mips would introduce too much error
+                lowest_mip_level = 0;
+            }else{
+                lowest_mip_level = SIMILARITY_MIP_OFFSET;
+            }
+
+            // accelerate comparrison via mipmaps, can reject much faster and at worst we do 33% more work
+            for (let k = mipmap_a.length - 1; k >= lowest_mip_level; k--) {
+
+                const sampler_a = mipmap_a[k];
+                const sampler_b = mipmap_b[k];
+
+                const similarity = sampler2d_compare(sampler_a, sampler_b);
+
+                if (similarity < SIMILARITY_THRESHOLD) {
+                    continue loop_b;
+                }
+
+            }
+
+
+            // same
+
+            duplicate_pairs.push([
+                source_b, // <- discard
+                source_a // <- master record
+            ]);
+        }
+    }
+
+    return duplicate_pairs;
 }

package/src/shade/renderer/scene/optimization/downscale_images.js

@@ -1,216 +1,216 @@
-import {
-    sampler2d_scale_up_linear
-} from "../../../../engine/graphics/texture/sampler/resize/sampler2d_scale_up_linear.js";
-import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
-import { sampler2d_build_mipmap_chain } from "./sampler2d_build_mipmap_chain.js";
-import { sampler2d_compare } from "./sampler2d_compare.js";
-import { source_to_sampler2d } from "./source_to_sampler2d.js";
-
-/**
- * Checks whether a Sampler2D is effectively a single solid color.
- * Uses per-channel variance: if every channel has negligible spread, the image
- * can be collapsed to 1×1.
- *
- * @param {Sampler2D} sampler
- * @param {number} threshold Maximum per-channel range (in data units) to still
- *        qualify as solid.  For Uint8 data this is on a 0-255 scale.
- * @returns {boolean}
- */
-function is_solid_color(sampler, threshold) {
-    const { data, itemSize, width, height } = sampler;
-    const texel_count = width * height;
-
-    if (texel_count <= 1) {
-        return true;
-    }
-
-    // Track min/max per channel
-    const channel_min = new Float64Array(itemSize);
-    const channel_max = new Float64Array(itemSize);
-
-    channel_min.fill(Infinity);
-    channel_max.fill(-Infinity);
-
-    for (let p = 0; p < texel_count; p++) {
-        const base = p * itemSize;
-
-        for (let c = 0; c < itemSize; c++) {
-            const v = data[base + c];
-
-            if (v < channel_min[c]) {
-                channel_min[c] = v;
-            }
-
-            if (v > channel_max[c]) {
-                channel_max[c] = v;
-            }
-        }
-
-        // Early out: if any channel already exceeds threshold, no point continuing
-        let any_exceeded = false;
-        for (let c = 0; c < itemSize; c++) {
-            if (channel_max[c] - channel_min[c] > threshold) {
-                any_exceeded = true;
-                break;
-            }
-        }
-
-        if (any_exceeded) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Creates a 1×1 Sampler2D with the average color of the input.
- *
- * @param {Sampler2D} sampler
- * @returns {Sampler2D}
- */
-function create_1x1_average(sampler) {
-    const { data, itemSize, width, height } = sampler;
-    const texel_count = width * height;
-
-    const sum = new Float64Array(itemSize);
-
-    for (let p = 0; p < texel_count; p++) {
-        const base = p * itemSize;
-
-        for (let c = 0; c < itemSize; c++) {
-            sum[c] += data[base + c];
-        }
-    }
-
-    const out_data = new sampler.data.constructor(itemSize);
-
-    for (let c = 0; c < itemSize; c++) {
-        out_data[c] = Math.round(sum[c] / texel_count);
-    }
-
-    return new Sampler2D(out_data, itemSize, 1, 1);
-}
-
-/**
- * Attempts to find the smallest mip level at which an image can be represented
- * without perceptible quality loss.  Uses a round-trip test: scale down, then
- * scale back up to the original resolution using bilinear filtering.  If the
- * reconstructed image is near-identical to the original, the smaller version
- * is accepted.
- *
- * The function generates a mipmap chain of successively halved sizes, then
- * walks from the smallest mip upward.  The first mip whose round-trip
- * reconstruction stays within the similarity threshold is selected.
- *
- * @param {Sampler2D} original
- * @param {number} similarity_threshold  Minimum similarity score (0-1) for acceptance.
- * @returns {Sampler2D} The smallest acceptable Sampler2D (may be the original
- *          itself if no reduction is possible).
- */
-function find_best_downscale(original, similarity_threshold) {
-
-    if (original.width <= 2 && original.height <= 2) {
-        // Already tiny, nothing to gain
-        return original;
-    }
-
-    // Build mipmap chain (including the original at index 0)
-    const mips = sampler2d_build_mipmap_chain(original);
-
-    if (mips.length <= 1) {
-        return original;
-    }
-
-    // Allocate a reconstruction buffer at the original resolution once
-    const reconstruction = original.clone();
-
-    // Walk from the smallest mip toward the original, looking for the smallest
-    // one whose round-trip stays within budget.
-    for (let i = mips.length - 1; i >= 1; i--) {
-        const candidate = mips[i];
-
-        // Upscale candidate back to original size
-        sampler2d_scale_up_linear(candidate, reconstruction);
-
-        const similarity = sampler2d_compare(original, reconstruction);
-
-        if (similarity >= similarity_threshold) {
-            return candidate;
-        }
-    }
-
-    return original;
-}
-
-/**
- * @typedef {Object} DownscaleResult
- * @property {Object} original_source  The original image source that was replaced.
- * @property {Sampler2D} replacement   The smaller Sampler2D to use instead.
- */
-
-/**
- * Attempts to downscale a list of image sources.  Returns an array of
- * replacements: each entry is an object describing what was replaced.
- *
- * Only images that can be converted to Sampler2D are considered
- * (Sampler2D instances and ImageBitmap instances).
- *
- * @param {Object[]} sources  Array of unique image source objects.
- * @returns {DownscaleResult[]}
- */
-export function downscale_images(sources) {
-    /**
-     * Similarity threshold for the round-trip test.
-     * Uses the same scoring as deduplicate_images (0 = nothing in common, 1 = identical).
-     * 0.999 is stricter than the dedup threshold of 0.99, since we're altering
-     * images rather than just removing duplicates.
-     */
-    const ROUND_TRIP_SIMILARITY_THRESHOLD = 0.999;
-
-    /**
-     * Maximum per-channel range to consider an image as solid color.
-     * On a 0-255 scale, 2 means at most 2 levels of variation in any channel.
-     */
-    const SOLID_COLOR_THRESHOLD = 2;
-
-    /** @type {DownscaleResult[]} */
-    const results = [];
-
-    for (const source of sources) {
-        const sampler = source_to_sampler2d(source);
-
-        if (sampler === null) {
-            continue;
-        }
-
-        if(sampler.width <= 1 && sampler.height <= 1){
-            // not applicable, skip
-            continue;
-        }
-
-        // --- Strategy 1: solid-color collapse to 1×1 ---
-        if (is_solid_color(sampler, SOLID_COLOR_THRESHOLD)) {
-            const tiny = create_1x1_average(sampler);
-
-            results.push({
-                original_source: source,
-                replacement: tiny,
-            });
-
-            continue;
-        }
-
-        // --- Strategy 2: round-trip downscale ---
-        const best = find_best_downscale(sampler, ROUND_TRIP_SIMILARITY_THRESHOLD);
-
-        if (best !== sampler) {
-            results.push({
-                original_source: source,
-                replacement: best,
-            });
-        }
-    }
-
-    return results;
-}
+import {
+    sampler2d_scale_up_linear
+} from "../../../../engine/graphics/texture/sampler/resize/sampler2d_scale_up_linear.js";
+import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { sampler2d_build_mipmap_chain } from "./sampler2d_build_mipmap_chain.js";
+import { sampler2d_compare } from "../../../../engine/graphics/texture/sampler/compare/sampler2d_compare.js";
+import { source_to_sampler2d } from "./source_to_sampler2d.js";
+
+/**
+ * Checks whether a Sampler2D is effectively a single solid color.
+ * Uses per-channel variance: if every channel has negligible spread, the image
+ * can be collapsed to 1×1.
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} threshold Maximum per-channel range (in data units) to still
+ *        qualify as solid.  For Uint8 data this is on a 0-255 scale.
+ * @returns {boolean}
+ */
+function is_solid_color(sampler, threshold) {
+    const { data, itemSize, width, height } = sampler;
+    const texel_count = width * height;
+
+    if (texel_count <= 1) {
+        return true;
+    }
+
+    // Track min/max per channel
+    const channel_min = new Float64Array(itemSize);
+    const channel_max = new Float64Array(itemSize);
+
+    channel_min.fill(Infinity);
+    channel_max.fill(-Infinity);
+
+    for (let p = 0; p < texel_count; p++) {
+        const base = p * itemSize;
+
+        for (let c = 0; c < itemSize; c++) {
+            const v = data[base + c];
+
+            if (v < channel_min[c]) {
+                channel_min[c] = v;
+            }
+
+            if (v > channel_max[c]) {
+                channel_max[c] = v;
+            }
+        }
+
+        // Early out: if any channel already exceeds threshold, no point continuing
+        let any_exceeded = false;
+        for (let c = 0; c < itemSize; c++) {
+            if (channel_max[c] - channel_min[c] > threshold) {
+                any_exceeded = true;
+                break;
+            }
+        }
+
+        if (any_exceeded) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Creates a 1×1 Sampler2D with the average color of the input.
+ *
+ * @param {Sampler2D} sampler
+ * @returns {Sampler2D}
+ */
+function create_1x1_average(sampler) {
+    const { data, itemSize, width, height } = sampler;
+    const texel_count = width * height;
+
+    const sum = new Float64Array(itemSize);
+
+    for (let p = 0; p < texel_count; p++) {
+        const base = p * itemSize;
+
+        for (let c = 0; c < itemSize; c++) {
+            sum[c] += data[base + c];
+        }
+    }
+
+    const out_data = new sampler.data.constructor(itemSize);
+
+    for (let c = 0; c < itemSize; c++) {
+        out_data[c] = Math.round(sum[c] / texel_count);
+    }
+
+    return new Sampler2D(out_data, itemSize, 1, 1);
+}
+
+/**
+ * Attempts to find the smallest mip level at which an image can be represented
+ * without perceptible quality loss.  Uses a round-trip test: scale down, then
+ * scale back up to the original resolution using bilinear filtering.  If the
+ * reconstructed image is near-identical to the original, the smaller version
+ * is accepted.
+ *
+ * The function generates a mipmap chain of successively halved sizes, then
+ * walks from the smallest mip upward.  The first mip whose round-trip
+ * reconstruction stays within the similarity threshold is selected.
+ *
+ * @param {Sampler2D} original
+ * @param {number} similarity_threshold  Minimum similarity score (0-1) for acceptance.
+ * @returns {Sampler2D} The smallest acceptable Sampler2D (may be the original
+ *          itself if no reduction is possible).
+ */
+function find_best_downscale(original, similarity_threshold) {
+
+    if (original.width <= 2 && original.height <= 2) {
+        // Already tiny, nothing to gain
+        return original;
+    }
+
+    // Build mipmap chain (including the original at index 0)
+    const mips = sampler2d_build_mipmap_chain(original);
+
+    if (mips.length <= 1) {
+        return original;
+    }
+
+    // Allocate a reconstruction buffer at the original resolution once
+    const reconstruction = original.clone();
+
+    // Walk from the smallest mip toward the original, looking for the smallest
+    // one whose round-trip stays within budget.
+    for (let i = mips.length - 1; i >= 1; i--) {
+        const candidate = mips[i];
+
+        // Upscale candidate back to original size
+        sampler2d_scale_up_linear(candidate, reconstruction);
+
+        const similarity = sampler2d_compare(original, reconstruction);
+
+        if (similarity >= similarity_threshold) {
+            return candidate;
+        }
+    }
+
+    return original;
+}
+
+/**
+ * @typedef {Object} DownscaleResult
+ * @property {Object} original_source  The original image source that was replaced.
+ * @property {Sampler2D} replacement   The smaller Sampler2D to use instead.
+ */
+
+/**
+ * Attempts to downscale a list of image sources.  Returns an array of
+ * replacements: each entry is an object describing what was replaced.
+ *
+ * Only images that can be converted to Sampler2D are considered
+ * (Sampler2D instances and ImageBitmap instances).
+ *
+ * @param {Object[]} sources  Array of unique image source objects.
+ * @returns {DownscaleResult[]}
+ */
+export function downscale_images(sources) {
+    /**
+     * Similarity threshold for the round-trip test.
+     * Uses the same scoring as deduplicate_images (0 = nothing in common, 1 = identical).
+     * 0.999 is stricter than the dedup threshold of 0.99, since we're altering
+     * images rather than just removing duplicates.
+     */
+    const ROUND_TRIP_SIMILARITY_THRESHOLD = 0.999;
+
+    /**
+     * Maximum per-channel range to consider an image as solid color.
+     * On a 0-255 scale, 2 means at most 2 levels of variation in any channel.
+     */
+    const SOLID_COLOR_THRESHOLD = 2;
+
+    /** @type {DownscaleResult[]} */
+    const results = [];
+
+    for (const source of sources) {
+        const sampler = source_to_sampler2d(source);
+
+        if (sampler === null) {
+            continue;
+        }
+
+        if(sampler.width <= 1 && sampler.height <= 1){
+            // not applicable, skip
+            continue;
+        }
+
+        // --- Strategy 1: solid-color collapse to 1×1 ---
+        if (is_solid_color(sampler, SOLID_COLOR_THRESHOLD)) {
+            const tiny = create_1x1_average(sampler);
+
+            results.push({
+                original_source: source,
+                replacement: tiny,
+            });
+
+            continue;
+        }
+
+        // --- Strategy 2: round-trip downscale ---
+        const best = find_best_downscale(sampler, ROUND_TRIP_SIMILARITY_THRESHOLD);
+
+        if (best !== sampler) {
+            results.push({
+                original_source: source,
+                replacement: best,
+            });
+        }
+    }
+
+    return results;
+}

package/src/shade/renderer/scene/serialization/decode_image_source_hdr.js

@@ -1,4 +1,4 @@
-import { avif_to_sampler2d } from "../../../../avif/native/api/avif_to_sampler2d.js";
+import { avif_to_sampler2d } from "../../../../engine/graphics/texture/sampler/avif_to_sampler2d.js";
 
 /**
  * Checks if an ArrayBuffer contains an AVIF image.

package/src/shade/renderer/scene/serialization/deserialize_scene.js

@@ -12,7 +12,7 @@ import { StandardShadeMaterial } from "../../material/StandardShadeMaterial.js";
 import { Mesh } from "../Mesh.js";
 import { ShadeTexture } from "../../texture/ShadeTexture.js";
 import { ShadeImage } from "../../texture/source/ShadeImage.js";
-import { avif_to_sampler2d } from "../../../../avif/native/api/avif_to_sampler2d.js";
+import { avif_to_sampler2d } from "../../../../engine/graphics/texture/sampler/avif_to_sampler2d.js";
 import { decode_image_source_hdr } from "./decode_image_source_hdr.js";
 import { LightTypeSerializationIndex } from "./LightTypeSerializationIndex.js";
 import { STANDARD_MATERIAL_SERIALIZED_BYTE_SIZE } from "./STANDARD_MATERIAL_SERIALIZED_BYTE_SIZE.js";

package/src/shade/renderer/scene/serialization/write_image_source.js

@@ -1,4 +1,4 @@
-import { get_threaded_image_encoder } from "../../../../avif/threaded_image_encoder.js";
+import { get_threaded_image_encoder } from "../../../../engine/asset/loaders/image/avif/threaded_image_encoder.js";
 
 /**
  * @param {Sampler2D} sampler2d

package/src/shade/renderer/shader/chunk/color/iCtCp/chunk_eotf_st2084.d.ts

@@ -15,7 +15,7 @@
  * |---|---|---|
  * | here, and `chunk_tonemap_gt7` | 100 nits | GT7's internal unit for a GPU linear `1.0` |
  * | `core/color/PQ/PQ_constants.js` | 203 nits | BT.2408 graphics white, a *renderer* convention |
- * | `avif/native/color/transfer_to_linear.js` | 100 nits | the reference display the SDR curves in H.273 are defined against |
+ * | `format/image/avif/color/transfer_to_linear.js` | 100 nits | the reference display the SDR curves in H.273 are defined against |
  *
  * The CPU's `linear_to_PQ` / `PQ_to_linear` fold in none of these — they are pure ST 2084 in PQ's own
  * normalisation, which is what makes them an exact inverse pair — so the 203 is applied by their callers.

package/src/shade/renderer/shader/chunk/color/iCtCp/chunk_eotf_st2084.js

@@ -17,7 +17,7 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
  * |---|---|---|
  * | here, and `chunk_tonemap_gt7` | 100 nits | GT7's internal unit for a GPU linear `1.0` |
  * | `core/color/PQ/PQ_constants.js` | 203 nits | BT.2408 graphics white, a *renderer* convention |
- * | `avif/native/color/transfer_to_linear.js` | 100 nits | the reference display the SDR curves in H.273 are defined against |
+ * | `format/image/avif/color/transfer_to_linear.js` | 100 nits | the reference display the SDR curves in H.273 are defined against |
  *
  * The CPU's `linear_to_PQ` / `PQ_to_linear` fold in none of these — they are pure ST 2084 in PQ's own
  * normalisation, which is what makes them an exact inverse pair — so the 203 is applied by their callers.