@woosh/meep-engine 3.14.1 → 3.14.3

package/src/format/texture/basis/uastc/uastc_to_astc.js

@@ -0,0 +1,421 @@
+import { ASTC_BLOCK_BYTES } from "../astc_block.js";
+import { astc_write_integer_sequence } from "../astc_integer_sequence.js";
+import { astc_find_partition_seed } from "../astc_partition.js";
+import { uastc_decode_block, UASTC_BLOCK_BYTES } from "./uastc_decode_block.js";
+import {
+    UASTC_MODE_BY_INDEX,
+    UASTC_MODE_SOLID,
+    UASTC_PATTERNS_2,
+    UASTC_PATTERNS_2_BC7_3,
+    UASTC_PATTERNS_3,
+    UASTC_WEIGHT_LEVELS
+} from "./uastc_tables.js";
+
+/**
+ * Where each field of an ASTC block begins, counting from the least significant bit.
+ *
+ * @readonly
+ */
+const BLOCK_MODE_BIT = 0;
+const PARTITION_COUNT_BIT = 11;
+const PARTITION_SEED_BIT = 13;
+const CEM_SINGLE_BIT = 13;
+const CEM_SELECTOR_BIT = 23;
+const CEM_SHARED_BIT = 25;
+
+/**
+ * The one mode whose two subsets are indexed by the three-subset pattern table UASTC took from BC7.
+ *
+ * @readonly
+ * @type {number}
+ */
+const MODE_BC7_3_SUBSET_PATTERNS = 7;
+
+/**
+ * The ASTC weight-range field for a UASTC one, as `(R, H)`.
+ *
+ * A block mode names its weight range through a three-bit `R` and the high-precision flag `H`, with
+ * `R` running 2 to 7 over six ranges at each `H`. UASTC uses five of the twelve — 2, 4, 8, 16 and 32
+ * levels — and this is where each sits.
+ *
+ * @readonly
+ * @type {Object<number, {r: number, h: number}>}
+ */
+const WEIGHT_RANGE_FIELD = {
+    0: { r: 2, h: 0 },   // 2 levels
+    2: { r: 4, h: 0 },   // 4
+    5: { r: 7, h: 0 },   // 8
+    8: { r: 4, h: 1 },   // 16
+    11: { r: 7, h: 1 },  // 32
+};
+
+/**
+ * The 4x4 single-plane and dual-plane block modes, by UASTC weight range.
+ *
+ * **Assembled from the specification's layout rather than tabulated.** The low-precision row places
+ * `D` at bit 10, `H` at 9, the height term `B` at 8:7, the width term `A` at 6:5, `R0` at 4, two
+ * zero bits at 3:2, then `R2` and `R1` at 1:0 — with the grid `A+2` wide by `B+4` high. A 4x4 grid is
+ * therefore `A = 2, B = 0`, and everything else follows from the range.
+ *
+ * @param {number} weight_range UASTC's range index
+ * @param {boolean} dual_plane
+ * @returns {number} eleven bits
+ */
+function block_mode(weight_range, dual_plane) {
+    const { r, h } = WEIGHT_RANGE_FIELD[weight_range];
+
+    const a = 2;
+    const b = 0;
+
+    const r0 = r & 1;
+    const r1 = (r >> 1) & 1;
+    const r2 = (r >> 2) & 1;
+
+    return ((dual_plane ? 1 : 0) << 10)
+        | (h << 9)
+        | (b << 7)
+        | (a << 5)
+        | (r0 << 4)
+        | (r2 << 1)
+        | r1;
+}
+
+/**
+ * The ASTC partition seed and subset relabelling for every UASTC pattern, worked out once.
+ *
+ * **Derived by search, not copied.** UASTC names a pattern by index into its own list and ASTC names
+ * one by a seed into a hash over 1024 possibilities; the correspondence is a table of numbers that
+ * exists in the reference transcoder. Searching for it here means a wrong entry cannot survive —
+ * there is no entry, only a seed whose pattern is required to agree texel for texel.
+ *
+ * Built lazily so the search is paid for once per process and only by a caller that transcodes.
+ *
+ * @param {Uint8Array} table the flat pattern list
+ * @param {number} count how many patterns it holds
+ * @param {number} partition_count
+ * @returns {{seed: number, permutation: number[]}[]}
+ */
+function seeds_for(table, count, partition_count) {
+    const out = [];
+
+    for (let pattern = 0; pattern < count; pattern++) {
+        const wanted = table.subarray(pattern * 16, pattern * 16 + 16);
+
+        const found = astc_find_partition_seed(wanted, partition_count);
+
+        if (found === undefined) {
+            throw new Error(
+                `UASTC: pattern ${pattern} of the ${partition_count}-subset table has no ASTC`
+                + ` partition seed, which cannot happen for a pattern UASTC took from ASTC — the`
+                + ` partition hash or the pattern table is wrong.`
+            );
+        }
+
+        out.push(found);
+    }
+
+    return out;
+}
+
+/**
+ * @type {{seed: number, permutation: number[]}[][]}
+ */
+let seed_tables;
+
+/**
+ * @returns {{two: object[], three: object[], two_bc7_3: object[]}}
+ */
+function partition_seeds() {
+    if (seed_tables === undefined) {
+        seed_tables = {
+            two: seeds_for(UASTC_PATTERNS_2, 30, 2),
+            three: seeds_for(UASTC_PATTERNS_3, 11, 3),
+            two_bc7_3: seeds_for(UASTC_PATTERNS_2_BC7_3, 19, 2),
+        };
+    }
+
+    return seed_tables;
+}
+
+/**
+ * Transcode UASTC to ASTC 4x4 by repacking, which is what the format was built for.
+ *
+ * **Nothing is fitted and nothing is lost.** UASTC's nineteen modes were laid out so that each one's
+ * fields *are* an ASTC block's fields: the endpoints are already in ASTC's quantized space at a range
+ * ASTC names, the weights are already ASTC weights, and the partition patterns were taken from
+ * ASTC's own hash. What is left is arithmetic on bit positions — ASTC interleaves its integer
+ * sequences where UASTC keeps them in two plain runs, and puts its weights at the far end of the
+ * block in reverse.
+ *
+ * That is the whole difference between this and the re-encode measured at 34.9 dB in §9.18. A
+ * re-encode has to choose one colour line for a block that may have three, which is exactly what a
+ * normal map is worst at; a repack keeps the three the file already had.
+ *
+ * **Endpoints may be swapped, which is lossless.** Colour endpoint modes 8 and 12 swap their pair and
+ * blue-contract when the second endpoint's channel sum falls below the first's. UASTC guarantees the
+ * order it needs for BC7's rules rather than ASTC's, so a subset that would trip the rule has its
+ * pair exchanged and its weights inverted — the same block, described the other way up.
+ *
+ * @param {Uint8Array} blocks UASTC blocks, tightly packed
+ * @param {number} block_count
+ * @returns {Uint8Array} tightly packed ASTC blocks, in raster order
+ * @throws {Error} for a mode this cannot express
+ *
+ * @see the UASTC LDR 4x4 specification, "Converting to ASTC"
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function uastc_to_astc(blocks, block_count) {
+    const out = new Uint8Array(block_count * ASTC_BLOCK_BYTES);
+
+    const seeds = partition_seeds();
+
+    for (let block = 0; block < block_count; block++) {
+        const decoded = uastc_decode_block(blocks, block * UASTC_BLOCK_BYTES);
+
+        write_astc(out, block * ASTC_BLOCK_BYTES, decoded, seeds);
+    }
+
+    return out;
+}
+
+/**
+ * Compose one ASTC block from a decoded UASTC one.
+ *
+ * @param {Uint8Array} out
+ * @param {number} offset
+ * @param {object} decoded from {@link uastc_decode_block}
+ * @param {object} seeds
+ */
+function write_astc(out, offset, decoded, seeds) {
+    if (decoded.mode === UASTC_MODE_SOLID) {
+        write_void_extent(out, offset, decoded.endpoints);
+
+        return;
+    }
+
+    const mode = UASTC_MODE_BY_INDEX[decoded.mode];
+
+    const levels = UASTC_WEIGHT_LEVELS[mode.weight_range];
+
+    const weight_bits = Math.log2(levels);
+
+    const subsets = mode.subsets;
+
+    const endpoints = [...decoded.endpoints_quantised];
+    const weights = Uint8Array.from(decoded.weight_indices);
+
+    disable_blue_contraction(mode, decoded, endpoints, weights, levels);
+
+    let seed = 0;
+    let permutation = [0];
+
+    if (subsets > 1) {
+        /*
+         Three tables, and which one a mode reads is a property of the mode rather than of its subset
+         count alone: mode 7 has two subsets but indexes the nineteen patterns UASTC borrowed from
+         BC7's three-subset set, which it then folds down to two.
+        */
+        const table = mode.mode === MODE_BC7_3_SUBSET_PATTERNS
+            ? seeds.two_bc7_3
+            : (subsets === 3 ? seeds.three : seeds.two);
+
+        const chosen = table[decoded.pattern];
+
+        seed = chosen.seed;
+        permutation = chosen.permutation;
+    }
+
+    /*
+     **The two number their subsets the same way, and this is where that is checked.** A seed found
+     by search is only required to *group* the texels as UASTC does; which group it calls subset 0 is
+     the hash's business, and in general an encoder would have to reorder its endpoint pairs to
+     match. In fact no pattern ever needs it — all 60 across the three tables come back as the
+     identity, which follows from UASTC having taken its patterns from ASTC in the first place.
+
+     So there is no reordering code here, because code that never runs is code that is never right.
+     If a pattern ever did need it the block would be silently wrong, and this refuses instead.
+
+     **Deleting this will not fail a test, and it should still not be deleted.** It cannot fire while
+     the pattern tables and the partition hash both stay as they are, which is exactly the pair of
+     assumptions it exists to catch someone breaking.
+    */
+    if (permutation.some((to, from) => to !== from)) {
+        throw new Error(
+            `UASTC: pattern ${decoded.pattern} maps to ASTC seed ${seed} with its subsets renumbered`
+            + ` (${permutation.join(", ")}), which no UASTC pattern does. The endpoint pairs would`
+            + ` have to be reordered to match, and nothing here does that.`
+        );
+    }
+
+    const ordered = endpoints;
+
+    let bits = 0n;
+
+    const put = (value, width, at) => {
+        bits |= (BigInt(value) & ((1n << BigInt(width)) - 1n)) << BigInt(at);
+    };
+
+    put(block_mode(mode.weight_range, mode.dual_plane), 11, BLOCK_MODE_BIT);
+    put(subsets - 1, 2, PARTITION_COUNT_BIT);
+
+    let cursor;
+
+    if (subsets === 1) {
+        put(mode.cem, 4, CEM_SINGLE_BIT);
+        cursor = 17;
+    } else {
+        put(seed, 10, PARTITION_SEED_BIT);
+
+        // selector 00 means every partition shares one mode, which is always true of a UASTC block
+        put(0, 2, CEM_SELECTOR_BIT);
+        put(mode.cem, 4, CEM_SHARED_BIT);
+
+        cursor = 29;
+    }
+
+    astc_write_integer_sequence(
+        (value, width) => {
+            put(value, width, cursor);
+            cursor += width;
+        },
+        ordered,
+        mode.endpoint_range
+    );
+
+    if (mode.dual_plane) {
+        // the component selector sits immediately below the weights, at the top of the block
+        put(decoded.component_selector, 2, 128 - 16 * 2 * weight_bits - 2);
+    }
+
+    /*
+     The weights fill the top of the block with the whole field's bit order reversed, and a dual-plane
+     block interleaves its two planes texel by texel. Every range UASTC uses is a power of two, so
+     these are plain bits with no integer sequence to interleave.
+    */
+    const plane_count = mode.dual_plane ? 2 : 1;
+
+    let field = 0n;
+
+    for (let i = 0; i < 16 * plane_count; i++) {
+        field |= BigInt(weights[i]) << BigInt(i * weight_bits);
+    }
+
+    const width = 16 * plane_count * weight_bits;
+
+    for (let i = 0; i < width; i++) {
+        if ((field >> BigInt(i)) & 1n) {
+            bits |= 1n << BigInt(127 - i);
+        }
+    }
+
+    for (let i = 0; i < ASTC_BLOCK_BYTES; i++) {
+        out[offset + i] = Number((bits >> BigInt(i * 8)) & 0xFFn);
+    }
+}
+
+/**
+ * Put each subset's endpoints the way round that stops a decoder blue-contracting them.
+ *
+ * **Colour endpoint modes 8 and 12 have a rule with no flag.** A decoder compares the two endpoints
+ * by the sum of their colour channels, and where the second falls below the first it swaps the pair
+ * *and* applies blue contraction — `r = (r + b) >> 1`, `g = (g + b) >> 1` — to both. That is a
+ * different picture rather than an inverted one, and nothing in the block records that it happened.
+ *
+ * UASTC orders its endpoints to suit BC7's rules, which are not these, so a subset can easily arrive
+ * the wrong way round. Exchanging the pair and inverting that subset's weights describes the same
+ * block the other way up, which is why the specification calls this lossless — and it has to be done
+ * per subset, since each has its own pair and its own texels.
+ *
+ * Modes 4 and 6 have no such rule and are left alone; comparing sums there would swap pairs for
+ * nothing and change what the block decodes to.
+ *
+ * @param {object} mode the UASTC mode descriptor
+ * @param {object} decoded
+ * @param {number[]} endpoints quantised values, modified in place
+ * @param {Uint8Array} weights modified in place
+ * @param {number} levels how many weight levels the mode has
+ */
+function disable_blue_contraction(mode, decoded, endpoints, weights, levels) {
+    if (mode.cem !== 8 && mode.cem !== 12) {
+        return;
+    }
+
+    const values_per_subset = endpoints.length / mode.subsets;
+
+    const plane_count = mode.dual_plane ? 2 : 1;
+
+    for (let subset = 0; subset < mode.subsets; subset++) {
+        /*
+         The comparison is on the *decoded* colours, which is what the rule is written over. The
+         quantised values are monotonic in them per channel but not comparable across channels at
+         different ranges, so summing those instead would disagree on the blocks nearest the boundary
+         — the ones where getting it wrong is least visible and most likely.
+        */
+        const base = subset * 8;
+
+        const first = decoded.endpoints[base] + decoded.endpoints[base + 1] + decoded.endpoints[base + 2];
+        const second = decoded.endpoints[base + 4] + decoded.endpoints[base + 5] + decoded.endpoints[base + 6];
+
+        if (second >= first) {
+            continue;
+        }
+
+        for (let pair = 0; pair < values_per_subset; pair += 2) {
+            const at = subset * values_per_subset + pair;
+
+            const swap = endpoints[at];
+
+            endpoints[at] = endpoints[at + 1];
+            endpoints[at + 1] = swap;
+        }
+
+        for (let texel = 0; texel < 16; texel++) {
+            if (decoded.partition[texel] !== subset) {
+                continue;
+            }
+
+            for (let plane = 0; plane < plane_count; plane++) {
+                const at = texel * plane_count + plane;
+
+                weights[at] = levels - 1 - weights[at];
+            }
+        }
+    }
+}
+
+/**
+ * Write a void-extent block: one colour over the whole block, which is UASTC's solid mode.
+ *
+ * The magic `0x1FC` in the low bits is what marks a block void-extent rather than a weight grid, and
+ * the four `0x1FFF` coordinates are the "unused" extent that tells a decoder not to try to
+ * interpolate across neighbouring blocks. The colour is stored as four 16-bit channels, so an 8-bit
+ * value is replicated into both halves.
+ *
+ * @param {Uint8Array} out
+ * @param {number} offset
+ * @param {Uint8Array} endpoints the solid colour occupies the first four bytes
+ */
+function write_void_extent(out, offset, endpoints) {
+    /*
+     Bits 0 to 8 mark the block void-extent, bit 9 says the colour is LDR rather than HDR, and bits
+     10 and 11 are reserved and set. Leaving those two clear is a block a decoder is entitled to
+     reject, and it is the only thing that separated this from the reference's own solid blocks.
+    */
+    let bits = 0x1FCn | (0b11n << 10n);
+
+    // the two dimensions' extents, all ones, meaning "no extent to speak of"
+    for (let i = 0; i < 4; i++) {
+        bits |= 0x1FFFn << BigInt(12 + i * 13);
+    }
+
+    for (let channel = 0; channel < 4; channel++) {
+        const value = endpoints[channel];
+
+        bits |= BigInt((value << 8) | value) << BigInt(64 + channel * 16);
+    }
+
+    for (let i = 0; i < ASTC_BLOCK_BYTES; i++) {
+        out[offset + i] = Number((bits >> BigInt(i * 8)) & 0xFFn);
+    }
+}

