@myned-ai/gsplat-flame-avatar-renderer 1.0.6 → 1.0.7

package/src/buffers/SplatBufferGenerator.js

@@ -1,41 +0,0 @@
-/**
- * SplatBufferGenerator
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * This file is functionally identical to the original.
- * Import paths adjusted for gsplat-flame-avatar package structure.
- */
-
-import { Vector3 } from 'three';
-import { SplatBuffer } from './SplatBuffer.js';
-import { SplatPartitioner } from './SplatPartitioner.js';
-
-export class SplatBufferGenerator {
-
-    constructor(splatPartitioner, alphaRemovalThreshold, compressionLevel, sectionSize, sceneCenter, blockSize, bucketSize) {
-        this.splatPartitioner = splatPartitioner;
-        this.alphaRemovalThreshold = alphaRemovalThreshold;
-        this.compressionLevel = compressionLevel;
-        this.sectionSize = sectionSize;
-        this.sceneCenter = sceneCenter ? new Vector3().copy(sceneCenter) : undefined;
-        this.blockSize = blockSize;
-        this.bucketSize = bucketSize;
-    }
-
-    generateFromUncompressedSplatArray(splatArray) {
-        const partitionResults = this.splatPartitioner.partitionUncompressedSplatArray(splatArray);
-        return SplatBuffer.generateFromUncompressedSplatArrays(partitionResults.splatArrays,
-                                                               this.alphaRemovalThreshold, this.compressionLevel,
-                                                               this.sceneCenter, this.blockSize, this.bucketSize,
-                                                               partitionResults.parameters);
-    }
-
-    static getStandardGenerator(alphaRemovalThreshold = 1, compressionLevel = 1, sectionSize = 0, sceneCenter = new Vector3(),
-                                blockSize = SplatBuffer.BucketBlockSize, bucketSize = SplatBuffer.BucketSize) {
-        const splatPartitioner = SplatPartitioner.getStandardPartitioner(sectionSize, sceneCenter, blockSize, bucketSize);
-        return new SplatBufferGenerator(splatPartitioner, alphaRemovalThreshold, compressionLevel,
-                                        sectionSize, sceneCenter, blockSize, bucketSize);
-    }
-}

package/src/buffers/SplatPartitioner.js

