@manycore/aholo-splat-transform 1.2.6

package/dist/tasks/AutoChunkLodTask.js

@@ -0,0 +1,117 @@
+import { combineSplatData, computeDenseBox } from '../utils/index.js';
+import { BaseTask } from './BaseTask.js';
+import { generateLod } from '../native/index.js';
+const DefaultLevels = [
+    { precision: 1.0, scaleBoost: 1 },
+    { precision: 0.5, scaleBoost: 1 },
+    { precision: 0.25, scaleBoost: 1 },
+    { precision: 0.05, scaleBoost: 1.01 },
+    { precision: 0.01, scaleBoost: 1.02 },
+];
+export class AutoChunkLodTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, output, type, maxChunkCounts = 400000, levels = DefaultLevels } = config;
+        const splat = resources.get(input);
+        logger.info(`loaded -> "${input}"`);
+        const forwardBox = computeDenseBox(splat, 0.8);
+        const outputs = [];
+        const outputBlocks = [];
+        const permanentFiles = [];
+        {
+            logger.info('generate lod');
+            logger.time('generate elapsed');
+            const { blocks, splats } = generateLod(splat, levels, Math.min(1, maxChunkCounts / splat.counts), 2000, 20);
+            logger.timeEnd('generate elapsed');
+            const chunkL3Idx = [];
+            const chunkL4Idx = [];
+            for (let i = 0; i < blocks.length; i++) {
+                const block = blocks[i];
+                chunkL4Idx.push(block.refs[4]);
+                if (block.refs[3] !== block.refs[4]) {
+                    chunkL3Idx.push(block.refs[3]);
+                }
+            }
+            const layout = new Map();
+            {
+                const chunkL4 = combineSplatData(chunkL4Idx.map(idx => splats[idx]));
+                outputs.push({ name: `chunk_0.${type}`, content: chunkL4, preserveOrder: true });
+                permanentFiles.push(0);
+                let offset = 0;
+                for (let i = 0; i < chunkL4Idx.length; i++) {
+                    const idx = chunkL4Idx[i];
+                    const counts = splats[idx].counts;
+                    layout.set(idx, { idx: 0, offset, counts });
+                    offset += counts;
+                }
+            }
+            if (chunkL3Idx.length > 0) {
+                const chunkL3 = combineSplatData(chunkL3Idx.map(idx => splats[idx]));
+                outputs.push({ name: `chunk_1.${type}`, content: chunkL3, preserveOrder: true });
+                permanentFiles.push(1);
+                let offset = 0;
+                for (let i = 0; i < chunkL3Idx.length; i++) {
+                    const idx = chunkL3Idx[i];
+                    const counts = splats[idx].counts;
+                    layout.set(idx, { idx: 1, offset, counts });
+                    offset += counts;
+                }
+            }
+            for (let i = 0; i < splats.length; i++) {
+                if (chunkL3Idx.includes(i) || chunkL4Idx.includes(i)) {
+                    continue;
+                }
+                const idx = outputs.length;
+                const splat = splats[i];
+                outputs.push({
+                    name: `chunk_${idx}.${type}`,
+                    content: splat,
+                });
+                layout.set(i, { idx, offset: 0, counts: splat.counts });
+            }
+            for (const block of blocks) {
+                outputBlocks.push({
+                    bound: block.box,
+                    lods: block.refs.map(ref => {
+                        const v = layout.get(ref);
+                        return {
+                            file: v.idx,
+                            offset: v.offset,
+                            count: v.counts,
+                        };
+                    })
+                });
+            }
+        }
+        logger.info(`Total blocks: ${outputBlocks.length}, files: ${outputs.length}`);
+        logger.info(`Gaussian per level: `);
+        let maxLength = 0;
+        for (let i = 0; i < levels.length; i++) {
+            const level = levels[i];
+            const levelCount = outputBlocks.map(block => block.lods[i].count).reduce((acc, i) => acc + i, 0);
+            const levelStr = levelCount.toString().padStart(maxLength, ' ');
+            maxLength = levelStr.length;
+            logger.info(`\tLevel ${i}${`(${(level.precision * 100).toFixed(2)}%)`.padStart(9, ' ')}: ${levelStr}${`(${(levelCount / splat.counts * 100).toFixed(2)}%)`.padStart(9, ' ')}`);
+        }
+        resources.set(output, [
+            {
+                name: 'lod-meta.json',
+                content: JSON.stringify({
+                    magicCode: 0x262834,
+                    type: 'lod-splat',
+                    version: '1.0',
+                    counts: splat.counts,
+                    shDegree: splat.shDegree,
+                    levels: levels.length,
+                    forwardBox,
+                    files: outputs.map(f => f.name),
+                    permanentFiles,
+                    tree: outputBlocks,
+                }),
+            },
+            ...outputs,
+        ]);
+    }
+    requiresGPU(config) {
+        return config.type === 'sog';
+    }
+}

