@manycore/aholo-splat-transform 1.2.6

package/dist/file/sog.js

@@ -0,0 +1,504 @@
+import { unzipSync, zipSync } from 'fflate';
+import { Buffer } from 'node:buffer';
+import { decodeWebP, encodeWebP, WebPLosslessProfile } from '../native/index.js';
+import { SH_C0, SH_MAPS, NUM_F_REST_TO_SH_DEGREE } from '../constant.js';
+import { getOrCreateDevice, kmeans, logger, mortonSort, quantize1d, isUrl, extractFromRootDir, clamp } from '../utils/index.js';
+const ZIP_MAGIC = 0x04034b50;
+const PERM_TABLE = [
+    [0, 1, 2, 3],
+    [3, 1, 2, 0],
+    [1, 3, 2, 0],
+    [1, 2, 3, 0],
+];
+const TEMP_ROT = new Float32Array(4);
+function logTransform(value) {
+    return Math.sign(value) * Math.log(Math.abs(value) + 1);
+}
+;
+function writeTableData(table, indices, width, height, channels = 4) {
+    const data = new Uint8Array(width * height * channels);
+    const numColumns = table.length;
+    for (let i = 0; i < indices.length; ++i) {
+        const idx = indices[i];
+        data[i * channels + 0] = table[0][idx];
+        data[i * channels + 1] = numColumns > 1 ? table[1][idx] : 0;
+        data[i * channels + 2] = numColumns > 2 ? table[2][idx] : 0;
+        data[i * channels + 3] = numColumns > 3 ? table[3][idx] : 255;
+    }
+    return data;
+}
+function buildSHTableMap(shCoeffs) {
+    const result = [];
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < shCoeffs; j++) {
+            result.push(j * 3 + i);
+        }
+    }
+    return result;
+}
+export class SogFile {
+    iterations;
+    counts = 0;
+    shDegree = 0;
+    /**
+     * @internal
+     */
+    version;
+    /**
+     * @internal
+     */
+    meta;
+    /**
+     * @internal
+     */
+    refs = {};
+    cached;
+    constructor(iterations = 10) {
+        this.iterations = iterations;
+    }
+    async load(stream, contentLength) {
+        const buffer = new Uint8Array(contentLength);
+        const reader = stream.getReader();
+        let offset = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer.set(value, offset);
+            offset += value.length;
+        }
+        let metaBuffer = buffer;
+        const view = new DataView(buffer.buffer);
+        if (view.getUint32(0, true) === ZIP_MAGIC) {
+            this.refs = extractFromRootDir(unzipSync(buffer));
+            metaBuffer = this.refs['meta.json'];
+            if (!metaBuffer) {
+                throw new Error('SOG meta.json not found in the zip archive.');
+            }
+        }
+        this.meta = JSON.parse(new TextDecoder().decode(metaBuffer));
+        if (this.meta.version === undefined) {
+            const { means, quats, shN } = this.meta;
+            if (quats.encoding !== 'quaternion_packed') {
+                throw new Error('Unsupported quaternion encoding');
+            }
+            this.counts = means.shape[0];
+            this.shDegree = shN ? NUM_F_REST_TO_SH_DEGREE[shN.shape[1]] : 0;
+            this.version = 1;
+        }
+        else {
+            const { version, count, shN } = this.meta;
+            if (version !== 2) {
+                throw new Error(`Unsupported SOGS version: ${version}`);
+            }
+            this.counts = count;
+            this.shDegree = shN?.bands ?? 0;
+            this.version = version;
+        }
+    }
+    parse_v1(data, offset) {
+        const setFn = data.set.bind(data);
+        const setShFn = data.setShN.bind(data);
+        const { meta, counts, shDegree, cached } = this;
+        const [mean0, mean1, scale0, quat0, color0, centroids, labels] = cached.map(v => v.data);
+        const { means: { mins: [centerMinX, centerMinY, centerMinZ], maxs: [centerMaxX, centerMaxY, centerMaxZ] }, scales: { mins: [scaleMinX, scaleMinY, scaleMinZ], maxs: [scaleMaxX, scaleMaxY, scaleMaxZ] }, sh0: { mins: [colorMinR, colorMinG, colorMinB, colorMinA], maxs: [colorMaxR, colorMaxG, colorMaxB, colorMaxA], }, shN, } = meta;
+        const rangeX = (centerMaxX - centerMinX) / 65535;
+        const rangeY = (centerMaxY - centerMinY) / 65535;
+        const rangeZ = (centerMaxZ - centerMinZ) / 65535;
+        const SX_LUT = new Float32Array(256);
+        const SY_LUT = new Float32Array(256);
+        const SZ_LUT = new Float32Array(256);
+        const scaleRangeX = (scaleMaxX - scaleMinX) / 255;
+        const scaleRangeY = (scaleMaxY - scaleMinY) / 255;
+        const scaleRangeZ = (scaleMaxZ - scaleMinZ) / 255;
+        for (let i = 0; i < 256; i++) {
+            SX_LUT[i] = Math.exp(scaleMinX + scaleRangeX * i);
+            SY_LUT[i] = Math.exp(scaleMinY + scaleRangeY * i);
+            SZ_LUT[i] = Math.exp(scaleMinZ + scaleRangeZ * i);
+        }
+        const A_LUT = new Float32Array(256);
+        const colorRangeR = (colorMaxR - colorMinR) / 255;
+        const colorRangeG = (colorMaxG - colorMinG) / 255;
+        const colorRangeB = (colorMaxB - colorMinB) / 255;
+        const colorRangeA = (colorMaxA - colorMinA) / 255;
+        for (let i = 0; i < 256; i++) {
+            A_LUT[i] = 1.0 / (1.0 + Math.exp(-(colorMinA + colorRangeA * i)));
+        }
+        const single = {
+            x: 0, y: 0, z: 0,
+            sx: 0, sy: 0, sz: 0,
+            qx: 0, qy: 0, qz: 0, qw: 0,
+            r: 0, g: 0, b: 0, a: 0,
+            shN: [],
+        };
+        for (let i = 0; i < counts; i++) {
+            const i4 = i * 4;
+            const x = centerMinX + rangeX * (mean0[i4 + 0] + (mean1[i4 + 0] << 8));
+            const y = centerMinY + rangeY * (mean0[i4 + 1] + (mean1[i4 + 1] << 8));
+            const z = centerMinZ + rangeZ * (mean0[i4 + 2] + (mean1[i4 + 2] << 8));
+            single.x = Math.sign(x) * (Math.exp(Math.abs(x)) - 1);
+            single.y = Math.sign(y) * (Math.exp(Math.abs(y)) - 1);
+            single.z = Math.sign(z) * (Math.exp(Math.abs(z)) - 1);
+            single.sx = SX_LUT[scale0[i4 + 0]];
+            single.sy = SY_LUT[scale0[i4 + 1]];
+            single.sz = SZ_LUT[scale0[i4 + 2]];
+            TEMP_ROT[0] = (quat0[i4 + 0] / 255 - 0.5) * Math.SQRT2;
+            TEMP_ROT[1] = (quat0[i4 + 1] / 255 - 0.5) * Math.SQRT2;
+            TEMP_ROT[2] = (quat0[i4 + 2] / 255 - 0.5) * Math.SQRT2;
+            TEMP_ROT[3] = Math.sqrt(Math.max(0, 1.0 - TEMP_ROT[0] * TEMP_ROT[0] - TEMP_ROT[1] * TEMP_ROT[1] - TEMP_ROT[2] * TEMP_ROT[2]));
+            const PERM = PERM_TABLE[quat0[i4 + 3] - 252];
+            single.qx = TEMP_ROT[PERM[0]];
+            single.qy = TEMP_ROT[PERM[1]];
+            single.qz = TEMP_ROT[PERM[2]];
+            single.qw = TEMP_ROT[PERM[3]];
+            single.r = SH_C0 * (colorMinR + colorRangeR * color0[i4 + 0]) + 0.5;
+            single.g = SH_C0 * (colorMinG + colorRangeG * color0[i4 + 1]) + 0.5;
+            single.b = SH_C0 * (colorMinB + colorRangeB * color0[i4 + 2]) + 0.5;
+            single.a = A_LUT[color0[i4 + 3]];
+            setFn(offset + i, single);
+        }
+        if (shN) {
+            const centroidTexWidth = cached[5].width;
+            const { mins: min, maxs: max } = shN;
+            const range = (max - min) / 255;
+            const shCounts = SH_MAPS[shDegree];
+            const sh = new Array(shCounts);
+            const shCoeffs = shCounts / 3;
+            for (let i = 0; i < counts; i++) {
+                const i4 = i * 4;
+                const label = labels[i4] + (labels[i4 + 1] << 8);
+                const o = ((label >>> 6) * centroidTexWidth + (label & 63) * 15) * 4;
+                for (let j = 0; j < shCoeffs; j++) {
+                    sh[j * 3 + 0] = min + range * centroids[o + j * 4 + 0];
+                    sh[j * 3 + 1] = min + range * centroids[o + j * 4 + 1];
+                    sh[j * 3 + 2] = min + range * centroids[o + j * 4 + 2];
+                }
+                setShFn(offset + i, sh);
+            }
+        }
+    }
+    parse_v2(data, offset) {
+        const setFn = data.set.bind(data);
+        const setShFn = data.setShN.bind(data);
+        const { meta, counts, shDegree, cached } = this;
+        const { means, scales, sh0, shN } = meta;
+        const { mins: [centerMinX, centerMinY, centerMinZ], maxs: [centerMaxX, centerMaxY, centerMaxZ], } = means;
+        const { codebook: scaleCodebook } = scales;
+        const { codebook: sh0Codebook } = sh0;
+        const [mean0, mean1, scale0, quat0, color0, centroids, labels] = cached.map(img => img.data);
+        const rangeX = (centerMaxX - centerMinX) / 65535;
+        const rangeY = (centerMaxY - centerMinY) / 65535;
+        const rangeZ = (centerMaxZ - centerMinZ) / 65535;
+        const SCALE_LUT = scaleCodebook.map(v => Math.exp(v));
+        const single = {
+            x: 0, y: 0, z: 0,
+            sx: 0, sy: 0, sz: 0,
+            qx: 0, qy: 0, qz: 0, qw: 0,
+            r: 0, g: 0, b: 0, a: 0,
+            shN: [],
+        };
+        for (let i = 0; i < counts; i++) {
+            const i4 = i * 4;
+            const x = centerMinX + rangeX * (mean0[i4 + 0] + (mean1[i4 + 0] << 8));
+            const y = centerMinY + rangeY * (mean0[i4 + 1] + (mean1[i4 + 1] << 8));
+            const z = centerMinZ + rangeZ * (mean0[i4 + 2] + (mean1[i4 + 2] << 8));
+            single.x = Math.sign(x) * (Math.exp(Math.abs(x)) - 1);
+            single.y = Math.sign(y) * (Math.exp(Math.abs(y)) - 1);
+            single.z = Math.sign(z) * (Math.exp(Math.abs(z)) - 1);
+            single.sx = SCALE_LUT[scale0[i4 + 0]];
+            single.sy = SCALE_LUT[scale0[i4 + 1]];
+            single.sz = SCALE_LUT[scale0[i4 + 2]];
+            TEMP_ROT[0] = (quat0[i4 + 0] / 255 - 0.5) * Math.SQRT2;
+            TEMP_ROT[1] = (quat0[i4 + 1] / 255 - 0.5) * Math.SQRT2;
+            TEMP_ROT[2] = (quat0[i4 + 2] / 255 - 0.5) * Math.SQRT2;
+            TEMP_ROT[3] = Math.sqrt(Math.max(0, 1.0 - TEMP_ROT[0] * TEMP_ROT[0] - TEMP_ROT[1] * TEMP_ROT[1] - TEMP_ROT[2] * TEMP_ROT[2]));
+            const PERM = PERM_TABLE[quat0[i4 + 3] - 252];
+            single.qx = TEMP_ROT[PERM[0]];
+            single.qy = TEMP_ROT[PERM[1]];
+            single.qz = TEMP_ROT[PERM[2]];
+            single.qw = TEMP_ROT[PERM[3]];
+            single.r = SH_C0 * sh0Codebook[color0[i4 + 0]] + 0.5;
+            single.g = SH_C0 * sh0Codebook[color0[i4 + 1]] + 0.5;
+            single.b = SH_C0 * sh0Codebook[color0[i4 + 2]] + 0.5;
+            single.a = color0[i4 + 3] / 255;
+            setFn(offset + i, single);
+        }
+        if (shN) {
+            const { codebook } = shN;
+            const shCounts = SH_MAPS[shDegree];
+            const shCoeffs = shCounts / 3;
+            const offsetItemSize = shCoeffs * 4;
+            const sh = new Array(shCounts);
+            for (let i = 0; i < counts; i++) {
+                const i4 = i * 4;
+                const o = (labels[i4 + 0] + (labels[i4 + 1] << 8)) * offsetItemSize;
+                for (let j = 0; j < shCoeffs; j++) {
+                    sh[j * 3] = codebook[centroids[o + j * 4 + 0]];
+                    sh[j * 3 + 1] = codebook[centroids[o + j * 4 + 1]];
+                    sh[j * 3 + 2] = codebook[centroids[o + j * 4 + 2]];
+                }
+                setShFn(offset + i, sh);
+            }
+        }
+    }
+    async loadTexture(path) {
+        let buffer = this.refs[path];
+        if (!buffer) {
+            if (isUrl(path)) {
+                buffer = await fetch(path)
+                    .then(res => res.arrayBuffer())
+                    .then(buf => new Uint8Array(buf));
+            }
+        }
+        if (!buffer) {
+            throw new Error(`Cannot load texture: ${path}`);
+        }
+        const { data, width, height } = decodeWebP(buffer);
+        return {
+            data: new Uint8Array(data),
+            width,
+            height,
+        };
+    }
+    async read(stream, contentLength, data) {
+        await this.load(stream, contentLength);
+        const BlockOffset = await data.initBlock(this.counts, this.shDegree);
+        const { means, scales, quats, sh0, shN } = this.meta;
+        this.cached = await Promise.all([
+            means.files[0], means.files[1],
+            scales.files[0], quats.files[0],
+            sh0.files[0], shN?.files[0], shN?.files[1],
+        ].filter(path => !!path).map(path => this.loadTexture(path)));
+        if (this.version === 1) {
+            this.parse_v1(data, BlockOffset);
+        }
+        else if (this.version === 2) {
+            this.parse_v2(data, BlockOffset);
+        }
+        else {
+            throw new Error(`Unsupported SOG version: ${this.version}`);
+        }
+        data.finishBlock();
+    }
+    async write(stream, data, indices = mortonSort(data)) {
+        const { counts, shDegree, shCounts, table } = data;
+        const width = Math.ceil(Math.sqrt(counts) / 4) * 4;
+        const height = Math.ceil(counts / width / 4) * 4;
+        const channels = 4;
+        const single = {
+            x: 0, y: 0, z: 0,
+            sx: 0, sy: 0, sz: 0,
+            qx: 0, qy: 0, qz: 0, qw: 0,
+            r: 0, g: 0, b: 0, a: 0,
+            shN: new Array(shCounts),
+        };
+        const webPProfile = new WebPLosslessProfile();
+        const output = {};
+        const meta = {
+            version: 2,
+            count: counts,
+            means: {
+                mins: [],
+                maxs: [],
+                files: [
+                    'means_l.webp',
+                    'means_u.webp'
+                ]
+            },
+            scales: {
+                codebook: [],
+                files: ['scales.webp']
+            },
+            quats: {
+                files: ['quats.webp']
+            },
+            sh0: {
+                codebook: [],
+                files: ['sh0.webp']
+            }
+        };
+        // means
+        {
+            logger.time('SOG encoding means');
+            const xCol = table[0 /* ColIdx.x */];
+            const yCol = table[1 /* ColIdx.y */];
+            const zCol = table[2 /* ColIdx.z */];
+            // calculate minmax & transform
+            let minX = Infinity;
+            let minY = Infinity;
+            let minZ = Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            let maxZ = -Infinity;
+            for (let i = 0; i < counts; i++) {
+                const idx = indices[i];
+                const x = xCol[idx];
+                const y = yCol[idx];
+                const z = zCol[idx];
+                if (x < minX) {
+                    minX = x;
+                }
+                if (x > maxX) {
+                    maxX = x;
+                }
+                if (y < minY) {
+                    minY = y;
+                }
+                if (y > maxY) {
+                    maxY = y;
+                }
+                if (z < minZ) {
+                    minZ = z;
+                }
+                if (z > maxZ) {
+                    maxZ = z;
+                }
+            }
+            minX = logTransform(minX);
+            minY = logTransform(minY);
+            minZ = logTransform(minZ);
+            maxX = logTransform(maxX);
+            maxY = logTransform(maxY);
+            maxZ = logTransform(maxZ);
+            const scaleX = 65535 / Math.max(maxX - minX, 1e-9);
+            const scaleY = 65535 / Math.max(maxY - minY, 1e-9);
+            const scaleZ = 65535 / Math.max(maxZ - minZ, 1e-9);
+            // encode means
+            const meansL = new Uint8Array(width * height * channels).fill(0xff);
+            const meansU = new Uint8Array(width * height * channels).fill(0xff);
+            for (let i = 0; i < indices.length; i++) {
+                const idx = indices[i];
+                const x = (logTransform(xCol[idx]) - minX) * scaleX;
+                const y = (logTransform(yCol[idx]) - minY) * scaleY;
+                const z = (logTransform(zCol[idx]) - minZ) * scaleZ;
+                meansL[i * 4 + 0] = x & 0xff;
+                meansL[i * 4 + 1] = y & 0xff;
+                meansL[i * 4 + 2] = z & 0xff;
+                meansU[i * 4 + 0] = (x >> 8) & 0xff;
+                meansU[i * 4 + 1] = (y >> 8) & 0xff;
+                meansU[i * 4 + 2] = (z >> 8) & 0xff;
+            }
+            output['means_l.webp'] = encodeWebP(meansL, width, height, webPProfile);
+            output['means_u.webp'] = encodeWebP(meansU, width, height, webPProfile);
+            meta.means.mins = [minX, minY, minZ];
+            meta.means.maxs = [maxX, maxY, maxZ];
+            logger.timeEnd('SOG encoding means');
+        }
+        // quaternions
+        {
+            logger.time('SOG encoding quaternions');
+            const quats = new Uint8Array(width * height * channels);
+            const q = [0, 0, 0, 0];
+            for (let i = 0; i < indices.length; ++i) {
+                data.getQuat(indices[i], single);
+                q[0] = single.qw;
+                q[1] = single.qx;
+                q[2] = single.qy;
+                q[3] = single.qz;
+                const l = Math.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3]);
+                // normalize
+                q.forEach((v, j) => {
+                    q[j] = v / l;
+                });
+                // find max component
+                const maxComp = q.reduce((v, _, i) => (Math.abs(q[i]) > Math.abs(q[v]) ? i : v), 0);
+                // invert if max component is negative
+                if (q[maxComp] < 0) {
+                    q.forEach((v, j) => {
+                        q[j] *= -1;
+                    });
+                }
+                // scale by sqrt(2) to fit in [-1, 1] range
+                q.forEach((v, j) => q[j] *= Math.SQRT2);
+                const idx = [
+                    [1, 2, 3],
+                    [0, 2, 3],
+                    [0, 1, 3],
+                    [0, 1, 2]
+                ][maxComp];
+                quats[i * 4] = (q[idx[0]] * 0.5 + 0.5) * 255;
+                quats[i * 4 + 1] = (q[idx[1]] * 0.5 + 0.5) * 255;
+                quats[i * 4 + 2] = (q[idx[2]] * 0.5 + 0.5) * 255;
+                quats[i * 4 + 3] = 252 + maxComp;
+            }
+            output['quats.webp'] = encodeWebP(quats, width, height, webPProfile);
+            logger.timeEnd('SOG encoding quaternions');
+        }
+        // scales
+        {
+            logger.time('SOG encoding scales');
+            const scaleData = quantize1d([table[3 /* ColIdx.sx */], table[4 /* ColIdx.sy */], table[5 /* ColIdx.sz */]], undefined, undefined, Math.log);
+            const tableData = writeTableData(scaleData.labels, indices, width, height, channels);
+            output['scales.webp'] = encodeWebP(tableData, width, height, webPProfile);
+            meta.scales.codebook = Array.from(scaleData.centroids);
+            logger.timeEnd('SOG encoding scales');
+        }
+        // colors
+        {
+            logger.time('SOG encoding colors');
+            const colorData = quantize1d([table[10 /* ColIdx.r */], table[11 /* ColIdx.g */], table[12 /* ColIdx.b */]], undefined, undefined, v => (v - 0.5) / SH_C0);
+            const aCol = table[13 /* ColIdx.a */];
+            const opacityData = new Uint8Array(aCol.length);
+            for (let i = 0; i < counts; ++i) {
+                opacityData[i] = clamp(aCol[i] * 255, 0, 255);
+            }
+            colorData.labels.push(opacityData);
+            const tableData = writeTableData(colorData.labels, indices, width, height, channels);
+            output['sh0.webp'] = encodeWebP(tableData, width, height, webPProfile);
+            meta.sh0.codebook = Array.from(colorData.centroids);
+            logger.timeEnd('SOG encoding colors');
+        }
+        // SH
+        if (shDegree > 0) {
+            logger.time(`SOG encoding SH${shDegree}`);
+            const shCoeffs = shCounts / 3;
+            const shDataTable = [];
+            for (const i of buildSHTableMap(shCoeffs)) {
+                shDataTable.push(table[14 /* ColIdx.shOffset */ + i]);
+            }
+            const paletteSize = Math.min(64, 2 ** Math.floor(Math.log2(indices.length / 1024))) * 1024;
+            const device = await getOrCreateDevice();
+            logger.info(`SOG SH${shDegree} k-means with clusters=${paletteSize} iterations=${this.iterations}`);
+            logger.time(`SOG SH${shDegree} k-means`);
+            const { centroids, labels } = await kmeans(shDataTable, paletteSize, this.iterations, device);
+            logger.timeEnd(`SOG SH${shDegree} k-means`);
+            const codebook = quantize1d(centroids);
+            // write centroids
+            const centroidsBuf = new Uint8Array(64 * shCoeffs * Math.ceil(centroids[0].length / 64) * channels).fill(0xff);
+            const centroidsRow = [];
+            for (let i = 0; i < centroids[0].length; ++i) {
+                codebook.labels.forEach((column, index) => {
+                    centroidsRow[index] = column[i];
+                });
+                for (let j = 0; j < shCoeffs; ++j) {
+                    centroidsBuf[i * shCoeffs * 4 + j * 4 + 0] = centroidsRow[shCoeffs * 0 + j];
+                    centroidsBuf[i * shCoeffs * 4 + j * 4 + 1] = centroidsRow[shCoeffs * 1 + j];
+                    centroidsBuf[i * shCoeffs * 4 + j * 4 + 2] = centroidsRow[shCoeffs * 2 + j];
+                }
+            }
+            output['shN_centroids.webp'] = encodeWebP(centroidsBuf, 64 * shCoeffs, Math.ceil(centroids[0].length / 64), webPProfile);
+            // write labels
+            const labelsBuf = new Uint8Array(width * height * channels).fill(0xff);
+            for (let i = 0; i < indices.length; ++i) {
+                const label = labels[indices[i]];
+                labelsBuf[i * 4 + 0] = label & 0xff;
+                labelsBuf[i * 4 + 1] = (label >> 8) & 0xff;
+            }
+            output['shN_labels.webp'] = encodeWebP(labelsBuf, width, height, webPProfile);
+            meta.shN = {
+                count: paletteSize,
+                bands: shDegree,
+                codebook: Array.from(codebook.centroids),
+                files: [
+                    'shN_centroids.webp',
+                    'shN_labels.webp'
+                ]
+            };
+            logger.timeEnd(`SOG encoding SH${shDegree}`);
+        }
+        output['meta.json'] = Buffer.from(JSON.stringify(meta), 'utf-8');
+        const result = zipSync(output);
+        await stream.getWriter().write(result);
+    }
+}