package/src/format/texture/basis/uastc/uastc_to_bc5.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Transcode UASTC blocks to BC5.
+ *
+ * **This is the path a normal map takes, and the reason it is worth having separately.** A
+ * tangent-space normal's Z is positive by construction and is reconstructed from XY in the shader,
+ * so the blue channel of a normal map carries nothing — which is what lets `bc5-rg-unorm` spend on
+ * two channels the same eight bits per texel that BC7 spends on four. `texture_format_preference`
+ * has led with BC5 for the normal role since step 3b, and until now nothing could produce one from
+ * a Basis payload.
+ *
+ * **Two independent channels, so the encode is near-optimal rather than approximate.** BC5 is two
+ * BC4 blocks and a BC4 block is a scalar line: the endpoints are the channel's own extremes over the
+ * block, and every texel then picks the nearest of eight evenly spaced values between them. There is
+ * no endpoint fitting to do because there is no direction to get wrong — the thing that makes
+ * {@link etc1s_to_bc1} hard is choosing a line through three-dimensional colour, and a single
+ * channel has none.
+ *
+ * @param {Uint8Array} blocks UASTC blocks, tightly packed
+ * @param {number} block_count
+ * @returns {Uint8Array} tightly packed BC5 blocks, in raster order
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function uastc_to_bc5(blocks: Uint8Array, block_count: number): Uint8Array;
+//# sourceMappingURL=uastc_to_bc5.d.ts.map