package/dist/tasks/AutoLodTask.d.ts

@@ -0,0 +1,10 @@
+import { Context, BaseTask } from './BaseTask.js';
+export interface Config {
+    input: string;
+    output: string;
+    counts?: number;
+    ratio?: number;
+}
+export declare class AutoLodTask extends BaseTask<Config> {
+    exec(config: Config, { logger, resources }: Context): Promise<void>;
+}

package/dist/tasks/AutoLodTask.js

@@ -0,0 +1,20 @@
+import { combineSplatData } from '../utils/index.js';
+import { generateLod } from '../native/index.js';
+import { BaseTask } from './BaseTask.js';
+export class AutoLodTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, output, counts = Infinity, ratio = 0.3 } = config;
+        const splat = resources.get(input);
+        logger.info(`loaded -> "${input}"`);
+        const target = Math.min(Math.ceil(splat.counts * ratio), counts);
+        logger.info(`expected -> ${target}(${((target / splat.counts) * 100).toFixed(2)}%) | ratio=${ratio} counts=${counts}`);
+        const { blocks, splats } = generateLod(splat, [
+            { precision: 1.0, scaleBoost: 1.0 },
+            { precision: target / splat.counts, scaleBoost: 1.0 },
+        ], 0.2, 2000, 20);
+        const raw = combineSplatData(blocks.map(item => splats[item.refs[1]]));
+        logger.info(`result -> ${raw.counts}(${(raw.counts / target * 100).toFixed(2)}%)`);
+        resources.set(output, raw);
+        logger.info(`stored -> key="${output}"`);
+    }
+}

package/dist/tasks/BaseTask.d.ts

@@ -0,0 +1,15 @@
+import { SplatData } from '../SplatData.js';
+import { Logger } from '../utils/Logger.js';
+export interface SingleFile {
+    name: string;
+    content: SplatData | string;
+    preserveOrder?: boolean;
+}
+export interface Context {
+    logger: Logger;
+    resources: Map<string, SplatData | SingleFile[]>;
+}
+export declare abstract class BaseTask<T> {
+    abstract exec(config: T, ctx: Context): Promise<void>;
+    requiresGPU(_config: T): boolean;
+}

package/dist/tasks/BaseTask.js

@@ -0,0 +1,5 @@
+export class BaseTask {
+    requiresGPU(_config) {
+        return false;
+    }
+}

package/dist/tasks/FlexLodTask.d.ts

@@ -0,0 +1,12 @@
+import { Context, BaseTask } from './BaseTask.js';
+export interface Config {
+    input: string;
+    output: string;
+    scorePath: string;
+    counts?: number;
+    ratio?: number;
+    originalIndices?: string;
+}
+export declare class FlexLodTask extends BaseTask<Config> {
+    exec(config: Config, { logger, resources }: Context): Promise<void>;
+}

package/dist/tasks/FlexLodTask.js

@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import { SplatData } from '../SplatData.js';
+import { BaseTask } from './BaseTask.js';
+export class FlexLodTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, output, scorePath, counts = Infinity, ratio = 0.3, originalIndices } = config;
+        const splat = resources.get(input);
+        logger.info(`loaded -> "${input}"`);
+        const target = Math.min(counts, Math.ceil(splat.counts * ratio));
+        logger.info(`expected -> ${target}(${((target / splat.counts) * 100).toFixed(2)}%) | ratio=${ratio} counts=${counts}`);
+        const scores = new Float32Array(fs.readFileSync(scorePath).buffer);
+        let sorted = new Uint32Array(splat.counts);
+        for (let i = 0; i < sorted.length; i++) {
+            sorted[i] = i;
+        }
+        sorted.sort((a, b) => scores[b] - scores[a]);
+        sorted = sorted.subarray(0, target).sort((a, b) => a - b);
+        const raw = new SplatData().init(target, splat.shDegree);
+        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(splat.shCounts),
+        };
+        const shN = single.shN;
+        for (let i = 0; i < target; i++) {
+            splat.get(sorted[i], single);
+            splat.getShN(sorted[i], shN);
+            raw.set(i, single);
+            raw.setShN(i, shN);
+        }
+        if (originalIndices) {
+            const originIndices = new Uint32Array(target);
+            for (let i = 0; i < target; i++) {
+                originIndices[i] = sorted[i];
+            }
+            fs.writeFileSync(originalIndices, originIndices);
+            logger.info(`original indices saved -> "${originalIndices}"`);
+        }
+        resources.set(output, raw);
+        logger.info(`stored -> key="${output}"`);
+    }
+}

