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

package/src/flame/FlameTextureManager.js

@@ -1,293 +0,0 @@
-/**
- * FlameTextureManager
- * 
- * Derived from gaussian-splat-renderer-for-lam
- * 
- * Manages GPU textures for FLAME parametric head model:
- * - Blendshape morph target data textures
- * - Bone matrix textures for skeleton animation
- * - LBS weight textures for skinning
- */
-
-import {
-    Vector2,
-    DataTexture,
-    RGBAIntegerFormat,
-    UnsignedIntType
-} from 'three';
-
-import { uintEncodedFloat } from './utils.js';
-
-/**
- * Build the FLAME model texture containing blendshape positions
- * @param {THREE.SkinnedMesh} flameModel - The FLAME mesh with morph targets
- * @param {THREE.ShaderMaterial} material - The splat material to update uniforms
- * @param {number} gaussianSplatCount - Number of gaussian splats
- * @returns {object} Texture data object
- */
-export function buildModelTexture(flameModel, material, gaussianSplatCount) {
-    const flameModelTexSize = new Vector2(4096, 2048);
-
-    const shapedMesh = flameModel.geometry.attributes.position.array;
-    let shapedMeshArray = [];
-    const pointNum = shapedMesh.length / 3;
-    const bsLength = flameModel.geometry.morphAttributes.position.length;
-
-    // Sort morph targets by dictionary order
-    const morphTargetNames = Object.keys(flameModel.morphTargetDictionary);
-    morphTargetNames.forEach((name) => {
-        const originalIndex = flameModel.morphTargetDictionary[name];
-        const bsMesh = flameModel.geometry.morphAttributes.position[originalIndex];
-        shapedMeshArray = shapedMeshArray.concat(Array.from(bsMesh.array));
-    });
-    
-    // Add base mesh positions
-    shapedMeshArray = shapedMeshArray.concat(Array.from(shapedMesh));
-
-    // Create texture data
-    const flameModelData = new Float32Array(flameModelTexSize.x * flameModelTexSize.y * 4);
-    const flameModelDataInt = new Uint32Array(flameModelTexSize.x * flameModelTexSize.y * 4);
-    
-    for (let c = 0; c < pointNum * (bsLength + 1); c++) {
-        flameModelData[c * 4 + 0] = shapedMeshArray[c * 3 + 0];
-        flameModelData[c * 4 + 1] = shapedMeshArray[c * 3 + 1];
-        flameModelData[c * 4 + 2] = shapedMeshArray[c * 3 + 2];
-
-        flameModelDataInt[c * 4 + 0] = uintEncodedFloat(flameModelData[c * 4 + 0]);
-        flameModelDataInt[c * 4 + 1] = uintEncodedFloat(flameModelData[c * 4 + 1]);
-        flameModelDataInt[c * 4 + 2] = uintEncodedFloat(flameModelData[c * 4 + 2]);
-    }
-
-    const flameModelTex = new DataTexture(
-        flameModelDataInt,
-        flameModelTexSize.x,
-        flameModelTexSize.y,
-        RGBAIntegerFormat,
-        UnsignedIntType
-    );
-    flameModelTex.internalFormat = 'RGBA32UI';
-    flameModelTex.needsUpdate = true;
-
-    // Update material uniforms
-    material.uniforms.flameModelTexture.value = flameModelTex;
-    material.uniforms.flameModelTextureSize.value.copy(flameModelTexSize);
-    material.uniforms.gaussianSplatCount.value = gaussianSplatCount;
-    material.uniformsNeedUpdate = true;
-
-    return {
-        data: flameModelDataInt,
-        texture: flameModelTex,
-        size: flameModelTexSize,
-        baseData: { flameModelPos: flameModelData }
-    };
-}
-
-/**
- * Build bone matrix texture for skeleton animation
- * @param {Float32Array} bonesMatrix - Flattened bone matrices
- * @param {number} bonesNum - Number of bones
- * @param {object} bsWeight - Blendshape weights object
- * @param {object} morphTargetDictionary - Maps blendshape names to indices
- * @param {THREE.SkinnedMesh} flameModel - The FLAME mesh
- * @param {THREE.ShaderMaterial} material - The splat material
- * @param {boolean} useFlameModel - Use FLAME mode
- * @returns {object} Texture data object
- */
-export function buildBoneMatrixTexture(
-    bonesMatrix,
-    bonesNum,
-    bsWeight,
-    morphTargetDictionary,
-    flameModel,
-    material,
-    useFlameModel
-) {
-    if (!bsWeight) return null;
-
-    // bonesNum + expressionBSNum / 4 = 30, so texture height is 32
-    const boneTextureSize = new Vector2(4, 32);
-    const boneMatrixTextureData = new Float32Array(bonesMatrix);
-    const boneMatrixTextureDataInt = new Uint32Array(boneTextureSize.x * boneTextureSize.y * 4);
-
-    if (useFlameModel) {
-        // Encode bone matrices
-        for (let c = 0; c < bonesNum * 16; c++) {
-            boneMatrixTextureDataInt[c] = uintEncodedFloat(boneMatrixTextureData[c]);
-        }
-        
-        // Set skeleton uniforms
-        if (flameModel && flameModel.skeleton) {
-            material.uniforms.boneTexture0.value = flameModel.skeleton.boneTexture;
-            material.uniforms.bindMatrix.value = flameModel.bindMatrix;
-            material.uniforms.bindMatrixInverse.value = flameModel.bindMatrixInverse;
-        }
-    }
-
-    // Encode blendshape weights
-    for (const key in bsWeight) {
-        if (Object.hasOwn(bsWeight, key)) {
-            const value = bsWeight[key];
-            const idx = morphTargetDictionary[key];
-            boneMatrixTextureDataInt[idx + bonesNum * 16] = uintEncodedFloat(value);
-        }
-    }
-
-    const boneMatrixTex = new DataTexture(
-        boneMatrixTextureDataInt,
-        boneTextureSize.x,
-        boneTextureSize.y,
-        RGBAIntegerFormat,
-        UnsignedIntType
-    );
-    boneMatrixTex.internalFormat = 'RGBA32UI';
-    boneMatrixTex.needsUpdate = true;
-
-    material.uniforms.boneTexture.value = boneMatrixTex;
-    material.uniforms.boneTextureSize.value.copy(boneTextureSize);
-    material.uniformsNeedUpdate = true;
-
-    return {
-        data: boneMatrixTextureDataInt,
-        texture: boneMatrixTex,
-        size: boneTextureSize,
-        baseData: { boneMatrix: boneMatrixTextureDataInt }
-    };
-}
-
-/**
- * Update bone matrix texture with new animation data
- * @param {object} splatDataTextures - Texture data storage
- * @param {Float32Array} bonesMatrix - Updated bone matrices
- * @param {number} bonesNum - Number of bones
- * @param {object} bsWeight - Updated blendshape weights
- * @param {object} morphTargetDictionary - Blendshape name to index map
- * @param {THREE.SkinnedMesh} flameModel - The FLAME mesh
- * @param {THREE.ShaderMaterial} material - The splat material
- * @param {boolean} updateFlameBoneMatrix - Whether to update bone matrices
- */
-export function updateBoneMatrixTexture(
-    splatDataTextures,
-    bonesMatrix,
-    bonesNum,
-    bsWeight,
-    morphTargetDictionary,
-    flameModel,
-    material,
-    updateFlameBoneMatrix = false
-) {
-    if (!bsWeight || !morphTargetDictionary) return;
-
-    if (updateFlameBoneMatrix) {
-        const boneMatrixTextureData = new Float32Array(bonesMatrix);
-        for (let c = 0; c < bonesNum * 16; c++) {
-            splatDataTextures.baseData['boneMatrix'][c] = uintEncodedFloat(boneMatrixTextureData[c]);
-        }
-    }
-
-    // Update blendshape weights
-    for (const key in bsWeight) {
-        if (Object.hasOwn(bsWeight, key)) {
-            const value = bsWeight[key];
-            const idx = morphTargetDictionary[key];
-            splatDataTextures.baseData['boneMatrix'][idx + bonesNum * 16] = uintEncodedFloat(value);
-        }
-    }
-
-    // Update texture data
-    splatDataTextures['boneMatrix']['texture'].data = splatDataTextures.baseData['boneMatrix'];
-    splatDataTextures['boneMatrix']['texture'].needsUpdate = true;
-    material.uniforms.boneTexture.value = splatDataTextures['boneMatrix']['texture'];
-
-    // Update skeleton uniforms
-    if (flameModel.skeleton) {
-        material.uniforms.boneTexture0.value = flameModel.skeleton.boneTexture;
-        material.uniforms.bindMatrix.value = flameModel.bindMatrix;
-        material.uniforms.bindMatrixInverse.value = flameModel.bindMatrixInverse;
-    }
-
-    material.uniformsNeedUpdate = true;
-}
-
-/**
- * Build LBS weight texture for skin deformation
- * @param {THREE.SkinnedMesh} flameModel - The FLAME mesh
- * @param {Array} bonesWeight - Per-vertex bone weights array
- * @param {THREE.ShaderMaterial} material - The splat material
- * @returns {object} Texture data object
- */
-export function buildBoneWeightTexture(flameModel, bonesWeight, material) {
-    const shapedMesh = flameModel.geometry.attributes.position.array;
-    const pointNum = shapedMesh.length / 3;
-    
-    const boneWeightTextureSize = new Vector2(512, 512);
-    const boneWeightTextureData = new Float32Array(boneWeightTextureSize.x * boneWeightTextureSize.y * 4);
-    const boneWeightTextureDataInt = new Uint32Array(boneWeightTextureSize.x * boneWeightTextureSize.y * 4);
-
-    for (let i = 0; i < pointNum; i++) {
-        // Store 5 bone weights per vertex (2 texels)
-        boneWeightTextureData[i * 8 + 0] = bonesWeight[i][0];
-        boneWeightTextureData[i * 8 + 1] = bonesWeight[i][1];
-        boneWeightTextureData[i * 8 + 2] = bonesWeight[i][2];
-        boneWeightTextureData[i * 8 + 3] = bonesWeight[i][3];
-        boneWeightTextureData[i * 8 + 4] = bonesWeight[i][4];
-
-        boneWeightTextureDataInt[i * 8 + 0] = uintEncodedFloat(bonesWeight[i][0]);
-        boneWeightTextureDataInt[i * 8 + 1] = uintEncodedFloat(bonesWeight[i][1]);
-        boneWeightTextureDataInt[i * 8 + 2] = uintEncodedFloat(bonesWeight[i][2]);
-        boneWeightTextureDataInt[i * 8 + 3] = uintEncodedFloat(bonesWeight[i][3]);
-        boneWeightTextureDataInt[i * 8 + 4] = uintEncodedFloat(bonesWeight[i][4]);
-    }
-
-    const boneWeightTex = new DataTexture(
-        boneWeightTextureDataInt,
-        boneWeightTextureSize.x,
-        boneWeightTextureSize.y,
-        RGBAIntegerFormat,
-        UnsignedIntType
-    );
-    boneWeightTex.internalFormat = 'RGBA32UI';
-    boneWeightTex.needsUpdate = true;
-
-    material.uniforms.boneWeightTexture.value = boneWeightTex;
-    material.uniforms.boneWeightTextureSize.value.copy(boneWeightTextureSize);
-    material.uniformsNeedUpdate = true;
-
-    return {
-        data: boneWeightTextureDataInt,
-        texture: boneWeightTex,
-        size: boneWeightTextureSize,
-        baseData: { boneWeight: boneWeightTextureDataInt }
-    };
-}
-
-/**
- * Get updated bone matrices from skeleton
- * @param {THREE.Skeleton} skeleton - The skeleton to read matrices from
- * @param {number} boneNum - Number of bones
- * @returns {Float32Array} Flattened bone matrices
- */
-export function getUpdatedBoneMatrices(skeleton, boneNum) {
-    const updatedBoneMatrices = [];
-    
-    for (let j = 0; j < boneNum; j++) {
-        const boneMatrix = skeleton.bones[j].matrixWorld.clone()
-            .multiply(skeleton.boneInverses[j].clone());
-
-        const elements = boneMatrix.elements;
-        for (let i = 0; i < elements.length; i++) {
-            updatedBoneMatrices.push(elements[i]);
-        }
-    }
-    
-    return new Float32Array(updatedBoneMatrices);
-}
-
-export const FlameTextureManager = {
-    buildModelTexture,
-    buildBoneMatrixTexture,
-    updateBoneMatrixTexture,
-    buildBoneWeightTexture,
-    getUpdatedBoneMatrices
-};
-
-export default FlameTextureManager;

