@myned-ai/gsplat-flame-avatar-renderer 1.0.1 → 1.0.4

package/src/loaders/PlyLoader.js

@@ -0,0 +1,261 @@
+/**
+ * PlyLoader
+ * 
+ * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
+ * https://github.com/mkkellogg/GaussianSplats3D
+ * 
+ * Simplified for FLAME avatar - only supports INRIAV1 PLY format.
+ */
+
+import { Vector3 } from 'three';
+import { SplatBuffer } from '../buffers/SplatBuffer.js';
+import { UncompressedSplatArray } from '../buffers/UncompressedSplatArray.js';
+import { SplatBufferGenerator } from '../buffers/SplatBufferGenerator.js';
+import { PlyParser } from './PlyParser.js';
+import { PlyParserUtils } from './PlyParserUtils.js';
+import { INRIAV1PlyParser } from './INRIAV1PlyParser.js';
+import { Constants, InternalLoadType, LoaderStatus } from '../enums/EngineConstants.js';
+import { fetchWithProgress, delayedExecute, nativePromiseWithExtractedComponents } from '../utils/Util.js';
+
+/**
+ * Helper function to store chunks into a single buffer
+ */
+function storeChunksInBuffer(chunks, buffer) {
+    let inBytes = 0;
+    for (let chunk of chunks) inBytes += chunk.sizeBytes;
+
+    if (!buffer || buffer.byteLength < inBytes) {
+        buffer = new ArrayBuffer(inBytes);
+    }
+
+    let offset = 0;
+    for (let chunk of chunks) {
+        new Uint8Array(buffer, offset, chunk.sizeBytes).set(chunk.data);
+        offset += chunk.sizeBytes;
+    }
+
+    return buffer;
+}
+
+/**
+ * Helper function to finalize splat data
+ */
+function finalize$1(splatData, optimizeSplatData, minimumAlpha, compressionLevel, sectionSize, sceneCenter, blockSize, bucketSize) {
+    if (optimizeSplatData) {
+        const splatBufferGenerator = SplatBufferGenerator.getStandardGenerator(minimumAlpha, compressionLevel,
+                                                                               sectionSize, sceneCenter,
+                                                                               blockSize, bucketSize);
+        return splatBufferGenerator.generateFromUncompressedSplatArray(splatData);
+    } else {
+        return SplatBuffer.generateFromUncompressedSplatArrays([splatData], minimumAlpha, 0, new Vector3());
+    }
+}
+
+export class PlyLoader {
+
+    static loadFromURL(fileName, onProgress, loadDirectoToSplatBuffer, onProgressiveLoadSectionProgress,
+                       minimumAlpha, compressionLevel, optimizeSplatData = true, outSphericalHarmonicsDegree = 0,
+                       headers, sectionSize, sceneCenter, blockSize, bucketSize) {
+
+        let internalLoadType = loadDirectoToSplatBuffer ? InternalLoadType.DirectToSplatBuffer : InternalLoadType.DirectToSplatArray;
+        if (optimizeSplatData) internalLoadType = InternalLoadType.DirectToSplatArray;
+
+        const directLoadSectionSizeBytes = Constants.ProgressiveLoadSectionSize;
+        const splatDataOffsetBytes = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes;
+        const sectionCount = 1;
+
+        let directLoadBufferIn;
+        let directLoadBufferOut;
+        let directLoadSplatBuffer;
+        let maxSplatCount = 0;
+        let splatCount = 0;
+
+        let headerLoaded = false;
+        let readyToLoadSplatData = false;
+
+        const loadPromise = nativePromiseWithExtractedComponents();
+
+        let numBytesStreamed = 0;
+        let numBytesParsed = 0;
+        let numBytesDownloaded = 0;
+        let headerText = '';
+        let header = null;
+        let chunks = [];
+
+        let standardLoadUncompressedSplatArray;
+
+        const textDecoder = new TextDecoder();
+        const inriaV1PlyParser = new INRIAV1PlyParser();
+
+        const localOnProgress = (percent, percentLabel, chunkData) => {
+            const loadComplete = percent >= 100;
+
+            if (chunkData) {
+                chunks.push({
+                    'data': chunkData,
+                    'sizeBytes': chunkData.byteLength,
+                    'startBytes': numBytesDownloaded,
+                    'endBytes': numBytesDownloaded + chunkData.byteLength
+                });
+                numBytesDownloaded += chunkData.byteLength;
+            }
+
+            if (internalLoadType === InternalLoadType.DownloadBeforeProcessing) {
+                if (loadComplete) {
+                    loadPromise.resolve(chunks);
+                }
+            } else {
+                if (!headerLoaded) {
+                    headerText += textDecoder.decode(chunkData);
+                    if (PlyParserUtils.checkTextForEndHeader(headerText)) {
+                        // FLAME avatars use INRIAV1 format
+                        header = inriaV1PlyParser.decodeHeaderText(headerText);
+                        maxSplatCount = header.splatCount;
+                        readyToLoadSplatData = true;
+                        
+                        outSphericalHarmonicsDegree = Math.min(outSphericalHarmonicsDegree, header.sphericalHarmonicsDegree);
+
+                        const shDescriptor = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[outSphericalHarmonicsDegree];
+                        const splatBufferSizeBytes = splatDataOffsetBytes + shDescriptor.BytesPerSplat * maxSplatCount;
+
+                        if (internalLoadType === InternalLoadType.DirectToSplatBuffer) {
+                            directLoadBufferOut = new ArrayBuffer(splatBufferSizeBytes);
+                            SplatBuffer.writeHeaderToBuffer({
+                                versionMajor: SplatBuffer.CurrentMajorVersion,
+                                versionMinor: SplatBuffer.CurrentMinorVersion,
+                                maxSectionCount: sectionCount,
+                                sectionCount: sectionCount,
+                                maxSplatCount: maxSplatCount,
+                                splatCount: splatCount,
+                                compressionLevel: 0,
+                                sceneCenter: new Vector3()
+                            }, directLoadBufferOut);
+                        } else {
+                            standardLoadUncompressedSplatArray = new UncompressedSplatArray(outSphericalHarmonicsDegree);
+                        }
+
+                        numBytesStreamed = header.headerSizeBytes;
+                        numBytesParsed = header.headerSizeBytes;
+                        headerLoaded = true;
+                    }
+                }
+
+                if (headerLoaded && readyToLoadSplatData) {
+
+                    if (chunks.length > 0) {
+
+                        directLoadBufferIn = storeChunksInBuffer(chunks, directLoadBufferIn);
+
+                        const bytesLoadedSinceLastStreamedSection = numBytesDownloaded - numBytesStreamed;
+                        if (bytesLoadedSinceLastStreamedSection > directLoadSectionSizeBytes || loadComplete) {
+                            const numBytesToProcess = numBytesDownloaded - numBytesParsed;
+                            const addedSplatCount = Math.floor(numBytesToProcess / header.bytesPerSplat);
+                            const numBytesToParse = addedSplatCount * header.bytesPerSplat;
+                            const numBytesLeftOver = numBytesToProcess - numBytesToParse;
+                            const newSplatCount = splatCount + addedSplatCount;
+                            const parsedDataViewOffset = numBytesParsed - chunks[0].startBytes;
+                            const dataToParse = new DataView(directLoadBufferIn, parsedDataViewOffset, numBytesToParse);
+
+                            const shDescriptor = SplatBuffer.CompressionLevels[0].SphericalHarmonicsDegrees[outSphericalHarmonicsDegree];
+                            const outOffset = splatCount * shDescriptor.BytesPerSplat + splatDataOffsetBytes;
+
+                            if (internalLoadType === InternalLoadType.DirectToSplatBuffer) {
+                                inriaV1PlyParser.parseToUncompressedSplatBufferSection(header, 0, addedSplatCount - 1, dataToParse,
+                                                                                    0, directLoadBufferOut, outOffset,
+                                                                                    outSphericalHarmonicsDegree);
+                            } else {
+                                inriaV1PlyParser.parseToUncompressedSplatArraySection(header, 0, addedSplatCount - 1, dataToParse,
+                                                                                    0, standardLoadUncompressedSplatArray,
+                                                                                    outSphericalHarmonicsDegree);
+                            }
+
+                            splatCount = newSplatCount;
+
+                            if (internalLoadType === InternalLoadType.DirectToSplatBuffer) {
+                                if (!directLoadSplatBuffer) {
+                                    SplatBuffer.writeSectionHeaderToBuffer({
+                                        maxSplatCount: maxSplatCount,
+                                        splatCount: splatCount,
+                                        bucketSize: 0,
+                                        bucketCount: 0,
+                                        bucketBlockSize: 0,
+                                        compressionScaleRange: 0,
+                                        storageSizeBytes: 0,
+                                        fullBucketCount: 0,
+                                        partiallyFilledBucketCount: 0,
+                                        sphericalHarmonicsDegree: outSphericalHarmonicsDegree
+                                    }, 0, directLoadBufferOut, SplatBuffer.HeaderSizeBytes);
+                                    directLoadSplatBuffer = new SplatBuffer(directLoadBufferOut, false);
+                                }
+                                directLoadSplatBuffer.updateLoadedCounts(1, splatCount);
+                                if (onProgressiveLoadSectionProgress) {
+                                    onProgressiveLoadSectionProgress(directLoadSplatBuffer, loadComplete);
+                                }
+                            }
+
+                            numBytesStreamed += directLoadSectionSizeBytes;
+                            numBytesParsed += numBytesToParse;
+
+                            if (numBytesLeftOver === 0) {
+                                chunks = [];
+                            } else {
+                                let keepChunks = [];
+                                let keepSize = 0;
+                                for (let i = chunks.length - 1; i >= 0; i--) {
+                                    const chunk = chunks[i];
+                                    keepSize += chunk.sizeBytes;
+                                    keepChunks.unshift(chunk);
+                                    if (keepSize >= numBytesLeftOver) break;
+                                }
+                                chunks = keepChunks;
+                            }
+                        }
+                    }
+
+                    if (loadComplete) {
+                        if (internalLoadType === InternalLoadType.DirectToSplatBuffer) {
+                            loadPromise.resolve(directLoadSplatBuffer);
+                        } else {
+                            loadPromise.resolve(standardLoadUncompressedSplatArray);
+                        }
+                    }
+                }
+            }
+
+            if (onProgress) onProgress(percent, percentLabel, LoaderStatus.Downloading);
+        };
+
+        if (onProgress) onProgress(0, '0%', LoaderStatus.Downloading);
+        return fetchWithProgress(fileName, localOnProgress, false, headers).then(() => {
+            if (onProgress) onProgress(0, '0%', LoaderStatus.Processing);
+            return loadPromise.promise.then((splatData) => {
+                if (onProgress) onProgress(100, '100%', LoaderStatus.Done);
+                if (internalLoadType === InternalLoadType.DownloadBeforeProcessing) {
+                    const chunkDatas = chunks.map((chunk) => chunk.data);
+                    return new Blob(chunkDatas).arrayBuffer().then((plyFileData) => {
+                        return PlyLoader.loadFromFileData(plyFileData, minimumAlpha, compressionLevel, optimizeSplatData,
+                                                          outSphericalHarmonicsDegree, sectionSize, sceneCenter, blockSize, bucketSize);
+                    });
+                } else if (internalLoadType === InternalLoadType.DirectToSplatBuffer) {
+                    return splatData;
+                } else {
+                    return delayedExecute(() => {
+                        return finalize$1(splatData, optimizeSplatData, minimumAlpha, compressionLevel,
+                                        sectionSize, sceneCenter, blockSize, bucketSize);
+                    });
+                }
+            });
+        });
+    }
+
+    static loadFromFileData(plyFileData, minimumAlpha, compressionLevel, optimizeSplatData, outSphericalHarmonicsDegree = 0,
+                            sectionSize, sceneCenter, blockSize, bucketSize) {
+        return delayedExecute(() => {
+            return PlyParser.parseToUncompressedSplatArray(plyFileData, outSphericalHarmonicsDegree);
+        })
+        .then((splatArray) => {
+            return finalize$1(splatArray, optimizeSplatData, minimumAlpha, compressionLevel,
+                            sectionSize, sceneCenter, blockSize, bucketSize);
+        });
+    }
+}