package/dist/tasks/ModifyTask.d.ts

@@ -0,0 +1,9 @@
+import { Context, BaseTask } from './BaseTask.js';
+export interface Config {
+    input: string;
+    output: string;
+    modifyPaths?: string[];
+}
+export declare class ModifyTask extends BaseTask<Config> {
+    exec(config: Config, { logger, resources }: Context): Promise<void>;
+}

package/dist/tasks/ModifyTask.js

@@ -0,0 +1,156 @@
+import fs from 'node:fs';
+import { createSHRotateFn, fastDeleteSplat, Matrix3, Matrix4, Quaternion, Vector3 } from '../utils/index.js';
+import { BaseTask } from './BaseTask.js';
+async function createSplatModify(path, counts) {
+    if (!path) {
+        return undefined;
+    }
+    const { isRowMatrix = true, transform, deletedIndices: deletedIndicesBitMap = [], indicesTransform = [], } = JSON.parse(fs.readFileSync(path, 'utf-8'));
+    const used = new Uint8Array(counts);
+    let usedCounts = 0;
+    const deletedIndices = [];
+    for (let i = 0; i < deletedIndicesBitMap.length; i++) {
+        const v = deletedIndicesBitMap[i];
+        for (let j = 0; j < 8; j++) {
+            if (v & (1 << j)) {
+                const idx = i * 8 + j;
+                deletedIndices.push(idx);
+                used[idx] = 1;
+                usedCounts++;
+            }
+        }
+    }
+    const groupIndices = [];
+    const groupTransforms = [];
+    const modelMatrix = new Matrix4(transform, isRowMatrix);
+    const transforms = indicesTransform.map(v => new Matrix4(v.transform, isRowMatrix).multiply(modelMatrix));
+    for (let i = 0; i < transforms.length; i++) {
+        const { indices } = indicesTransform[i];
+        for (let j = 0; j < indices.length; j++) {
+            used[indices[j]] = 1;
+        }
+        usedCounts += indices.length;
+        const matrix = transforms[i];
+        if (matrix.equals(Matrix4.ONE)) {
+            continue;
+        }
+        const scale = new Vector3(1, 1, 1);
+        const quat = new Quaternion(0, 0, 0, 1);
+        matrix.decompose(new Vector3(1, 1, 1), quat, scale);
+        groupIndices.push(indices);
+        groupTransforms.push({
+            isScale: !scale.equals(Vector3.ONE),
+            isRotate: !quat.equals(Quaternion.ONE),
+            matrix,
+            scale,
+            quat,
+            shRotateFn: createSHRotateFn(new Matrix3().setFromMatrix4(new Matrix4().compose(new Vector3(0, 0, 0), quat, new Vector3(1, 1, 1)))),
+        });
+    }
+    if (!modelMatrix.equals(Matrix4.ONE)) {
+        const indices = new Array(counts - usedCounts);
+        for (let i = 0; i < used.length; i++) {
+            if (used[i]) {
+                continue;
+            }
+            indices.push(i);
+        }
+        const matrix = modelMatrix;
+        const scale = new Vector3(1, 1, 1);
+        const quat = new Quaternion(0, 0, 0, 1);
+        matrix.decompose(new Vector3(1, 1, 1), quat, scale);
+        groupIndices.unshift(indices);
+        groupTransforms.unshift({
+            isScale: !scale.equals(Vector3.ONE),
+            isRotate: !quat.equals(Quaternion.ONE),
+            matrix,
+            scale,
+            quat,
+            shRotateFn: createSHRotateFn(new Matrix3().setFromMatrix4(new Matrix4().compose(new Vector3(0, 0, 0), quat, new Vector3(1, 1, 1)))),
+        });
+    }
+    return {
+        deletedIndices,
+        groupIndices,
+        groupTransforms,
+    };
+}
+export class ModifyTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, modifyPaths = [], output } = config;
+        const splat = resources.get(input);
+        logger.info(`loaded -> "${input}"`);
+        const modifies = await Promise.all(modifyPaths.map((p, i) => createSplatModify(p, splat.blockContentCounts[i])));
+        const tempVec = new Vector3(0, 0, 0);
+        const tempQuat = new Quaternion(0, 0, 0, 1);
+        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(splat.shCounts),
+        };
+        const shN = single.shN;
+        const shCoeffs = new Array(splat.shCounts / 3).fill(0);
+        const deletedTotalIndices = [];
+        for (let i = 0; i < modifies.length; i++) {
+            const modify = modifies[i];
+            if (!modify) {
+                logger.info(`modify[${i}] is null, skip`);
+                continue;
+            }
+            const offset = splat.blockOffsets[i];
+            const { deletedIndices, groupIndices, groupTransforms } = modify;
+            logger.info(`modify[${i}] offset=${offset} groups=${groupIndices.length} delete=${deletedIndices.length}`);
+            for (let j = 0; j < groupIndices.length; j++) {
+                const indices = groupIndices[j];
+                const { isScale, isRotate, matrix, scale, quat, shRotateFn } = groupTransforms[j];
+                logger.info(`group[${i}:${j}] size=${indices.length} scale=${isScale} rotate=${isRotate}`);
+                for (let k = 0; k < indices.length; k++) {
+                    const idx = offset + indices[k];
+                    splat.get(idx, single);
+                    tempVec.set(single.x, single.y, single.z).applyMatrix4(matrix);
+                    single.x = tempVec.x;
+                    single.y = tempVec.y;
+                    single.z = tempVec.z;
+                    if (isScale) {
+                        tempVec.set(single.sx, single.sy, single.sz).mul(scale);
+                        single.sx = tempVec.x;
+                        single.sy = tempVec.y;
+                        single.sz = tempVec.z;
+                    }
+                    if (isRotate) {
+                        tempQuat.set(single.qx, single.qy, single.qz, single.qw).premultiply(quat);
+                        single.qx = tempQuat.x;
+                        single.qy = tempQuat.y;
+                        single.qz = tempQuat.z;
+                        single.qw = tempQuat.w;
+                    }
+                    splat.set(idx, single);
+                    if (isRotate) {
+                        splat.getShN(idx, shN);
+                        for (let m = 0; m < 3; m++) {
+                            for (let n = 0; n < shCoeffs.length; n++) {
+                                shCoeffs[n] = shN[n * 3 + m];
+                            }
+                            shRotateFn(shCoeffs);
+                            for (let n = 0; n < shCoeffs.length; n++) {
+                                shN[n * 3 + m] = shCoeffs[n];
+                            }
+                        }
+                        splat.setShN(idx, shN);
+                    }
+                }
+            }
+            for (let j = 0; j < deletedIndices.length; j++) {
+                deletedTotalIndices.push(offset + deletedIndices[j]);
+            }
+        }
+        if (deletedTotalIndices.length > 0) {
+            fastDeleteSplat(splat, deletedTotalIndices);
+            logger.info(`delete ${deletedTotalIndices.length} splat`);
+        }
+        resources.set(output, splat);
+        logger.info(`stored -> key="${output}"`);
+    }
+}

