@woosh/meep-engine 3.14.2 → 3.14.3

package/src/basis/transcode/etc1s_to_bc1.js

@@ -1,205 +0,0 @@
-import { etc1s_block_colors } from "../etc1s/etc1s_block_colors.js";
-
-/**
- * Bytes one BC1 block occupies: two 16-bit endpoints and sixteen 2-bit indices.
- *
- * @readonly
- * @type {number}
- */
-const BC1_BLOCK_BYTES = 8;
-
-/**
- * Pack an eight-bit-per-channel colour into BC1's 5:6:5 endpoint.
- *
- * Rounding rather than truncating: truncation biases every endpoint darker, and over a whole texture
- * that reads as a gamma shift rather than as noise.
- *
- * @param {number} r
- * @param {number} g
- * @param {number} b
- * @returns {number} sixteen bits
- */
-function pack565(r, g, b) {
-    const r5 = Math.min(31, (r * 31 + 127) / 255 | 0);
-    const g6 = Math.min(63, (g * 63 + 127) / 255 | 0);
-    const b5 = Math.min(31, (b * 31 + 127) / 255 | 0);
-
-    return (r5 << 11) | (g6 << 5) | b5;
-}
-
-/**
- * The eight-bit colour a 5:6:5 endpoint decodes to, by the same bit replication hardware uses.
- *
- * @param {Uint8Array} out
- * @param {number} offset
- * @param {number} packed
- */
-function unpack565(out, offset, packed) {
-    const r5 = (packed >> 11) & 31;
-    const g6 = (packed >> 5) & 63;
-    const b5 = packed & 31;
-
-    out[offset] = (r5 << 3) | (r5 >> 2);
-    out[offset + 1] = (g6 << 2) | (g6 >> 4);
-    out[offset + 2] = (b5 << 3) | (b5 >> 2);
-}
-
-/**
- * Which of BC1's four colours best matches a target, given the block's decoded palette.
- *
- * @param {Uint8Array} palette twelve bytes, four `[r, g, b]` triples in BC1 index order
- * @param {Uint8Array} target three bytes
- * @param {number} target_offset
- * @returns {number} `0` to `3`
- */
-function closest_index(palette, target, target_offset) {
-    let best = 0;
-    let best_error = Infinity;
-
-    for (let i = 0; i < 4; i++) {
-        const dr = palette[i * 3] - target[target_offset];
-        const dg = palette[i * 3 + 1] - target[target_offset + 1];
-        const db = palette[i * 3 + 2] - target[target_offset + 2];
-
-        const error = dr * dr + dg * dg + db * db;
-
-        if (error < best_error) {
-            best_error = error;
-            best = i;
-        }
-    }
-
-    return best;
-}
-
-/**
- * Transcode a decoded ETC1S slice to BC1.
- *
- * **Both formats put four colours on a line, which is what makes this cheap and good.** An ETC1S
- * block is a base colour plus an intensity modifier applied equally to all three channels, so its
- * four colours are collinear; BC1's are two endpoints plus two interpolants, which is the same
- * shape. The transcode is therefore a re-parameterisation rather than a re-quantisation, and what it
- * loses is only what 5:6:5 endpoints lose over ETC1S's 5:5:5-plus-modifier.
- *
- * **The work is per endpoint codebook entry, not per block.** A block's four colours depend only on
- * which endpoint entry it names, so the endpoint pair and the selector-to-index mapping are computed
- * once per entry — of which there are at most a few thousand — and every block that names it just
- * writes them out. A texture is typically tens of thousands of blocks over a few hundred entries.
- *
- * @param {Etc1sSlice} slice
- * @param {Etc1sEndpointCodebook} endpoints
- * @param {Etc1sSelectorCodebook} selectors
- * @returns {Uint8Array} tightly packed BC1 blocks, in raster order
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function etc1s_to_bc1(slice, endpoints, selectors) {
-    const plan = build_range_plan(selectors);
-
-    const templates = build_templates(endpoints, plan);
-
-    const block_count = slice.blocks_x * slice.blocks_y;
-
-    const out = new Uint8Array(block_count * BC1_BLOCK_BYTES);
-
-    for (let block = 0; block < block_count; block++) {
-        const selector_entry = slice.selector_index[block];
-        const selector_base = selector_entry * 16;
-
-        const pairing = slice.endpoint_index[block] * plan.slot_count
-            + plan.slot_of_entry[selector_entry];
-
-        const low = templates.low[pairing];
-        const high = templates.high[pairing];
-        const map = pairing * 4;
-
-        const o = block * BC1_BLOCK_BYTES;
-
-        out[o] = low & 255;
-        out[o + 1] = low >> 8;
-        out[o + 2] = high & 255;
-        out[o + 3] = high >> 8;
-
-        for (let row = 0; row < 4; row++) {
-            const base = selector_base + row * 4;
-
-            out[o + 4 + row] =
-                templates.selector_to_index[map + selectors.selectors[base]]
-                | (templates.selector_to_index[map + selectors.selectors[base + 1]] << 2)
-                | (templates.selector_to_index[map + selectors.selectors[base + 2]] << 4)
-                | (templates.selector_to_index[map + selectors.selectors[base + 3]] << 6);
-        }
-    }
-
-    return out;
-}
-
-/**
- * The BC1 endpoint pair and selector mapping for every entry of the endpoint codebook.
- *
- * @param {Etc1sEndpointCodebook} endpoints
- * @returns {{low: Uint16Array, high: Uint16Array, selector_to_index: Uint8Array}} `low` is written
- * first, and is the larger of the pair so the block decodes in four-colour mode
- */
-function build_templates(endpoints) {
-    const count = endpoints.count;
-
-    const low = new Uint16Array(count);
-    const high = new Uint16Array(count);
-    const selector_to_index = new Uint8Array(count * 4);
-
-    const colors = new Uint8Array(12);
-    const palette = new Uint8Array(12);
-
-    for (let entry = 0; entry < count; entry++) {
-        etc1s_block_colors(colors, 0, endpoints.color5, endpoints.intensity, entry);
-
-        /*
-         The darkest and brightest of the four span the line; the middle two are recovered by BC1's
-         own interpolants, which sit at one and two thirds. ETC1S's middle colours are not exactly
-         there — the modifier table is not evenly spaced — so they are matched rather than assumed.
-        */
-        let first = pack565(colors[9], colors[10], colors[11]);
-        let second = pack565(colors[0], colors[1], colors[2]);
-
-        /*
-         Four-colour mode needs the first endpoint to compare greater. Equal endpoints would select
-         three-colour mode, whose fourth index is transparent black — so they are nudged apart, which
-         is invisible because the block is a single colour either way.
-        */
-        if (first < second) {
-            const swap = first;
-
-            first = second;
-            second = swap;
-        }
-
-        if (first === second) {
-            second = first === 0 ? 0 : first - 1;
-        }
-
-        low[entry] = first;
-        high[entry] = second;
-
-        unpack565(palette, 0, first);
-        unpack565(palette, 3, second);
-
-        /*
-         The specification's interpolants, truncating rather than rounding. It matters only that the
-         same arithmetic is used here and by whatever decodes the result: these colours exist to pick
-         indices, and picking them against a palette a decoder will not produce is how a transcoder
-         ends up half a level off everywhere.
-        */
-        for (let c = 0; c < 3; c++) {
-            palette[6 + c] = (2 * palette[c] + palette[3 + c]) / 3 | 0;
-            palette[9 + c] = (palette[c] + 2 * palette[3 + c]) / 3 | 0;
-        }
-
-        for (let selector = 0; selector < 4; selector++) {
-            selector_to_index[entry * 4 + selector] = closest_index(palette, colors, selector * 3);
-        }
-    }
-
-    return { low, high, selector_to_index };
-}