package/src/flame/index.js

@@ -1,22 +0,0 @@
-/**
- * gsplat-flame-avatar - FLAME Module
- * Modified GaussianSplats3D components with FLAME parametric head model support
- */
-
-// FLAME-specific Constants (exported as FlameConstants to avoid conflict)
-export { Constants as FlameConstants } from './FlameConstants.js';
-
-// Texture Constants (not duplicated elsewhere)
-export { TextureConstants } from './utils.js';
-
-// FLAME support
-export { 
-    FlameTextureManager,
-    buildModelTexture,
-    buildBoneMatrixTexture,
-    updateBoneMatrixTexture,
-    buildBoneWeightTexture,
-    getUpdatedBoneMatrices
-} from './FlameTextureManager.js';
-
-export { FlameAnimator } from './FlameAnimator.js';

package/src/flame/utils.js

@@ -1,50 +0,0 @@
-/**
- * FLAME Utility Functions
- * 
- * Derived from gaussian-splat-renderer-for-lam
- * Contains encoding functions and helpers for GPU texture data.
- */
-
-/**
- * Encode float as uint32 for GPU texture storage
- * Uses Float32Array/Int32Array view trick to reinterpret float bits as integer
- */
-export const uintEncodedFloat = (function() {
-    const floatView = new Float32Array(1);
-    const int32View = new Int32Array(floatView.buffer);
-
-    return function(f) {
-        floatView[0] = f;
-        return int32View[0];
-    };
-})();
-
-/**
- * Convert RGBA values to a single integer
- */
-export const rgbaToInteger = function(r, g, b, a) {
-    return r + (g << 8) + (b << 16) + (a << 24);
-};
-
-/**
- * Convert RGBA array at offset to a single integer
- */
-export const rgbaArrayToInteger = function(arr, offset) {
-    return arr[offset] + (arr[offset + 1] << 8) + (arr[offset + 2] << 16) + (arr[offset + 3] << 24);
-};
-
-/**
- * Constants for texture data layout
- */
-export const TextureConstants = {
-    CENTER_COLORS_ELEMENTS_PER_TEXEL: 4,
-    CENTER_COLORS_ELEMENTS_PER_SPLAT: 4,
-    COVARIANCES_ELEMENTS_PER_TEXEL_STORED: 2,
-    COVARIANCES_ELEMENTS_PER_TEXEL_ALLOCATED: 4,
-    COVARIANCES_ELEMENTS_PER_TEXEL_COMPRESSED_STORED: 2,
-    COVARIANCES_ELEMENTS_PER_TEXEL_COMPRESSED_ALLOCATED: 4,
-    COVARIANCES_ELEMENTS_PER_SPLAT: 6,
-    SCALES_ROTATIONS_ELEMENTS_PER_TEXEL: 4,
-    SCENE_INDEXES_ELEMENTS_PER_TEXEL: 1,
-    MAX_TEXTURE_TEXELS: 4096 * 4096
-};