@@ -1,110 +0,0 @@
-/**
- * SplatPartitioner
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * This file is functionally identical to the original.
- * Import paths adjusted for gsplat-flame-avatar package structure.
- */
-
-import { Vector3 } from 'three';
-import { SplatBuffer } from './SplatBuffer.js';
-import { UncompressedSplatArray } from './UncompressedSplatArray.js';
-
-export class SplatPartitioner {
-
-    constructor(sectionCount, sectionFilters, groupingParameters, partitionGenerator) {
-        this.sectionCount = sectionCount;
-        this.sectionFilters = sectionFilters;
-        this.groupingParameters = groupingParameters;
-        this.partitionGenerator = partitionGenerator;
-    }
-
-    partitionUncompressedSplatArray(splatArray) {
-        let groupingParameters;
-        let sectionCount;
-        let sectionFilters;
-        if (this.partitionGenerator) {
-            const results = this.partitionGenerator(splatArray);
-            groupingParameters = results.groupingParameters;
-            sectionCount = results.sectionCount;
-            sectionFilters = results.sectionFilters;
-        } else {
-            groupingParameters = this.groupingParameters;
-            sectionCount = this.sectionCount;
-            sectionFilters = this.sectionFilters;
-        }
-
-        const newArrays = [];
-        for (let s = 0; s < sectionCount; s++) {
-            const sectionSplats = new UncompressedSplatArray(splatArray.sphericalHarmonicsDegree);
-            const sectionFilter = sectionFilters[s];
-            for (let i = 0; i < splatArray.splatCount; i++) {
-                if (sectionFilter(i)) {
-                    sectionSplats.addSplat(splatArray.splats[i]);
-                }
-            }
-            newArrays.push(sectionSplats);
-        }
-        return {
-            splatArrays: newArrays,
-            parameters: groupingParameters
-        };
-    }
-
-    static getStandardPartitioner(partitionSize = 0, sceneCenter = new Vector3(),
-                                  blockSize = SplatBuffer.BucketBlockSize, bucketSize = SplatBuffer.BucketSize) {
-
-        const partitionGenerator = (splatArray) => {
-
-            const OFFSET_X = UncompressedSplatArray.OFFSET.X;
-            const OFFSET_Y = UncompressedSplatArray.OFFSET.Y;
-            const OFFSET_Z = UncompressedSplatArray.OFFSET.Z;
-
-            if (partitionSize <= 0) partitionSize = splatArray.splatCount;
-
-            const center = new Vector3();
-            const clampDistance = 0.5;
-            const clampPoint = (point) => {
-                point.x = Math.floor(point.x / clampDistance) * clampDistance;
-                point.y = Math.floor(point.y / clampDistance) * clampDistance;
-                point.z = Math.floor(point.z / clampDistance) * clampDistance;
-            };
-            splatArray.splats.forEach((splat) => {
-                center.set(splat[OFFSET_X], splat[OFFSET_Y], splat[OFFSET_Z]).sub(sceneCenter);
-                clampPoint(center);
-                splat.centerDist = center.lengthSq();
-            });
-            splatArray.splats.sort((a, b) => {
-                let centerADist = a.centerDist;
-                let centerBDist = b.centerDist;
-                if (centerADist > centerBDist) return 1;
-                else return -1;
-            });
-
-            const sectionFilters = [];
-            const groupingParameters = [];
-            partitionSize = Math.min(splatArray.splatCount, partitionSize);
-            const patitionCount = Math.ceil(splatArray.splatCount / partitionSize);
-            let currentStartSplat = 0;
-            for (let i = 0; i < patitionCount; i ++) {
-                let startSplat = currentStartSplat;
-                sectionFilters.push((splatIndex) => {
-                    return splatIndex >= startSplat && splatIndex < startSplat + partitionSize;
-                });
-                groupingParameters.push({
-                    'blocksSize': blockSize,
-                    'bucketSize': bucketSize,
-                });
-                currentStartSplat += partitionSize;
-            }
-            return {
-                'sectionCount': sectionFilters.length,
-                sectionFilters,
-                groupingParameters
-            };
-        };
-        return new SplatPartitioner(undefined, undefined, undefined, partitionGenerator);
-    }
-}

package/src/buffers/UncompressedSplatArray.js

