@myned-ai/gsplat-flame-avatar-renderer 1.0.2 → 1.0.5

package/src/buffers/SplatBufferGenerator.js

@@ -0,0 +1,41 @@
+/**
+ * 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

@@ -0,0 +1,110 @@
+/**
+ * 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

@@ -0,0 +1,106 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,48 @@
+/**
+ * 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;
+    }
+}