package/dist/file/splat.d.ts

@@ -0,0 +1,6 @@
+import { SplatData } from '../SplatData.js';
+import { IFile } from './IFile.js';
+export declare class SplatFile implements IFile {
+    read(stream: ReadableStream<Uint8Array>, contentLength: number, data: SplatData): Promise<void>;
+    write(stream: WritableStream<Uint8Array>, data: SplatData, indices?: Uint32Array): Promise<void>;
+}

package/dist/file/splat.js

@@ -0,0 +1,99 @@
+import { clamp, StreamChunkDecoder, BufferReader, mortonSort } from '../utils/index.js';
+const ItemSize = 32;
+export class SplatFile {
+    async read(stream, contentLength, data) {
+        const setFn = data.set.bind(data);
+        const counts = Math.floor(contentLength / ItemSize);
+        const BlockOffset = await data.initBlock(counts, 0);
+        const reader = new BufferReader();
+        const decoder = new StreamChunkDecoder(reader);
+        const single = {
+            x: 0, y: 0, z: 0,
+            sx: 0, sy: 0, sz: 0,
+            qx: 0, qy: 0, qz: 0, qw: 0,
+            r: 0, g: 0, b: 0, a: 0,
+            shN: [],
+        };
+        decoder.setDecoders([
+            {
+                init: () => [counts, ItemSize],
+                decode: (offset, counts, buffer) => {
+                    offset += BlockOffset;
+                    const f32Array = new Float32Array(buffer.buffer);
+                    let o = 0;
+                    for (let i = 0; i < counts; i++) {
+                        o = i * 8;
+                        single.x = f32Array[o];
+                        single.y = f32Array[o + 1];
+                        single.z = f32Array[o + 2];
+                        single.sx = f32Array[o + 3];
+                        single.sy = f32Array[o + 4];
+                        single.sz = f32Array[o + 5];
+                        o = i * 32;
+                        single.r = buffer[o + 24] / 255;
+                        single.g = buffer[o + 25] / 255;
+                        single.b = buffer[o + 26] / 255;
+                        single.a = buffer[o + 27] / 255;
+                        single.qw = (buffer[o + 28] - 128) / 128;
+                        single.qx = (buffer[o + 29] - 128) / 128;
+                        single.qy = (buffer[o + 30] - 128) / 128;
+                        single.qz = (buffer[o + 31] - 128) / 128;
+                        setFn(offset + i, single);
+                    }
+                },
+            },
+        ]);
+        const source = stream.getReader();
+        while (true) {
+            const { done, value } = await source.read();
+            if (done) {
+                break;
+            }
+            reader.write(value);
+            decoder.flush();
+        }
+        data.finishBlock();
+    }
+    async write(stream, data, indices = mortonSort(data)) {
+        const writer = stream.getWriter();
+        const chunkSize = 2048;
+        const chunkCounts = Math.ceil(data.counts / chunkSize);
+        const single = {
+            x: 0, y: 0, z: 0,
+            sx: 0, sy: 0, sz: 0,
+            qx: 0, qy: 0, qz: 0, qw: 0,
+            r: 0, g: 0, b: 0, a: 0,
+            shN: [],
+        };
+        for (let i = 0; i < chunkCounts; i++) {
+            if (writer.desiredSize <= 0) {
+                await writer.ready;
+            }
+            const currentChunkSize = Math.min(chunkSize, data.counts - i * chunkSize);
+            const chunk = new Uint8Array(currentChunkSize * ItemSize);
+            const dataView = new DataView(chunk.buffer);
+            const offset = i * chunkSize;
+            for (let j = 0; j < currentChunkSize; j++) {
+                data.get(indices[offset + j], single);
+                const o = j * ItemSize;
+                dataView.setFloat32(o, single.x, true);
+                dataView.setFloat32(o + 4, single.y, true);
+                dataView.setFloat32(o + 8, single.z, true);
+                dataView.setFloat32(o + 12, single.sx, true);
+                dataView.setFloat32(o + 16, single.sy, true);
+                dataView.setFloat32(o + 20, single.sz, true);
+                dataView.setUint8(o + 24, clamp(Math.round(single.r * 255), 0, 255));
+                dataView.setUint8(o + 25, clamp(Math.round(single.g * 255), 0, 255));
+                dataView.setUint8(o + 26, clamp(Math.round(single.b * 255), 0, 255));
+                dataView.setUint8(o + 27, clamp(Math.round(single.a * 255), 0, 255));
+                dataView.setUint8(o + 28, clamp(Math.round(single.qw * 128 + 128), 0, 255));
+                dataView.setUint8(o + 29, clamp(Math.round(single.qx * 128 + 128), 0, 255));
+                dataView.setUint8(o + 30, clamp(Math.round(single.qy * 128 + 128), 0, 255));
+                dataView.setUint8(o + 31, clamp(Math.round(single.qz * 128 + 128), 0, 255));
+            }
+            writer.write(chunk);
+            await Promise.resolve();
+        }
+        await writer.close();
+    }
+}

package/dist/file/spz.d.ts

@@ -0,0 +1,8 @@
+import { SplatData } from '../SplatData.js';
+import { IFile } from './IFile.js';
+export declare class SpzFile implements IFile {
+    readonly compressLevel: number;
+    constructor(compressLevel: number);
+    read(stream: ReadableStream<Uint8Array>, _contentLength: number, data: SplatData): Promise<void>;
+    write(writeStream: WritableStream<Uint8Array>, data: SplatData, indices?: Uint32Array): Promise<void>;
+}