@manycore/aholo-splat-transform 1.2.8 → 1.2.10

package/dist/tasks/AutoChunkLodTask.js

@@ -1,117 +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';
-    }
-}
+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

@@ -1,10 +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>;
-}
+import { type 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

@@ -1,20 +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}"`);
-    }
-}
+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

@@ -1,15 +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;
-}
+import type { SplatData } from '../SplatData.js';
+import type { 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

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

package/dist/tasks/FlexLodTask.d.ts

@@ -1,12 +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>;
-}
+import { type 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

@@ -1,44 +1,54 @@
-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}"`);
-    }
-}
+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

@@ -1,9 +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>;
-}
+import { type 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>;
+}