package/src/basis/transcode/etc1s_to_bc7.d.ts

@@ -1,30 +0,0 @@
-/**
- * Transcode a decoded ETC1S slice to BC7.
- *
- * **Two modes, chosen by whether the payload carries alpha, because BC7 cannot do both at once.**
- * Mode 6 gives one index per texel, shared by all four channels, with four bits of it; mode 5 gives
- * colour and alpha their own indices but only two bits each. An opaque payload wants the finer
- * index; an alpha payload needs the independent one, because an ETC1S file's alpha slice has its own
- * selectors, unrelated to the colour slice's, and a shared index could not express both.
- *
- * Neither mode loses much to ETC1S, for the reason {@link etc1s_to_bc1} spells out: an ETC1S block's
- * four colours lie on a line, which is the shape both modes store natively. Mode 5's two-bit index
- * is in fact an exact structural match — four colours, four index values — and gives up only the
- * freedom to place the middle two, which ETC1S's modifier table has already fixed.
- *
- * **The work is per codebook entry, not per block.** A block's colours depend only on which endpoint
- * entry it names, so endpoints and the selector-to-index mapping are computed once per entry and
- * every block that names it just writes them out. Colour and alpha are tabulated separately, which
- * is what lets mode 5 pair any colour entry with any alpha entry without a table of their product.
- *
- * @param {Etc1sSlice} slice the colour slice
- * @param {Etc1sSlice|undefined} alpha_slice the alpha slice, when the payload has one
- * @param {Etc1sEndpointCodebook} endpoints
- * @param {Etc1sSelectorCodebook} selectors
- * @returns {Uint8Array} tightly packed BC7 blocks, in raster order
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function etc1s_to_bc7(slice: Etc1sSlice, alpha_slice: Etc1sSlice | undefined, endpoints: Etc1sEndpointCodebook, selectors: Etc1sSelectorCodebook): Uint8Array;
-//# sourceMappingURL=etc1s_to_bc7.d.ts.map

package/src/basis/transcode/etc1s_to_bc7.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"etc1s_to_bc7.d.ts","sourceRoot":"","sources":["../../../../src/basis/transcode/etc1s_to_bc7.js"],"names":[],"mappings":"AA4FA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,6DARW,aAAW,SAAS,uEAGlB,UAAU,CAStB"}

package/src/basis/transcode/fit_endpoints.d.ts

@@ -1,59 +0,0 @@
-/**
- * Which entry of {@link SELECTOR_RANGES} a `[min, max]` span is.
- *
- * @param {number} min
- * @param {number} max
- * @returns {number}
- */
-export function selector_range_index(min: number, max: number): number;
-/**
- * Fit a pair of endpoints to the colours a block actually uses, by least squares.
- *
- * **Why the obvious choice is not good enough.** An ETC1S block's four colours are its base colour
- * plus a modifier applied equally to every channel, so before clamping they lie on a line and the
- * darkest and brightest of them span it exactly. Clamping breaks that. A base colour near white with
- * a large modifier gives, say, red `{67, 203, 255, 255}` beside green `{0, 0, 57, 193}` — still
- * ordered, but no longer collinear, because red saturated and green did not. Taking the outer two as
- * endpoints then leaves the middle two nowhere near the line between them, and no interpolation
- * weight can recover them.
- *
- * So the endpoints are fitted rather than read off: each colour is assigned the weight that suits it
- * best, the endpoints are re-solved to minimise squared error against all of them at once, and the
- * two steps alternate.
- *
- * **And the fit is over `[min_selector, max_selector]` only.** Which colours a block uses is a
- * property of its *selector* codebook entry, and most entries do not use all four — a block spanning
- * only the darkest two is a line those two define exactly, and fitting it against colours it never
- * samples throws that away for nothing. Conditioning on the span is what closes most of the distance
- * to the reference transcoder on saturated content.
- *
- * @param {Uint8Array} low three channels, seeded with a guess and overwritten with the fit
- * @param {Uint8Array} high three channels, likewise
- * @param {Uint8Array} colors twelve bytes, the block's four `[r, g, b]` colours
- * @param {Int32Array} weights the destination format's interpolation weights, out of 64
- * @param {number} min_selector lowest selector value any block using this pairing has
- * @param {number} max_selector highest
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function fit_endpoints(low: Uint8Array, high: Uint8Array, colors: Uint8Array, weights: Int32Array, min_selector: number, max_selector: number): void;
-/**
- * The `[min, max]` selector span of every entry of a selector codebook.
- *
- * @param {Etc1sSelectorCodebook} selectors
- * @returns {Uint8Array} one index into {@link SELECTOR_RANGES} per entry
- */
-export function selector_codebook_ranges(selectors: Etc1sSelectorCodebook): Uint8Array;
-/**
- * Every `[min, max]` span of selector values a block can use, as pairs.
- *
- * Ten of them, because a span is an ordered pair drawn from four values. A block that only uses the
- * darkest two colours is fitted against those two alone, which is the whole reason this exists — see
- * {@link fit_endpoints}.
- *
- * @readonly
- * @type {number[][]}
- */
-export const SELECTOR_RANGES: number[][];
-//# sourceMappingURL=fit_endpoints.d.ts.map