package/src/index.js

@@ -1,39 +0,0 @@
-/**
- * gsplat-flame-avatar
- * 
- * A specialized Gaussian Splatting library with FLAME parametric head model support.
- * Built on Three.js for real-time facial animation of Gaussian Splat avatars.
- * 
- * Based on @mkkellogg/gaussian-splats-3d (MIT License)
- * Extended with FLAME integration from gaussian-splat-renderer-for-lam
- */
-
-// Enums
-export * from './enums/index.js';
-
-// Utils
-export * from './utils/index.js';
-
-// Api
-export * from './api/index.js';
-
-// Renderer (GaussianSplatRenderer, AnimationManager, state classes)
-export * from './renderer/index.js';
-
-// Buffers
-export * from './buffers/index.js';
-
-// Core (Viewer, SplatMesh, etc.)
-export * from './core/index.js';
-
-// Loaders
-export * from './loaders/index.js';
-
-// Materials
-export * from './materials/index.js';
-
-// Raycaster
-export * from './raycaster/index.js';
-
-// FLAME support
-export * from './flame/index.js';

package/src/loaders/DirectLoadError.js

@@ -1,14 +0,0 @@
-/**
- * DirectLoadError
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * Minor enhancement: Added this.name property for better error identification.
- */
-export class DirectLoadError extends Error {
-    constructor(msg) {
-        super(msg);
-        this.name = 'DirectLoadError';
-    }
-}