package/dist/tasks/ReadTask.d.ts

@@ -0,0 +1,8 @@
+import { Context, BaseTask } from './BaseTask.js';
+export interface Config {
+    inputs: string[];
+    output: string;
+}
+export declare class ReadTask extends BaseTask<Config> {
+    exec(config: Config, { logger, resources }: Context): Promise<void>;
+}

package/dist/tasks/ReadTask.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import { Readable } from 'node:stream';
+import { SplatData } from '../SplatData.js';
+import { createSplatFile } from '../utils/index.js';
+import { BaseTask } from './BaseTask.js';
+export class ReadTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { inputs, output } = config;
+        const splat = new SplatData(inputs.length);
+        const promises = [];
+        let totalBytes = 0;
+        for (let i = 0; i < inputs.length; i++) {
+            const path = inputs[i];
+            const { size } = fs.statSync(path);
+            totalBytes += size;
+            const stream = Readable.toWeb(fs.createReadStream(path));
+            const promise = createSplatFile(path).read(stream, size, splat);
+            promises.push(promise);
+        }
+        await Promise.all(promises);
+        logger.info(`load: ${inputs.length} files | sizes=${(totalBytes / 1024 / 1024).toFixed(2)}MB`);
+        for (let i = 0; i < inputs.length; i++) {
+            logger.info(`  - ${inputs[i]}`);
+        }
+        logger.info(`counts: ${splat.counts}, SH: ${splat.shDegree}`);
+        resources.set(output, splat);
+        logger.info(`stored -> "${output}"`);
+    }
+}