package/src/basis/transcode/fit_endpoints.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fit_endpoints.d.ts","sourceRoot":"","sources":["../../../../src/basis/transcode/fit_endpoints.js"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH,0CAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,mCAVW,UAAU,QACV,UAAU,UACV,UAAU,WACV,UAAU,gBACV,MAAM,gBACN,MAAM,QA+EhB;AA+CD;;;;;GAKG;AACH,4EAFa,UAAU,CAyBtB;AAvND;;;;;;;;;GASG;AACH,8BAFU,MAAM,EAAE,EAAE,CAOlB"}

package/src/basis/transcode/fit_endpoints.js

@@ -1,226 +0,0 @@
-/**
- * How many refine-and-reassign rounds to run. The fit converges in two or three for almost every
- * codebook entry, and the loop leaves early when nothing moves, so this is a ceiling rather than a
- * cost.
- *
- * @readonly
- * @type {number}
- */
-const MAX_ITERATIONS = 8;
-
-/**
- * Every `[min, max]` span of selector values a block can use, as pairs.
- *
- * Ten of them, because a span is an ordered pair drawn from four values. A block that only uses the
- * darkest two colours is fitted against those two alone, which is the whole reason this exists — see
- * {@link fit_endpoints}.
- *
- * @readonly
- * @type {number[][]}
- */
-export const SELECTOR_RANGES = [
-    [0, 0], [0, 1], [0, 2], [0, 3],
-    [1, 1], [1, 2], [1, 3],
-    [2, 2], [2, 3],
-    [3, 3],
-];
-
-/**
- * Which entry of {@link SELECTOR_RANGES} a `[min, max]` span is.
- *
- * @param {number} min
- * @param {number} max
- * @returns {number}
- */
-export function selector_range_index(min, max) {
-    for (let i = 0; i < SELECTOR_RANGES.length; i++) {
-        if (SELECTOR_RANGES[i][0] === min && SELECTOR_RANGES[i][1] === max) {
-            return i;
-        }
-    }
-
-    throw new Error(`Basis: ${min}..${max} is not a selector range`);
-}
-
-/**
- * Fit a pair of endpoints to the colours a block actually uses, by least squares.
- *
- * **Why the obvious choice is not good enough.** An ETC1S block's four colours are its base colour
- * plus a modifier applied equally to every channel, so before clamping they lie on a line and the
- * darkest and brightest of them span it exactly. Clamping breaks that. A base colour near white with
- * a large modifier gives, say, red `{67, 203, 255, 255}` beside green `{0, 0, 57, 193}` — still
- * ordered, but no longer collinear, because red saturated and green did not. Taking the outer two as
- * endpoints then leaves the middle two nowhere near the line between them, and no interpolation
- * weight can recover them.
- *
- * So the endpoints are fitted rather than read off: each colour is assigned the weight that suits it
- * best, the endpoints are re-solved to minimise squared error against all of them at once, and the
- * two steps alternate.
- *
- * **And the fit is over `[min_selector, max_selector]` only.** Which colours a block uses is a
- * property of its *selector* codebook entry, and most entries do not use all four — a block spanning
- * only the darkest two is a line those two define exactly, and fitting it against colours it never
- * samples throws that away for nothing. Conditioning on the span is what closes most of the distance
- * to the reference transcoder on saturated content.
- *
- * @param {Uint8Array} low three channels, seeded with a guess and overwritten with the fit
- * @param {Uint8Array} high three channels, likewise
- * @param {Uint8Array} colors twelve bytes, the block's four `[r, g, b]` colours
- * @param {Int32Array} weights the destination format's interpolation weights, out of 64
- * @param {number} min_selector lowest selector value any block using this pairing has
- * @param {number} max_selector highest
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function fit_endpoints(low, high, colors, weights, min_selector, max_selector) {
-    if (min_selector === max_selector) {
-        /*
-         One colour, and both endpoints are it — every weight then interpolates to the same value, so
-         there is nothing to solve and the normal equations below would be singular anyway.
-        */
-        for (let c = 0; c < 3; c++) {
-            low[c] = colors[min_selector * 3 + c];
-            high[c] = colors[min_selector * 3 + c];
-        }
-
-        return;
-    }
-
-    const assigned = new Int32Array(4);
-
-    for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
-        for (let selector = min_selector; selector <= max_selector; selector++) {
-            assigned[selector] = nearest_weight(low, high, weights, colors, selector * 3);
-        }
-
-        let sum_aa = 0;
-        let sum_ab = 0;
-        let sum_bb = 0;
-
-        for (let selector = min_selector; selector <= max_selector; selector++) {
-            const b = weights[assigned[selector]] / 64;
-            const a = 1 - b;
-
-            sum_aa += a * a;
-            sum_ab += a * b;
-            sum_bb += b * b;
-        }
-
-        const determinant = sum_aa * sum_bb - sum_ab * sum_ab;
-
-        // singular when every colour in the span was assigned the same weight; the fit is done
-        if (Math.abs(determinant) < 1e-6) {
-            return;
-        }
-
-        let moved = false;
-
-        for (let c = 0; c < 3; c++) {
-            let sum_ap = 0;
-            let sum_bp = 0;
-
-            for (let selector = min_selector; selector <= max_selector; selector++) {
-                const b = weights[assigned[selector]] / 64;
-                const a = 1 - b;
-                const p = colors[selector * 3 + c];
-
-                sum_ap += a * p;
-                sum_bp += b * p;
-            }
-
-            const solved_low = (sum_bb * sum_ap - sum_ab * sum_bp) / determinant;
-            const solved_high = (sum_aa * sum_bp - sum_ab * sum_ap) / determinant;
-
-            const next_low = clamp_round(solved_low);
-            const next_high = clamp_round(solved_high);
-
-            if (next_low !== low[c] || next_high !== high[c]) {
-                moved = true;
-            }
-
-            low[c] = next_low;
-            high[c] = next_high;
-        }
-
-        if (!moved) {
-            return;
-        }
-    }
-}
-
-/**
- * @param {number} value
- * @returns {number} rounded into `[0, 255]`
- */
-function clamp_round(value) {
-    const rounded = Math.round(value);
-
-    return rounded < 0 ? 0 : rounded > 255 ? 255 : rounded;
-}
-
-/**
- * Which weight puts the interpolated colour closest to a target.
- *
- * @param {Uint8Array} low three channels
- * @param {Uint8Array} high three channels
- * @param {Int32Array} weights
- * @param {Uint8Array} target
- * @param {number} target_offset
- * @returns {number} an index into `weights`
- */
-function nearest_weight(low, high, weights, target, target_offset) {
-    let best = 0;
-    let best_error = Infinity;
-
-    for (let i = 0; i < weights.length; i++) {
-        const weight = weights[i];
-
-        let error = 0;
-
-        for (let c = 0; c < 3; c++) {
-            const interpolated = (low[c] * (64 - weight) + high[c] * weight + 32) >> 6;
-            const delta = interpolated - target[target_offset + c];
-
-            error += delta * delta;
-        }
-
-        if (error < best_error) {
-            best_error = error;
-            best = i;
-        }
-    }
-
-    return best;
-}
-
-/**
- * The `[min, max]` selector span of every entry of a selector codebook.
- *
- * @param {Etc1sSelectorCodebook} selectors
- * @returns {Uint8Array} one index into {@link SELECTOR_RANGES} per entry
- */
-export function selector_codebook_ranges(selectors) {
-    const out = new Uint8Array(selectors.count);
-
-    for (let entry = 0; entry < selectors.count; entry++) {
-        let min = 3;
-        let max = 0;
-
-        for (let i = 0; i < 16; i++) {
-            const selector = selectors.selectors[entry * 16 + i];
-
-            if (selector < min) {
-                min = selector;
-            }
-
-            if (selector > max) {
-                max = selector;
-            }
-        }
-
-        out[entry] = selector_range_index(min, max);
-    }
-
-    return out;
-}