package/src/format/texture/basis/uastc/uastc_to_bc5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uastc_to_bc5.d.ts","sourceRoot":"","sources":["../../../../../../src/format/texture/basis/uastc/uastc_to_bc5.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qCAPW,UAAU,eACV,MAAM,GACJ,UAAU,CA0BtB"}

package/src/format/texture/basis/uastc/uastc_to_bc5.js

@@ -0,0 +1,115 @@
+import { BC4_BLOCK_BYTES, bc4_write_block } from "../../bc/bc4_write_block.js";
+import { uastc_block_texels, uastc_decode_block, UASTC_BLOCK_BYTES } from "./uastc_decode_block.js";
+
+/**
+ * Bytes one BC5 block occupies: two BC4 blocks, one per channel.
+ *
+ * @readonly
+ * @type {number}
+ */
+const BC5_BLOCK_BYTES = 16;
+
+/**
+ * Transcode UASTC blocks to BC5.
+ *
+ * **This is the path a normal map takes, and the reason it is worth having separately.** A
+ * tangent-space normal's Z is positive by construction and is reconstructed from XY in the shader,
+ * so the blue channel of a normal map carries nothing — which is what lets `bc5-rg-unorm` spend on
+ * two channels the same eight bits per texel that BC7 spends on four. `texture_format_preference`
+ * has led with BC5 for the normal role since step 3b, and until now nothing could produce one from
+ * a Basis payload.
+ *
+ * **Two independent channels, so the encode is near-optimal rather than approximate.** BC5 is two
+ * BC4 blocks and a BC4 block is a scalar line: the endpoints are the channel's own extremes over the
+ * block, and every texel then picks the nearest of eight evenly spaced values between them. There is
+ * no endpoint fitting to do because there is no direction to get wrong — the thing that makes
+ * {@link etc1s_to_bc1} hard is choosing a line through three-dimensional colour, and a single
+ * channel has none.
+ *
+ * @param {Uint8Array} blocks UASTC blocks, tightly packed
+ * @param {number} block_count
+ * @returns {Uint8Array} tightly packed BC5 blocks, in raster order
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function uastc_to_bc5(blocks, block_count) {
+    const out = new Uint8Array(block_count * BC5_BLOCK_BYTES);
+
+    const texels = new Uint8Array(64);
+    const channel = new Uint8Array(16);
+
+    for (let block = 0; block < block_count; block++) {
+        uastc_block_texels(
+            uastc_decode_block(blocks, block * UASTC_BLOCK_BYTES), texels, 0
+        );
+
+        for (let c = 0; c < 2; c++) {
+            for (let texel = 0; texel < 16; texel++) {
+                channel[texel] = texels[texel * 4 + c];
+            }
+
+            write_bc4(out, block * BC5_BLOCK_BYTES + c * BC4_BLOCK_BYTES, channel);
+        }
+    }
+
+    return out;
+}
+
+/**
+ * Write one channel's sixteen values as a BC4 block.
+ *
+ * @param {Uint8Array} out
+ * @param {number} offset
+ * @param {Uint8Array} values sixteen
+ */
+function write_bc4(out, offset, values) {
+    let low = 255;
+    let high = 0;
+
+    for (let i = 0; i < 16; i++) {
+        if (values[i] < low) {
+            low = values[i];
+        }
+
+        if (values[i] > high) {
+            high = values[i];
+        }
+    }
+
+    /*
+     Eight-value mode, which needs the first endpoint to compare greater. A block of one value would
+     make them equal and select the six-value mode, whose last two indices decode to 0 and 255 —
+     harmless here, since every texel would index the endpoint itself, but the endpoints are nudged
+     apart anyway so the block means what it looks like it means.
+    */
+    if (high === low) {
+        if (high < 255) {
+            high += 1;
+        } else {
+            low -= 1;
+        }
+    }
+
+    /*
+     Index 0 is the high endpoint, index 1 the low, and 2 through 7 are six evenly spaced steps
+     between them — so a value's index is not simply its position along the line, and the mapping
+     below is what BC4's ordering costs.
+    */
+    const range = high - low;
+
+    for (let texel = 0; texel < 16; texel++) {
+        const step = Math.round(((values[texel] - low) * 7) / range);
+
+        INDICES[texel] = step === 7 ? 0 : step === 0 ? 1 : 8 - step;
+    }
+
+    bc4_write_block(out, offset, high, low, INDICES);
+}
+
+/**
+ * Scratch for {@link write_bc4}'s sixteen indices, so a block does not allocate.
+ *
+ * @type {Uint8Array}
+ */
+const INDICES = new Uint8Array(16);