package/dist/tasks/SkeletonLodTask.d.ts

@@ -0,0 +1,10 @@
+import { Context, BaseTask } from './BaseTask.js';
+export interface Config {
+    input: string;
+    output: string;
+    counts?: number;
+    ratio?: number;
+}
+export declare class SkeletonLodTask extends BaseTask<Config> {
+    exec(config: Config, { logger, resources }: Context): Promise<void>;
+}

package/dist/tasks/SkeletonLodTask.js

@@ -0,0 +1,156 @@
+import { SplatData } from '../SplatData.js';
+import { BaseTask } from './BaseTask.js';
+const VOXEL_CHUNK_SIZE = 0.02;
+const VOXEL_CHUNK_SCALE = 1.3;
+export class SkeletonLodTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, output, counts = 85000, ratio = 0.1 } = config;
+        const splat = resources.get(input);
+        logger.info(`loaded -> "${input}"`);
+        const target = Math.min(Math.ceil(splat.counts * ratio), counts);
+        logger.info(`expected -> ${target}(${((target / splat.counts) * 100).toFixed(2)}%) | ratio=${ratio} counts=${counts}`);
+        const xCol = splat.table[0 /* ColIdx.x */];
+        const yCol = splat.table[1 /* ColIdx.y */];
+        const zCol = splat.table[2 /* ColIdx.z */];
+        let minX = Infinity;
+        let minY = Infinity;
+        let minZ = Infinity;
+        for (let i = 0; i < splat.counts; i++) {
+            const x = xCol[i];
+            const y = yCol[i];
+            const z = zCol[i];
+            if (x < minX) {
+                minX = x;
+            }
+            if (y < minY) {
+                minY = y;
+            }
+            if (z < minZ) {
+                minZ = z;
+            }
+        }
+        const chunkMap = new Map();
+        for (let i = 0; i < splat.counts; i++) {
+            const x = ((xCol[i] - minX) / VOXEL_CHUNK_SIZE) | 0;
+            const y = ((yCol[i] - minY) / VOXEL_CHUNK_SIZE) | 0;
+            const z = ((zCol[i] - minZ) / VOXEL_CHUNK_SIZE) | 0;
+            const key = `${x},${y},${z}`;
+            let arr = chunkMap.get(key);
+            if (!arr) {
+                arr = [];
+                chunkMap.set(key, arr);
+            }
+            arr.push(i);
+        }
+        const chunks = Array.from(chunkMap.values());
+        const CHUNK_RATIO = chunks.reduce((p, c) => p + c.length ** VOXEL_CHUNK_SCALE, 0) / (target * 0.1);
+        const mergeChucks = [];
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const size = Math.max(1, Math.ceil((chunk.length ** VOXEL_CHUNK_SCALE) / CHUNK_RATIO));
+            if (size === 1) {
+                mergeChucks.push(chunk);
+                continue;
+            }
+            let minX = Infinity;
+            let minY = Infinity;
+            let minZ = Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            let maxZ = -Infinity;
+            for (let j = 0; j < chunk.length; j++) {
+                const offset = chunk[j];
+                const x = xCol[offset];
+                const y = yCol[offset];
+                const z = zCol[offset];
+                if (x < minX) {
+                    minX = x;
+                }
+                if (y < minY) {
+                    minY = y;
+                }
+                if (z < minZ) {
+                    minZ = z;
+                }
+                if (x > maxX) {
+                    maxX = x;
+                }
+                if (y > maxY) {
+                    maxY = y;
+                }
+                if (z > maxZ) {
+                    maxZ = z;
+                }
+            }
+            const subChuckSize = Math.ceil(Math.cbrt(size));
+            const scaleX = subChuckSize / Math.max(maxX - minX, 1e-9);
+            const scaleY = subChuckSize / Math.max(maxY - minY, 1e-9);
+            const scaleZ = subChuckSize / Math.max(maxZ - minZ, 1e-9);
+            const subChunkMap = new Map();
+            for (let j = 0; j < chunk.length; j++) {
+                const idx = chunk[j];
+                const x = ((xCol[idx] - minX) * scaleX) | 0;
+                const y = ((yCol[idx] - minY) * scaleY) | 0;
+                const z = ((zCol[idx] - minZ) * scaleZ) | 0;
+                const key = `${x},${y},${z}`;
+                let arr = subChunkMap.get(key);
+                if (!arr) {
+                    arr = [];
+                    subChunkMap.set(key, arr);
+                }
+                arr.push(idx);
+            }
+            const subChunks = Array.from(subChunkMap.values());
+            if (subChunks.length > size) {
+                subChunks.sort((a, b) => b.length - a.length);
+                subChunks.length = size;
+            }
+            for (let j = 0; j < subChunks.length; j++) {
+                mergeChucks.push(subChunks[j]);
+            }
+        }
+        if (mergeChucks.length > target) {
+            mergeChucks.sort((a, b) => b.length - a.length);
+            mergeChucks.length = target;
+        }
+        const raw = new SplatData().init(mergeChucks.length, 0);
+        const result = {
+            x: 0, y: 0, z: 0,
+            sx: 0.005, sy: 0.005, sz: 0.005,
+            qx: 0, qy: 0, qz: 0, qw: 1,
+            r: 0, g: 0, b: 0, a: 0,
+            shN: [],
+        };
+        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 < mergeChucks.length; i++) {
+            const chunk = mergeChucks[i];
+            for (let j = 0; j < chunk.length; j++) {
+                splat.get(chunk[j], single);
+                result.x += single.x;
+                result.y += single.y;
+                result.z += single.z;
+                result.r += single.r;
+                result.g += single.g;
+                result.b += single.b;
+                result.a += single.a;
+            }
+            result.x /= chunk.length;
+            result.y /= chunk.length;
+            result.z /= chunk.length;
+            result.r /= chunk.length;
+            result.g /= chunk.length;
+            result.b /= chunk.length;
+            result.a /= chunk.length;
+            raw.set(i, result);
+            result.x = result.y = result.z = result.r = result.g = result.b = result.a = 0;
+        }
+        resources.set(output, raw);
+        logger.info(`stored -> key="${output}"`);
+    }
+}