package/src/engine/asset/loaders/gltf/computeObjectBoundingSphere.d.ts

@@ -1,8 +0,0 @@
-/**
- *
- * @param {Object3D} o
- * @returns {Vector4} center is x,y,z while radius is w
- */
-export function computeObjectBoundingSphere(o: Object3D): Vector4;
-import Vector4 from "../../../../core/geom/Vector4.js";
-//# sourceMappingURL=computeObjectBoundingSphere.d.ts.map

package/src/engine/asset/loaders/gltf/computeObjectBoundingSphere.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeObjectBoundingSphere.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/gltf/computeObjectBoundingSphere.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,0DAFa,OAAO,CA4DnB;oBApEmB,kCAAkC"}

package/src/engine/asset/loaders/gltf/computeObjectBoundingSphere.js

@@ -1,70 +0,0 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
-import Vector4 from "../../../../core/geom/Vector4.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { isMesh } from "./isMesh.js";
-import { rootObject3DFastMatrixUpdate } from "../../../graphics/ecs/mesh/rootObject3DFastMatrixUpdate.js";
-
-/**
- *
- * @param {Object3D} o
- * @returns {Vector4} center is x,y,z while radius is w
- */
-export function computeObjectBoundingSphere(o) {
-    /*
-    TODO: There are better ways of doing this:
-    https://github.com/CGAL/cgal/blob/c68cf8fc4c850f8cd84c6900faa781286a7117ed/Bounding_volumes/include/CGAL/Min_sphere_of_spheres_d/Min_sphere_of_spheres_d_impl.h
-    */
-
-    /**
-     * Individual geometry-bounding spheres comprising the object
-     * @type {Sphere[]}
-     */
-    const balls = [];
-
-    rootObject3DFastMatrixUpdate(o);
-
-    o.traverse(m => {
-        if (isMesh(m)) {
-            const geometry = m.geometry;
-
-            const sphere = geometry.boundingSphere.clone();
-
-            if (m !== o) {
-                sphere.applyMatrix4(m.matrixWorld);
-            }
-
-            balls.push(sphere);
-        }
-    });
-
-    // compute overall center
-    const center = new Vector3();
-
-    const numBalls = balls.length;
-    for (let i = 0; i < numBalls; i++) {
-        const sphere = balls[i];
-        center.add(sphere.center);
-    }
-
-    if (numBalls > 0) {
-        center.multiplyScalar(1 / numBalls);
-    }
-
-    // compute radius of the main sphere by computing the largest distance from the overall center to the edge of each individual sphere
-    let radius = 0;
-
-    for (let i = 0; i < numBalls; i++) {
-        const sphere = balls[i];
-
-        const distance_to_ball_edge = center.distanceTo(sphere.center) + sphere.radius;
-
-        radius = max2(radius, distance_to_ball_edge);
-    }
-
-    return new Vector4(
-        center.x,
-        center.y,
-        center.z,
-        radius
-    );
-}