package/src/format/texture/basis/uastc/uastc_to_bc7.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Transcode UASTC blocks to BC7.
+ *
+ * **Every UASTC mode is carried into the BC7 mode the specification pairs it with**, rather than
+ * decoded to texels and re-encoded. A UASTC block already *is* a partition, a pair of endpoints per
+ * subset and a weight per texel, which is exactly what BC7 stores — so the transcode is a change of
+ * representation and the only loss is endpoint precision. Re-fitting from texels instead costs
+ * around eighteen decibels on the dual plane modes and far more on the partitioned ones, because it
+ * throws away the answer the encoder already found.
+ *
+ * The pairings, all from the specification's mode table:
+ *
+ * | UASTC | BC7 | why |
+ * |---|---|---|
+ * | 0, 1, 5, 10, 12, 14, 15, 18 | 6 | one subset, one index set |
+ * | 8 | 6 | a solid colour, which BC7 has no mode for and mode 6 holds exactly |
+ * | 6, 11, 13, 17 | 5 | dual plane — one channel with its own weights, which BC7 spells as a rotation |
+ * | 2 | 1 | two subsets, three-bit weights |
+ * | 4 | 3 | two subsets, two-bit weights, seven-bit endpoints |
+ * | 9, 16 | 7 | two subsets with alpha |
+ * | 3 | 2 | three subsets |
+ * | 7 | 2 | two subsets in UASTC, three in BC7 — two of BC7's endpoint pairs are written alike |
+ *
+ * **The weights need no remapping.** ASTC's two- and three-bit weight tables are BC7's, and the
+ * four-bit ones agree too, so an index crosses over as itself. Where a UASTC mode's weight range is
+ * finer than the BC7 mode's index — only mode 18, at five bits — the nearest is taken.
+ *
+ * @param {Uint8Array} blocks UASTC blocks, tightly packed
+ * @param {number} block_count
+ * @returns {Uint8Array} tightly packed BC7 blocks, in raster order
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function uastc_to_bc7(blocks: Uint8Array, block_count: number): Uint8Array;
+//# sourceMappingURL=uastc_to_bc7.d.ts.map

package/src/format/texture/basis/uastc/uastc_to_bc7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uastc_to_bc7.d.ts","sourceRoot":"","sources":["../../../../../../src/format/texture/basis/uastc/uastc_to_bc7.js"],"names":[],"mappings":"AA2EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qCAPW,UAAU,eACV,MAAM,GACJ,UAAU,CAkCtB"}