@@ -1,106 +0,0 @@
-/**
- * UncompressedSplatArray
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * This file is functionally identical to the original.
- * Import paths adjusted for gsplat-flame-avatar package structure.
- */
-
-import { getSphericalHarmonicsComponentCountForDegree } from '../utils/Util.js';
-
-const BASE_COMPONENT_COUNT = 14;
-
-export class UncompressedSplatArray {
-
-    static OFFSET = {
-        X: 0,
-        Y: 1,
-        Z: 2,
-        SCALE0: 3,
-        SCALE1: 4,
-        SCALE2: 5,
-        ROTATION0: 6,
-        ROTATION1: 7,
-        ROTATION2: 8,
-        ROTATION3: 9,
-        FDC0: 10,
-        FDC1: 11,
-        FDC2: 12,
-        OPACITY: 13,
-        FRC0: 14,
-        FRC1: 15,
-        FRC2: 16,
-        FRC3: 17,
-        FRC4: 18,
-        FRC5: 19,
-        FRC6: 20,
-        FRC7: 21,
-        FRC8: 22,
-        FRC9: 23,
-        FRC10: 24,
-        FRC11: 25,
-        FRC12: 26,
-        FRC13: 27,
-        FRC14: 28,
-        FRC15: 29,
-        FRC16: 30,
-        FRC17: 31,
-        FRC18: 32,
-        FRC19: 33,
-        FRC20: 34,
-        FRC21: 35,
-        FRC22: 36,
-        FRC23: 37
-    };
-
-    constructor(sphericalHarmonicsDegree = 0) {
-        this.sphericalHarmonicsDegree = sphericalHarmonicsDegree;
-        this.sphericalHarmonicsCount = getSphericalHarmonicsComponentCountForDegree(this.sphericalHarmonicsDegree);
-        this.componentCount = this.sphericalHarmonicsCount + BASE_COMPONENT_COUNT;
-        this.defaultSphericalHarmonics = new Array(this.sphericalHarmonicsCount).fill(0);
-        this.splats = [];
-        this.splatCount = 0;
-    }
-
-    static createSplat(sphericalHarmonicsDegree = 0) {
-        const baseSplat = [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
-        let shEntries = getSphericalHarmonicsComponentCountForDegree(sphericalHarmonicsDegree);
-        for (let i = 0; i < shEntries; i++) baseSplat.push(0);
-        return baseSplat;
-    }
-
-    addSplat(splat) {
-        this.splats.push(splat);
-        this.splatCount++;
-    }
-
-    getSplat(index) {
-        return this.splats[index];
-    }
-
-    addDefaultSplat() {
-        const newSplat = UncompressedSplatArray.createSplat(this.sphericalHarmonicsDegree);
-        this.addSplat(newSplat);
-        return newSplat;
-    }
-
-    addSplatFromComonents(x, y, z, scale0, scale1, scale2, rot0, rot1, rot2, rot3, r, g, b, opacity, ...rest) {
-        const newSplat = [x, y, z, scale0, scale1, scale2, rot0, rot1, rot2, rot3, r, g, b, opacity, ...this.defaultSphericalHarmonics];
-        for (let i = 0; i < rest.length && i < this.sphericalHarmonicsCount; i++) {
-            newSplat[i] = rest[i];
-        }
-        this.addSplat(newSplat);
-        return newSplat;
-    }
-
-    addSplatFromArray(src, srcIndex) {
-        const srcSplat = src.splats[srcIndex];
-        const newSplat = UncompressedSplatArray.createSplat(this.sphericalHarmonicsDegree);
-        for (let i = 0; i < this.componentCount && i < srcSplat.length; i++) {
-            newSplat[i] = srcSplat[i];
-        }
-        this.addSplat(newSplat);
-    }
-}

package/src/buffers/index.js

@@ -1,11 +0,0 @@
-/**
- * gsplat-flame-avatar - Buffers Module
- * GPU buffer management for Gaussian Splat data.
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- */
-
-export { SplatBuffer } from './SplatBuffer.js';
-export { SplatBufferGenerator } from './SplatBufferGenerator.js';
-export { SplatPartitioner } from './SplatPartitioner.js';
-export { UncompressedSplatArray } from './UncompressedSplatArray.js';

package/src/core/SplatGeometry.js

@@ -1,48 +0,0 @@
-/**
- * SplatGeometry
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * This file is functionally identical to the original.
- */
-
-import { BufferAttribute, BufferGeometry, DynamicDrawUsage, InstancedBufferAttribute, InstancedBufferGeometry } from 'three';
-
-export class SplatGeometry {
-
-    /**
-     * Build the Three.js geometry that will be used to render the splats. The geometry is instanced and is made up of
-     * vertices for a single quad as well as an attribute buffer for the splat indexes.
-     * @param {number} maxSplatCount The maximum number of splats that the geometry will need to accomodate
-     * @return {THREE.InstancedBufferGeometry}
-     */
-    static build(maxSplatCount) {
-
-        const baseGeometry = new BufferGeometry();
-        baseGeometry.setIndex([0, 1, 2, 0, 2, 3]);
-
-        // Vertices for the instanced quad
-        const positionsArray = new Float32Array(4 * 3);
-        const positions = new BufferAttribute(positionsArray, 3);
-        baseGeometry.setAttribute('position', positions);
-        positions.setXYZ(0, -1.0, -1.0, 0.0);
-        positions.setXYZ(1, -1.0, 1.0, 0.0);
-        positions.setXYZ(2, 1.0, 1.0, 0.0);
-        positions.setXYZ(3, 1.0, -1.0, 0.0);
-        positions.needsUpdate = true;
-
-        const geometry = new InstancedBufferGeometry().copy(baseGeometry);
-
-        // Splat index buffer
-        const splatIndexArray = new Uint32Array(maxSplatCount);
-
-        const splatIndexes = new InstancedBufferAttribute(splatIndexArray, 1, false);
-        splatIndexes.setUsage(DynamicDrawUsage);
-        geometry.setAttribute('splatIndex', splatIndexes);
-
-        geometry.instanceCount = 0;
-
-        return geometry;
-    }
-}