package/src/engine/asset/loaders/gltf/isMesh.d.ts

@@ -1,7 +0,0 @@
-/**
- *
- * @param {Object3D|Mesh|SkinnedMesh} o
- * @returns {boolean}
- */
-export function isMesh(o: Object3D | Mesh | SkinnedMesh): boolean;
-//# sourceMappingURL=isMesh.d.ts.map

package/src/engine/asset/loaders/gltf/isMesh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/gltf/isMesh.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,0BAHW,6BAAyB,GACvB,OAAO,CAInB"}

package/src/engine/asset/loaders/gltf/isMesh.js

@@ -1,8 +0,0 @@
-/**
- *
- * @param {Object3D|Mesh|SkinnedMesh} o
- * @returns {boolean}
- */
-export function isMesh(o) {
-    return o.isMesh || o.isSkinnedMesh;
-}

package/src/engine/asset/loaders/image/jpeg/JpegFrame.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"JpegFrame.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegFrame.js"],"names":[],"mappings":"AAAA;IACI;;;OAGG;IACH,UAFU,OAAO,CAEA;IACjB;;;OAGG;IACH,aAFU,OAAO,CAEG;IACpB;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,WAFU,MAAM,CAEF;IACd;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB,aAAS;IACT,aAAS;IAET,oBAAgB;IAChB,sBAAkB;IAElB;;;;;OAKG;IACH,YAFU,IAAI,MAAM,qBAAqB,CAElB;IAEvB;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEG;CACxB"}