package/src/loaders/PlyParser.js

@@ -0,0 +1,19 @@
+/**
+ * PlyParser
+ * 
+ * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
+ * https://github.com/mkkellogg/GaussianSplats3D
+ * 
+ * Simplified for FLAME avatar - only supports INRIAV1 PLY format.
+ */
+
+import { INRIAV1PlyParser } from './INRIAV1PlyParser.js';
+
+export class PlyParser {
+
+    static parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree = 0) {
+        // FLAME avatars use INRIAV1 PLY format
+        return new INRIAV1PlyParser().parseToUncompressedSplatArray(plyBuffer, outSphericalHarmonicsDegree);
+    }
+
+}

package/src/loaders/PlyParserUtils.js

@@ -0,0 +1,311 @@
+/**
+ * PlyParserUtils and related constants
+ * 
+ * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
+ * https://github.com/mkkellogg/GaussianSplats3D
+ * 
+ * Simplified for FLAME avatar - only supports INRIAV1 format.
+ */
+
+// Ply format types (simplified - FLAME uses INRIAV1)
+export const PlyFormat = {
+    'INRIAV1': 0
+};
+
+// Field size IDs
+export const FieldSizeIdDouble = 0;
+export const FieldSizeIdInt = 1;
+export const FieldSizeIdUInt = 2;
+export const FieldSizeIdFloat = 3;
+export const FieldSizeIdShort = 4;
+export const FieldSizeIdUShort = 5;
+export const FieldSizeIdUChar = 6;
+
+export const FieldSizeStringMap = {
+    'double': FieldSizeIdDouble,
+    'int': FieldSizeIdInt,
+    'uint': FieldSizeIdUInt,
+    'float': FieldSizeIdFloat,
+    'short': FieldSizeIdShort,
+    'ushort': FieldSizeIdUShort,
+    'uchar': FieldSizeIdUChar,
+};
+
+export const FieldSize = {
+    [FieldSizeIdDouble]: 8,
+    [FieldSizeIdInt]: 4,
+    [FieldSizeIdUInt]: 4,
+    [FieldSizeIdFloat]: 4,
+    [FieldSizeIdShort]: 2,
+    [FieldSizeIdUShort]: 2,
+    [FieldSizeIdUChar]: 1,
+};
+
+export class PlyParserUtils {
+
+    static HeaderEndToken = 'end_header';
+
+    constructor() {
+    }
+
+    decodeSectionHeader(headerLines, fieldNameIdMap, headerStartLine = 0) {
+
+        const extractedLines = [];
+
+        let processingSection = false;
+        let headerEndLine = -1;
+        let vertexCount = 0;
+        let endOfHeader = false;
+        let sectionName = null;
+
+        const fieldIds = [];
+        const fieldTypes = [];
+        const allFieldNames = [];
+        const usedFieldNames = [];
+        const fieldTypesByName = {};
+
+        for (let i = headerStartLine; i < headerLines.length; i++) {
+            const line = headerLines[i].trim();
+            if (line.startsWith('element')) {
+                if (processingSection) {
+                    headerEndLine--;
+                    break;
+                } else {
+                    processingSection = true;
+                    headerStartLine = i;
+                    headerEndLine = i;
+                    const lineComponents = line.split(' ');
+                    let validComponents = 0;
+                    for (let lineComponent of lineComponents) {
+                        const trimmedComponent = lineComponent.trim();
+                        if (trimmedComponent.length > 0) {
+                            validComponents++;
+                            if (validComponents === 2) {
+                                sectionName = trimmedComponent;
+                            } else if (validComponents === 3) {
+                                vertexCount = parseInt(trimmedComponent);
+                            }
+                        }
+                    }
+                }
+            } else if (line.startsWith('property')) {
+                const fieldMatch = line.match(/(\w+)\s+(\w+)\s+(\w+)/);
+                if (fieldMatch) {
+                    const fieldTypeStr = fieldMatch[2];
+                    const fieldName = fieldMatch[3];
+                    allFieldNames.push(fieldName);
+                    const fieldId = fieldNameIdMap[fieldName];
+                    fieldTypesByName[fieldName] = fieldTypeStr;
+                    const fieldType = FieldSizeStringMap[fieldTypeStr];
+                    if (fieldId !== undefined) {
+                        usedFieldNames.push(fieldName);
+                        fieldIds.push(fieldId);
+                        fieldTypes[fieldId] = fieldType;
+                    }
+                }
+            }
+            if (line === PlyParserUtils.HeaderEndToken) {
+                endOfHeader = true;
+                break;
+            }
+            if (processingSection) {
+                extractedLines.push(line);
+                headerEndLine++;
+            }
+        }
+
+        const fieldOffsets = [];
+        let bytesPerVertex = 0;
+        for (let fieldName of allFieldNames) {
+            const fieldType = fieldTypesByName[fieldName];
+            if (Object.hasOwn(fieldTypesByName, fieldName)) {
+                const fieldId = fieldNameIdMap[fieldName];
+                if (fieldId !== undefined) {
+                    fieldOffsets[fieldId] = bytesPerVertex;
+                }
+            }
+            bytesPerVertex += FieldSize[FieldSizeStringMap[fieldType]];
+        }
+
+        const sphericalHarmonics = this.decodeSphericalHarmonicsFromSectionHeader(allFieldNames, fieldNameIdMap);
+
+        return {
+            'headerLines': extractedLines,
+            'headerStartLine': headerStartLine,
+            'headerEndLine': headerEndLine,
+            'fieldTypes': fieldTypes,
+            'fieldIds': fieldIds,
+            'fieldOffsets': fieldOffsets,
+            'bytesPerVertex': bytesPerVertex,
+            'vertexCount': vertexCount,
+            'dataSizeBytes': bytesPerVertex * vertexCount,
+            'endOfHeader': endOfHeader,
+            'sectionName': sectionName,
+            'sphericalHarmonicsDegree': sphericalHarmonics.degree,
+            'sphericalHarmonicsCoefficientsPerChannel': sphericalHarmonics.coefficientsPerChannel,
+            'sphericalHarmonicsDegree1Fields': sphericalHarmonics.degree1Fields,
+            'sphericalHarmonicsDegree2Fields': sphericalHarmonics.degree2Fields
+        };
+    }
+
+    decodeSphericalHarmonicsFromSectionHeader(fieldNames, fieldNameIdMap) {
+        let sphericalHarmonicsFieldCount = 0;
+        let coefficientsPerChannel = 0;
+        for (let fieldName of fieldNames) {
+            if (fieldName.startsWith('f_rest')) sphericalHarmonicsFieldCount++;
+        }
+        coefficientsPerChannel = sphericalHarmonicsFieldCount / 3;
+        let degree = 0;
+        if (coefficientsPerChannel >= 3) degree = 1;
+        if (coefficientsPerChannel >= 8) degree = 2;
+
+        let degree1Fields = [];
+        let degree2Fields = [];
+
+        for (let rgb = 0; rgb < 3; rgb++) {
+            if (degree >= 1) {
+                for (let i = 0; i < 3; i++) {
+                    degree1Fields.push(fieldNameIdMap['f_rest_' + (i + coefficientsPerChannel * rgb)]);
+                }
+            }
+            if (degree >= 2) {
+                for (let i = 0; i < 5; i++) {
+                    degree2Fields.push(fieldNameIdMap['f_rest_' + (i + coefficientsPerChannel * rgb + 3)]);
+                }
+            }
+        }
+
+        return {
+            'degree': degree,
+            'coefficientsPerChannel': coefficientsPerChannel,
+            'degree1Fields': degree1Fields,
+            'degree2Fields': degree2Fields
+        };
+    }
+
+    static getHeaderSectionNames(headerLines) {
+        const sectionNames = [];
+        for (let headerLine of headerLines) {
+            if (headerLine.startsWith('element')) {
+                const lineComponents = headerLine.split(' ');
+                let validComponents = 0;
+                for (let lineComponent of lineComponents) {
+                    const trimmedComponent = lineComponent.trim();
+                    if (trimmedComponent.length > 0) {
+                        validComponents++;
+                        if (validComponents === 2) {
+                            sectionNames.push(trimmedComponent);
+                        }
+                    }
+                }
+            }
+        }
+        return sectionNames;
+    }
+
+    static checkTextForEndHeader(endHeaderTestText) {
+        if (endHeaderTestText.includes(PlyParserUtils.HeaderEndToken)) {
+            return true;
+        }
+        return false;
+    }
+
+    static checkBufferForEndHeader(buffer, searchOfset, chunkSize, decoder) {
+        const endHeaderTestChunk = new Uint8Array(buffer, Math.max(0, searchOfset - chunkSize), chunkSize);
+        const endHeaderTestText = decoder.decode(endHeaderTestChunk);
+        return PlyParserUtils.checkTextForEndHeader(endHeaderTestText);
+    }
+
+    static extractHeaderFromBufferToText(plyBuffer) {
+        const decoder = new TextDecoder();
+        let headerOffset = 0;
+        let headerText = '';
+        const readChunkSize = 100;
+
+        while (true) {
+            if (headerOffset + readChunkSize >= plyBuffer.byteLength) {
+                throw new Error('End of file reached while searching for end of header');
+            }
+            const headerChunk = new Uint8Array(plyBuffer, headerOffset, readChunkSize);
+            headerText += decoder.decode(headerChunk);
+            headerOffset += readChunkSize;
+
+            if (PlyParserUtils.checkBufferForEndHeader(plyBuffer, headerOffset, readChunkSize * 2, decoder)) {
+                break;
+            }
+        }
+
+        return headerText;
+    }
+
+    readHeaderFromBuffer(plyBuffer) {
+        const decoder = new TextDecoder();
+        let headerOffset = 0;
+        let headerText = '';
+        const readChunkSize = 100;
+
+        while (true) {
+            if (headerOffset + readChunkSize >= plyBuffer.byteLength) {
+                throw new Error('End of file reached while searching for end of header');
+            }
+            const headerChunk = new Uint8Array(plyBuffer, headerOffset, readChunkSize);
+            headerText += decoder.decode(headerChunk);
+            headerOffset += readChunkSize;
+
+            if (PlyParserUtils.checkBufferForEndHeader(plyBuffer, headerOffset, readChunkSize * 2, decoder)) {
+                break;
+            }
+        }
+
+        return headerText;
+    }
+
+    static convertHeaderTextToLines(headerText) {
+        const headerLines = headerText.split('\n');
+        const prunedLines = [];
+        for (let i = 0; i < headerLines.length; i++) {
+            const line = headerLines[i].trim();
+            prunedLines.push(line);
+            if (line === PlyParserUtils.HeaderEndToken) {
+                break;
+            }
+        }
+        return prunedLines;
+    }
+
+    static determineHeaderFormatFromHeaderText(_headerText) {
+        // Simplified - FLAME avatars always use INRIAV1 format
+        return PlyFormat.INRIAV1;
+    }
+
+    static determineHeaderFormatFromPlyBuffer(plyBuffer) {
+        const headertText = PlyParserUtils.extractHeaderFromBufferToText(plyBuffer);
+        return PlyParserUtils.determineHeaderFormatFromHeaderText(headertText);
+    }
+
+    static readVertex(vertexData, header, row, dataOffset, fieldsToRead, rawVertex, normalize = true) {
+        const offset = row * header.bytesPerVertex + dataOffset;
+        const fieldOffsets = header.fieldOffsets;
+        const fieldTypes = header.fieldTypes;
+        for (let fieldId of fieldsToRead) {
+            const fieldType = fieldTypes[fieldId];
+            if (fieldType === FieldSizeIdFloat) {
+                rawVertex[fieldId] = vertexData.getFloat32(offset + fieldOffsets[fieldId], true);
+            } else if (fieldType === FieldSizeIdShort) {
+                rawVertex[fieldId] = vertexData.getInt16(offset + fieldOffsets[fieldId], true);
+            } else if (fieldType === FieldSizeIdUShort) {
+                rawVertex[fieldId] = vertexData.getUint16(offset + fieldOffsets[fieldId], true);
+            } else if (fieldType === FieldSizeIdInt) {
+                rawVertex[fieldId] = vertexData.getInt32(offset + fieldOffsets[fieldId], true);
+            } else if (fieldType === FieldSizeIdUInt) {
+                rawVertex[fieldId] = vertexData.getUint32(offset + fieldOffsets[fieldId], true);
+            } else if (fieldType === FieldSizeIdUChar) {
+                if (normalize) {
+                    rawVertex[fieldId] = vertexData.getUint8(offset + fieldOffsets[fieldId]) / 255.0;
+                } else {
+                    rawVertex[fieldId] = vertexData.getUint8(offset + fieldOffsets[fieldId]);
+                }
+            }
+        }
+    }
+}

package/src/loaders/index.js

@@ -0,0 +1,13 @@
+/**
+ * gsplat-flame-avatar - Loaders Module
+ * File format loaders for PLY (INRIAV1 format).
+ * 
+ * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
+ * Simplified for FLAME avatar usage.
+ */
+
+export { PlyLoader } from './PlyLoader.js';
+export { PlyParser } from './PlyParser.js';
+export { PlyParserUtils, PlyFormat, FieldSize, FieldSizeStringMap } from './PlyParserUtils.js';
+export { INRIAV1PlyParser } from './INRIAV1PlyParser.js';
+export { DirectLoadError } from './DirectLoadError.js';