package/dist/tasks/VoxelTask.d.ts

@@ -0,0 +1,30 @@
+import { Context, BaseTask } from './BaseTask.js';
+export interface VoxelTaskConfig {
+    input: string;
+    output: string;
+    voxelResolution?: number;
+    opacityCutoff?: number;
+    backend?: 'cpu' | 'gpu';
+    collisionMesh?: boolean | 'smooth' | 'faces';
+    navExteriorRadius?: number;
+    floorFill?: boolean;
+    floorFillDilation?: number;
+    cpuWorkerCount?: number;
+    box?: {
+        minCorner: [number, number, number];
+        maxCorner: [number, number, number];
+    };
+    navCapsule?: {
+        height: number;
+        radius: number;
+    };
+    navSeed?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export declare class VoxelTask extends BaseTask<VoxelTaskConfig> {
+    exec(config: VoxelTaskConfig, { logger, resources }: Context): Promise<void>;
+    requiresGPU(_config: VoxelTaskConfig): boolean;
+}

package/dist/tasks/VoxelTask.js

@@ -0,0 +1,37 @@
+import { SplatData } from '../SplatData.js';
+import { writeVoxelFiles } from '../file/voxel.js';
+import { BaseTask } from './BaseTask.js';
+export class VoxelTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, output, voxelResolution = 0.05, opacityCutoff = 0.1, backend = 'gpu', collisionMesh = false, navExteriorRadius, floorFill = false, floorFillDilation = 0, cpuWorkerCount = -1, box = { minCorner: [-100, -100, -100], maxCorner: [100, 100, 100] }, navCapsule, navSeed } = config;
+        const source = resources.get(input);
+        if (!(source instanceof SplatData)) {
+            throw new Error(`VoxelTask: resource "${input}" must be SplatData`);
+        }
+        const options = {
+            voxelResolution,
+            opacityCutoff,
+            backend,
+            collisionMesh,
+            floorFill,
+            floorFillDilation,
+            cpuWorkerCount,
+            box
+        };
+        if (navExteriorRadius !== undefined) {
+            options.navExteriorRadius = navExteriorRadius;
+        }
+        if (navCapsule !== undefined) {
+            options.navCapsule = navCapsule;
+        }
+        if (navSeed !== undefined) {
+            options.navSeed = navSeed;
+        }
+        logger.info(`writing voxel -> dir="${output}" count=${source.counts} SH=${source.shDegree}`);
+        await writeVoxelFiles(output, source, options);
+        logger.info('voxelizing done');
+    }
+    requiresGPU(_config) {
+        return (_config.backend ?? 'gpu') === 'gpu';
+    }
+}