package/src/engine/asset/loaders/image/jpeg/JpegFrameComponent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"JpegFrameComponent.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegFrameComponent.js"],"names":[],"mappings":"AAAA;IACI;;;OAGG;IACH,GAFU,MAAM,CAEX;IACL;;;OAGG;IACH,GAFU,MAAM,CAEX;IAEL;;OAEG;IACH,MAFU,MAAM,CAER;IAER;;OAEG;IACH,QAFU,UAAU,EAAE,EAAE,CAElB;IAEN,sBAAiB;IACjB,wBAAmB;IAEnB;;;;OAIG;IACH,iBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,mBAFU,UAAU,CAEF;IAElB;;;OAGG;IACH,gBAFU,EAAE,CAEE;IAEd;;;OAGG;IACH,gBAFU,EAAE,CAEE;CACjB"}

package/src/engine/asset/loaders/image/jpeg/JpegImage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"JpegImage.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/jpeg/JpegImage.js"],"names":[],"mappings":"AA6IA;IAEI;;;OAGG;IACH,YAFW,UAAU,QAyWpB;IAvRG;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEA;IA0DE,uBAAqD;IAsMzE,cAAiC;IACjC,eAA6B;IAC7B;;;;;;;;;;;MAAgB;IAChB;;;;;MAAkB;IAElB;;;OAGG;IACH,YAFU;QAAC,KAAK,EAAC,UAAU,EAAE,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAA;KAAC,EAAE,CAE1C;IAYxB;;;;;;;;;;OAUG;IACH,0BAUC;IAED;;;;;;;;;;OAUG;IACH,eAJW,MAAM,UACN,MAAM,GACL,UAAU,CAqDrB;IAED;;;;OAIG;IACH;cAHiB,UAAU;eAAQ,MAAM;gBAAS,MAAM;sBAC7C,OAAO,QA+DjB;CACJ"}