package/src/loaders/INRIAV1PlyParser.js

@@ -1,223 +0,0 @@
-/**
- * INRIAV1PlyParser
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * Import paths adjusted for gsplat-flame-avatar package structure.
- */
-
-import { Quaternion } from 'three';
-import { UncompressedSplatArray } from '../buffers/UncompressedSplatArray.js';
-import { SplatBuffer } from '../buffers/SplatBuffer.js';
-import { PlyParserUtils } from './PlyParserUtils.js';
-import { clamp } from '../utils/Util.js';
-
-const BaseFieldNamesToRead = ['scale_0', 'scale_1', 'scale_2', 'rot_0', 'rot_1', 'rot_2', 'rot_3', 'x', 'y', 'z',
-                              'f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity', 'red', 'green', 'blue', 'f_rest_0'];
-
-const BaseFieldsToReadIndexes = BaseFieldNamesToRead.map((e, i) => i);
-
-const [
-        SCALE_0, SCALE_1, SCALE_2, ROT_0, ROT_1, ROT_2, ROT_3, X, Y, Z, F_DC_0, F_DC_1, F_DC_2, OPACITY, RED, GREEN, BLUE, F_REST_0
-      ] = BaseFieldsToReadIndexes;
-
-export class INRIAV1PlyParser {
-
-    constructor() {
-        this.plyParserutils = new PlyParserUtils();
-    }
-
-    decodeHeaderLines(headerLines) {
-
-        let shLineCount = 0;
-        headerLines.forEach((line) => {
-            if (line.includes('f_rest_')) shLineCount++;
-        });
-
-        let shFieldsToReadCount = 0;
-        if (shLineCount >= 45) {
-            shFieldsToReadCount = 45;
-        } else if (shLineCount >= 24) {
-            shFieldsToReadCount = 24;
-        } else if (shLineCount >= 9) {
-            shFieldsToReadCount = 9;
-        }
-
-        const shFieldIndexesToMap = Array.from(Array(Math.max(shFieldsToReadCount - 1, 0)));
-        let shRemainingFieldNamesToRead = shFieldIndexesToMap.map((element, index) => `f_rest_${index + 1}`);
-
-        const fieldNamesToRead = [...BaseFieldNamesToRead, ...shRemainingFieldNamesToRead];
-        const fieldsToReadIndexes = fieldNamesToRead.map((e, i) => i);
-
-        const fieldNameIdMap = fieldsToReadIndexes.reduce((acc, element) => {
-            acc[fieldNamesToRead[element]] = element;
-            return acc;
-        }, {});
-        const header = this.plyParserutils.decodeSectionHeader(headerLines, fieldNameIdMap, 0);
-        header.splatCount = header.vertexCount;
-        header.bytesPerSplat = header.bytesPerVertex;
-        header.fieldsToReadIndexes = fieldsToReadIndexes;
-        return header;
-    }
-
-    decodeHeaderText(headerText) {
-        const headerLines = PlyParserUtils.convertHeaderTextToLines(headerText);
-        const header = this.decodeHeaderLines(headerLines);
-        header.headerText = headerText;
-        header.headerSizeBytes = headerText.indexOf(PlyParserUtils.HeaderEndToken) + PlyParserUtils.HeaderEndToken.length + 1;
-        return header;
-    }
-
-    decodeHeaderFromBuffer(plyBuffer) {
-        const headerText = this.plyParserutils.readHeaderFromBuffer(plyBuffer);
-        return this.decodeHeaderText(headerText);
-    }
-
-    findSplatData(plyBuffer, header) {
-        return new DataView(plyBuffer, header.headerSizeBytes);
-    }
-
-    parseToUncompressedSplatBufferSection(header, fromSplat, toSplat, splatData, splatDataOffset,
-                                          toBuffer, toOffset, outSphericalHarmonicsDegree = 0) {
-        outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree);
-        const outBytesPerSplat = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[outSphericalHarmonicsDegree].BytesPerSplat;
-
-        for (let i = fromSplat; i <= toSplat; i++) {
-            const parsedSplat = INRIAV1PlyParser.parseToUncompressedSplat(splatData, i, header,
-                                                                          splatDataOffset, outSphericalHarmonicsDegree);
-            const outBase = i * outBytesPerSplat + toOffset;
-            SplatBuffer.writeSplatDataToSectionBuffer(parsedSplat, toBuffer, outBase, 0, outSphericalHarmonicsDegree);
-        }
-    }
-
-    parseToUncompressedSplatArraySection(header, fromSplat, toSplat, splatData, splatDataOffset,
-                                         splatArray, outSphericalHarmonicsDegree = 0) {
-        outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree);
-        for (let i = fromSplat; i <= toSplat; i++) {
-            const parsedSplat = INRIAV1PlyParser.parseToUncompressedSplat(splatData, i, header,
-                                                                          splatDataOffset, outSphericalHarmonicsDegree);
-            splatArray.addSplat(parsedSplat);
-        }
-    }
-
-    decodeSectionSplatData(sectionSplatData, splatCount, sectionHeader, outSphericalHarmonicsDegree) {
-        outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, sectionHeader.sphericalHarmonicsDegree);
-        const splatArray = new UncompressedSplatArray(outSphericalHarmonicsDegree);
-        for (let row = 0; row < splatCount; row++) {
-            const newSplat = INRIAV1PlyParser.parseToUncompressedSplat(sectionSplatData, row, sectionHeader,
-                                                                       0, outSphericalHarmonicsDegree);
-            splatArray.addSplat(newSplat);
-        }
-        return splatArray;
-    }
-
-    static parseToUncompressedSplat = function() {
-
-        let rawSplat = [];
-        const tempRotation = new Quaternion();
-
-        const OFFSET_X = UncompressedSplatArray.OFFSET.X;
-        const OFFSET_Y = UncompressedSplatArray.OFFSET.Y;
-        const OFFSET_Z = UncompressedSplatArray.OFFSET.Z;
-
-        const OFFSET_SCALE0 = UncompressedSplatArray.OFFSET.SCALE0;
-        const OFFSET_SCALE1 = UncompressedSplatArray.OFFSET.SCALE1;
-        const OFFSET_SCALE2 = UncompressedSplatArray.OFFSET.SCALE2;
-
-        const OFFSET_ROTATION0 = UncompressedSplatArray.OFFSET.ROTATION0;
-        const OFFSET_ROTATION1 = UncompressedSplatArray.OFFSET.ROTATION1;
-        const OFFSET_ROTATION2 = UncompressedSplatArray.OFFSET.ROTATION2;
-        const OFFSET_ROTATION3 = UncompressedSplatArray.OFFSET.ROTATION3;
-
-        const OFFSET_FDC0 = UncompressedSplatArray.OFFSET.FDC0;
-        const OFFSET_FDC1 = UncompressedSplatArray.OFFSET.FDC1;
-        const OFFSET_FDC2 = UncompressedSplatArray.OFFSET.FDC2;
-        const OFFSET_OPACITY = UncompressedSplatArray.OFFSET.OPACITY;
-
-        const OFFSET_FRC = [];
-
-        for (let i = 0; i < 45; i++) {
-            OFFSET_FRC[i] = UncompressedSplatArray.OFFSET.FRC0 + i;
-        }
-
-        return function(splatData, row, header, splatDataOffset = 0, outSphericalHarmonicsDegree = 0) {
-            outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree);
-            INRIAV1PlyParser.readSplat(splatData, header, row, splatDataOffset, rawSplat);
-            const newSplat = UncompressedSplatArray.createSplat(outSphericalHarmonicsDegree);
-            if (rawSplat[SCALE_0] !== undefined) {
-                newSplat[OFFSET_SCALE0] = Math.exp(rawSplat[SCALE_0]);
-                newSplat[OFFSET_SCALE1] = Math.exp(rawSplat[SCALE_1]);
-                newSplat[OFFSET_SCALE2] = Math.exp(rawSplat[SCALE_2]);
-            } else {
-                newSplat[OFFSET_SCALE0] = 0.01;
-                newSplat[OFFSET_SCALE1] = 0.01;
-                newSplat[OFFSET_SCALE2] = 0.01;
-            }
-
-            if (rawSplat[F_DC_0] !== undefined) {
-                const SH_C0 = 0.28209479177387814;
-                newSplat[OFFSET_FDC0] = rawSplat[F_DC_0] * 255;
-                newSplat[OFFSET_FDC1] = rawSplat[F_DC_1] * 255;
-                newSplat[OFFSET_FDC2] = rawSplat[F_DC_2] * 255;
-            } else if (rawSplat[RED] !== undefined) {
-                newSplat[OFFSET_FDC0] = rawSplat[RED] * 255;
-                newSplat[OFFSET_FDC1] = rawSplat[GREEN] * 255;
-                newSplat[OFFSET_FDC2] = rawSplat[BLUE] * 255;
-            } else {
-                newSplat[OFFSET_FDC0] = 0;
-                newSplat[OFFSET_FDC1] = 0;
-                newSplat[OFFSET_FDC2] = 0;
-            }
-
-            if (rawSplat[OPACITY] !== undefined) {
-                newSplat[OFFSET_OPACITY] = (1 / (1 + Math.exp(-rawSplat[OPACITY]))) * 255;
-            }
-
-            newSplat[OFFSET_FDC0] = clamp(Math.floor(newSplat[OFFSET_FDC0]), 0, 255);
-            newSplat[OFFSET_FDC1] = clamp(Math.floor(newSplat[OFFSET_FDC1]), 0, 255);
-            newSplat[OFFSET_FDC2] = clamp(Math.floor(newSplat[OFFSET_FDC2]), 0, 255);
-            newSplat[OFFSET_OPACITY] = clamp(Math.floor(newSplat[OFFSET_OPACITY]), 0, 255);
-
-            if (outSphericalHarmonicsDegree >= 1) {
-                if (rawSplat[F_REST_0] !== undefined) {
-                    for (let i = 0; i < 9; i++) {
-                        newSplat[OFFSET_FRC[i]] = rawSplat[header.sphericalHarmonicsDegree1Fields[i]];
-                    }
-                    if (outSphericalHarmonicsDegree >= 2) {
-                        for (let i = 0; i < 15; i++) {
-                            newSplat[OFFSET_FRC[9 + i]] = rawSplat[header.sphericalHarmonicsDegree2Fields[i]];
-                        }
-                    }
-                }
-            }
-
-            tempRotation.set(rawSplat[ROT_0], rawSplat[ROT_1], rawSplat[ROT_2], rawSplat[ROT_3]);
-            tempRotation.normalize();
-
-            newSplat[OFFSET_ROTATION0] = tempRotation.x;
-            newSplat[OFFSET_ROTATION1] = tempRotation.y;
-            newSplat[OFFSET_ROTATION2] = tempRotation.z;
-            newSplat[OFFSET_ROTATION3] = tempRotation.w;
-
-            newSplat[OFFSET_X] = rawSplat[X];
-            newSplat[OFFSET_Y] = rawSplat[Y];
-            newSplat[OFFSET_Z] = rawSplat[Z];
-
-            return newSplat;
-        };
-
-    }();
-
-    static readSplat(splatData, header, row, dataOffset, rawSplat) {
-        return PlyParserUtils.readVertex(splatData, header, row, dataOffset, header.fieldsToReadIndexes, rawSplat, true);
-    }
-
-    parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree = 0) {
-        const header = this.decodeHeaderFromBuffer(plyBuffer);
-        const splatCount = header.splatCount;
-        const splatData = this.findSplatData(plyBuffer, header);
-        const splatArray = this.decodeSectionSplatData(splatData, splatCount, header, outSphericalHarmonicsDegree);
-        return splatArray;
-    }
-}