@playcanvas/splat-transform 0.5.3 → 0.6.0

package/dist/index.mjs

@@ -1884,7 +1884,7 @@ let Quat$1 = class Quat {
 		}
 };
 
-var version$1 = "0.5.3";
+var version$1 = "0.6.0";
 
 class Column {
     name;
@@ -1909,17 +1909,6 @@ class Column {
     clone() {
         return new Column(this.name, this.data.slice());
     }
-    filter(length, filter) {
-        const constructor = this.data.constructor;
-        const data = new constructor(length);
-        let j = 0;
-        for (let i = 0; i < this.data.length; i++) {
-            if (filter[i]) {
-                data[j++] = this.data[i];
-            }
-        }
-        return new Column(this.name, data);
-    }
 }
 class DataTable {
     columns;
@@ -1995,22 +1984,20 @@ class DataTable {
     clone() {
         return new DataTable(this.columns.map(c => c.clone()));
     }
-    filter(predicate) {
-        const flags = new Uint8Array(this.numRows);
-        const row = {};
-        let numRows = 0;
-        for (let i = 0; i < this.numRows; i++) {
-            this.getRow(i, row);
-            flags[i] = predicate(i, row) ? 1 : 0;
-            numRows += flags[i];
-        }
-        if (numRows === 0) {
-            return null;
-        }
-        if (numRows === this.numRows) {
-            return this;
+    // return a new table containing the rows referenced in indices
+    permuteRows(indices) {
+        const result = new DataTable(this.columns.map((c) => {
+            const constructor = c.data.constructor;
+            return new Column(c.name, new constructor(indices.length));
+        }));
+        for (let i = 0; i < this.numColumns; ++i) {
+            const src = this.getColumn(i).data;
+            const dst = result.getColumn(i).data;
+            for (let j = 0; j < indices.length; j++) {
+                dst[j] = src[indices[j]];
+            }
         }
-        return new DataTable(this.columns.map(c => c.filter(numRows, flags)));
+        return result;
     }
 }
 
@@ -2241,6 +2228,18 @@ const transform = (dataTable, t, r, s) => {
 };
 
 const shNames$2 = new Array(45).fill('').map((_, i) => `f_rest_${i}`);
+const filter = (dataTable, predicate) => {
+    const indices = new Uint32Array(dataTable.numRows);
+    let index = 0;
+    const row = {};
+    for (let i = 0; i < dataTable.numRows; i++) {
+        dataTable.getRow(i, row);
+        if (predicate(row, i)) {
+            indices[index++] = i;
+        }
+    }
+    return dataTable.permuteRows(indices.subarray(0, index));
+};
 // process a data table with standard options
 const process = (dataTable, processActions) => {
     let result = dataTable;
@@ -2257,7 +2256,7 @@ const process = (dataTable, processActions) => {
                 transform(result, Vec3$1.ZERO, Quat$1.IDENTITY, processAction.value);
                 break;
             case 'filterNaN': {
-                const predicate = (rowIndex, row) => {
+                const predicate = (row, rowIndex) => {
                     for (const key in row) {
                         if (!isFinite(row[key])) {
                             return false;
@@ -2265,21 +2264,21 @@ const process = (dataTable, processActions) => {
                     }
                     return true;
                 };
-                result = result.filter(predicate);
+                result = filter(result, predicate);
                 break;
             }
             case 'filterByValue': {
                 const { columnName, comparator, value } = processAction;
                 const Predicates = {
-                    'lt': (rowIndex, row) => row[columnName] < value,
-                    'lte': (rowIndex, row) => row[columnName] <= value,
-                    'gt': (rowIndex, row) => row[columnName] > value,
-                    'gte': (rowIndex, row) => row[columnName] >= value,
-                    'eq': (rowIndex, row) => row[columnName] === value,
-                    'neq': (rowIndex, row) => row[columnName] !== value
+                    'lt': (row, rowIndex) => row[columnName] < value,
+                    'lte': (row, rowIndex) => row[columnName] <= value,
+                    'gt': (row, rowIndex) => row[columnName] > value,
+                    'gte': (row, rowIndex) => row[columnName] >= value,
+                    'eq': (row, rowIndex) => row[columnName] === value,
+                    'neq': (row, rowIndex) => row[columnName] !== value
                 };
-                const predicate = Predicates[comparator] ?? ((rowIndex, row) => true);
-                result = result.filter(predicate);
+                const predicate = Predicates[comparator] ?? ((row, rowIndex) => true);
+                result = filter(result, predicate);
                 break;
             }
             case 'filterBands': {
@@ -2310,6 +2309,211 @@ const process = (dataTable, processActions) => {
     return result;
 };
 
+// Size of a chunk in the compressed PLY format (number of splats per chunk)
+const CHUNK_SIZE$1 = 256;
+const isCompressedPly$1 = (ply) => {
+    const hasShape = (dataTable, columns, type) => {
+        return columns.every((name) => {
+            const col = dataTable.getColumnByName(name);
+            return col && col.dataType === type;
+        });
+    };
+    const chunkProperties = [
+        'min_x',
+        'min_y',
+        'min_z',
+        'max_x',
+        'max_y',
+        'max_z',
+        'min_scale_x',
+        'min_scale_y',
+        'min_scale_z',
+        'max_scale_x',
+        'max_scale_y',
+        'max_scale_z',
+        'min_r',
+        'min_g',
+        'min_b',
+        'max_r',
+        'max_g',
+        'max_b'
+    ];
+    const vertexProperties = [
+        'packed_position',
+        'packed_rotation',
+        'packed_scale',
+        'packed_color'
+    ];
+    const numElements = ply.elements.length;
+    if (numElements !== 2 && numElements !== 3)
+        return false;
+    const chunk = ply.elements.find(e => e.name === 'chunk');
+    if (!chunk || !hasShape(chunk.dataTable, chunkProperties, 'float32'))
+        return false;
+    const vertex = ply.elements.find(e => e.name === 'vertex');
+    if (!vertex || !hasShape(vertex.dataTable, vertexProperties, 'uint32'))
+        return false;
+    if (Math.ceil(vertex.dataTable.numRows / CHUNK_SIZE$1) !== chunk.dataTable.numRows) {
+        return false;
+    }
+    // check optional spherical harmonics
+    if (numElements === 3) {
+        const sh = ply.elements.find(e => e.name === 'sh');
+        if (!sh) {
+            return false;
+        }
+        const shData = sh.dataTable;
+        if ([9, 24, 45].indexOf(shData.numColumns) === -1) {
+            return false;
+        }
+        for (let i = 0; i < shData.numColumns; ++i) {
+            const col = shData.getColumnByName(`f_rest_${i}`);
+            if (!col || col.dataType !== 'uint8') {
+                return false;
+            }
+        }
+        if (shData.numRows !== vertex.dataTable.numRows) {
+            return false;
+        }
+    }
+    return true;
+};
+// Detects the compressed PLY schema and returns a decompressed DataTable, or null if not compressed.
+const decompressPly = (ply) => {
+    const chunkData = ply.elements.find(e => e.name === 'chunk').dataTable;
+    const getChunk = (name) => chunkData.getColumnByName(name).data;
+    const vertexData = ply.elements.find(e => e.name === 'vertex').dataTable;
+    const packed_position = vertexData.getColumnByName('packed_position').data;
+    const packed_rotation = vertexData.getColumnByName('packed_rotation').data;
+    const packed_scale = vertexData.getColumnByName('packed_scale').data;
+    const packed_color = vertexData.getColumnByName('packed_color').data;
+    const min_x = getChunk('min_x');
+    const min_y = getChunk('min_y');
+    const min_z = getChunk('min_z');
+    const max_x = getChunk('max_x');
+    const max_y = getChunk('max_y');
+    const max_z = getChunk('max_z');
+    const min_scale_x = getChunk('min_scale_x');
+    const min_scale_y = getChunk('min_scale_y');
+    const min_scale_z = getChunk('min_scale_z');
+    const max_scale_x = getChunk('max_scale_x');
+    const max_scale_y = getChunk('max_scale_y');
+    const max_scale_z = getChunk('max_scale_z');
+    const min_r = getChunk('min_r');
+    const min_g = getChunk('min_g');
+    const min_b = getChunk('min_b');
+    const max_r = getChunk('max_r');
+    const max_g = getChunk('max_g');
+    const max_b = getChunk('max_b');
+    const numSplats = vertexData.numRows;
+    const columns = [
+        new Column('x', new Float32Array(numSplats)),
+        new Column('y', new Float32Array(numSplats)),
+        new Column('z', new Float32Array(numSplats)),
+        new Column('f_dc_0', new Float32Array(numSplats)),
+        new Column('f_dc_1', new Float32Array(numSplats)),
+        new Column('f_dc_2', new Float32Array(numSplats)),
+        new Column('opacity', new Float32Array(numSplats)),
+        new Column('rot_0', new Float32Array(numSplats)),
+        new Column('rot_1', new Float32Array(numSplats)),
+        new Column('rot_2', new Float32Array(numSplats)),
+        new Column('rot_3', new Float32Array(numSplats)),
+        new Column('scale_0', new Float32Array(numSplats)),
+        new Column('scale_1', new Float32Array(numSplats)),
+        new Column('scale_2', new Float32Array(numSplats))
+    ];
+    const result = new DataTable(columns);
+    const lerp = (a, b, t) => a * (1 - t) + b * t;
+    const unpackUnorm = (value, bits) => {
+        const t = (1 << bits) - 1;
+        return (value & t) / t;
+    };
+    const unpack111011 = (value) => ({
+        x: unpackUnorm(value >>> 21, 11),
+        y: unpackUnorm(value >>> 11, 10),
+        z: unpackUnorm(value, 11)
+    });
+    const unpack8888 = (value) => ({
+        x: unpackUnorm(value >>> 24, 8),
+        y: unpackUnorm(value >>> 16, 8),
+        z: unpackUnorm(value >>> 8, 8),
+        w: unpackUnorm(value, 8)
+    });
+    const unpackRot = (value) => {
+        const norm = 1.0 / (Math.sqrt(2) * 0.5);
+        const a = (unpackUnorm(value >>> 20, 10) - 0.5) * norm;
+        const b = (unpackUnorm(value >>> 10, 10) - 0.5) * norm;
+        const c = (unpackUnorm(value, 10) - 0.5) * norm;
+        const m = Math.sqrt(Math.max(0, 1.0 - (a * a + b * b + c * c)));
+        const which = value >>> 30;
+        switch (which) {
+            case 0:
+                return { x: m, y: a, z: b, w: c };
+            case 1:
+                return { x: a, y: m, z: b, w: c };
+            case 2:
+                return { x: a, y: b, z: m, w: c };
+            default:
+                return { x: a, y: b, z: c, w: m };
+        }
+    };
+    const SH_C0 = 0.28209479177387814;
+    const ox = result.getColumnByName('x').data;
+    const oy = result.getColumnByName('y').data;
+    const oz = result.getColumnByName('z').data;
+    const or0 = result.getColumnByName('rot_0').data;
+    const or1 = result.getColumnByName('rot_1').data;
+    const or2 = result.getColumnByName('rot_2').data;
+    const or3 = result.getColumnByName('rot_3').data;
+    const os0 = result.getColumnByName('scale_0').data;
+    const os1 = result.getColumnByName('scale_1').data;
+    const os2 = result.getColumnByName('scale_2').data;
+    const of0 = result.getColumnByName('f_dc_0').data;
+    const of1 = result.getColumnByName('f_dc_1').data;
+    const of2 = result.getColumnByName('f_dc_2').data;
+    const oo = result.getColumnByName('opacity').data;
+    for (let i = 0; i < numSplats; ++i) {
+        const ci = Math.floor(i / CHUNK_SIZE$1);
+        const p = unpack111011(packed_position[i]);
+        const r = unpackRot(packed_rotation[i]);
+        const s = unpack111011(packed_scale[i]);
+        const c = unpack8888(packed_color[i]);
+        ox[i] = lerp(min_x[ci], max_x[ci], p.x);
+        oy[i] = lerp(min_y[ci], max_y[ci], p.y);
+        oz[i] = lerp(min_z[ci], max_z[ci], p.z);
+        or0[i] = r.x;
+        or1[i] = r.y;
+        or2[i] = r.z;
+        or3[i] = r.w;
+        os0[i] = lerp(min_scale_x[ci], max_scale_x[ci], s.x);
+        os1[i] = lerp(min_scale_y[ci], max_scale_y[ci], s.y);
+        os2[i] = lerp(min_scale_z[ci], max_scale_z[ci], s.z);
+        const cr = lerp(min_r[ci], max_r[ci], c.x);
+        const cg = lerp(min_g[ci], max_g[ci], c.y);
+        const cb = lerp(min_b[ci], max_b[ci], c.z);
+        of0[i] = (cr - 0.5) / SH_C0;
+        of1[i] = (cg - 0.5) / SH_C0;
+        of2[i] = (cb - 0.5) / SH_C0;
+        oo[i] = -Math.log(1 / c.w - 1);
+    }
+    // extract spherical harmonics
+    const shElem = ply.elements.find(e => e.name === 'sh');
+    if (shElem) {
+        const shData = shElem.dataTable;
+        for (let k = 0; k < shData.numColumns; ++k) {
+            const col = shData.getColumn(k);
+            const src = col.data;
+            const dst = new Float32Array(numSplats);
+            for (let i = 0; i < numSplats; ++i) {
+                const n = (src[i] === 0) ? 0 : (src[i] === 255) ? 1 : (src[i] + 0.5) / 256;
+                dst[i] = (n - 0.5) * 8;
+            }
+            result.addColumn(new Column(col.name, dst));
+        }
+    }
+    return result;
+};
+
 // Half-precision floating point decoder
 function decodeFloat16(encoded) {
     const signBit = (encoded >> 15) & 1;
@@ -3010,7 +3214,7 @@ class CompressedChunk {
 }
 
 // sort the compressed indices into morton order
-const generateOrdering = (dataTable) => {
+const generateOrdering = (dataTable, indices) => {
     const cx = dataTable.getColumnByName('x').data;
     const cy = dataTable.getColumnByName('y').data;
     const cz = dataTable.getColumnByName('z').data;
@@ -3066,9 +3270,13 @@ const generateOrdering = (dataTable) => {
             console.log('invalid extents', xlen, ylen, zlen);
             return;
         }
-        const xmul = 1024 / xlen;
-        const ymul = 1024 / ylen;
-        const zmul = 1024 / zlen;
+        // all points are identical
+        if (xlen === 0 && ylen === 0 && zlen === 0) {
+            return;
+        }
+        const xmul = (xlen === 0) ? 0 : 1024 / xlen;
+        const ymul = (ylen === 0) ? 0 : 1024 / ylen;
+        const zmul = (zlen === 0) ? 0 : 1024 / zlen;
         const morton = new Uint32Array(indices.length);
         for (let i = 0; i < indices.length; ++i) {
             const ri = indices[i];
@@ -3101,10 +3309,6 @@ const generateOrdering = (dataTable) => {
             start = end;
         }
     };
-    const indices = new Uint32Array(dataTable.numRows);
-    for (let i = 0; i < indices.length; ++i) {
-        indices[i] = i;
-    }
     generate(indices);
     return indices;
 };
@@ -3125,11 +3329,13 @@ const vertexProps = [
     'packed_color'
 ];
 const shNames$1 = new Array(45).fill('').map((_, i) => `f_rest_${i}`);
+// Size of a chunk in the compressed PLY format (number of splats per chunk)
+const CHUNK_SIZE = 256;
 const writeCompressedPly = async (fileHandle, dataTable) => {
     const shBands = { '9': 1, '24': 2, '-1': 3 }[shNames$1.findIndex(v => !dataTable.hasColumn(v))] ?? 0;
     const outputSHCoeffs = [0, 3, 8, 15][shBands];
     const numSplats = dataTable.numRows;
-    const numChunks = Math.ceil(numSplats / 256);
+    const numChunks = Math.ceil(numSplats / CHUNK_SIZE);
     const shHeader = shBands ? [
         `element sh ${numSplats}`,
         new Array(outputSHCoeffs * 3).fill('').map((_, i) => `property uchar f_rest_${i}`)
@@ -3150,26 +3356,30 @@ const writeCompressedPly = async (fileHandle, dataTable) => {
     const splatIData = new Uint32Array(numSplats * vertexProps.length);
     const shData = new Uint8Array(numSplats * outputSHCoeffs * 3);
     // sort splats into some kind of order (morton order rn)
-    const sortIndices = generateOrdering(dataTable);
+    const sortIndices = new Uint32Array(dataTable.numRows);
+    for (let i = 0; i < sortIndices.length; ++i) {
+        sortIndices[i] = i;
+    }
+    generateOrdering(dataTable, sortIndices);
     const row = {};
     const chunk = new CompressedChunk();
     for (let i = 0; i < numChunks; ++i) {
-        const num = Math.min(numSplats, (i + 1) * 256) - i * 256;
+        const num = Math.min(numSplats, (i + 1) * CHUNK_SIZE) - i * CHUNK_SIZE;
         for (let j = 0; j < num; ++j) {
-            const index = sortIndices[i * 256 + j];
+            const index = sortIndices[i * CHUNK_SIZE + j];
             // read splat data
             dataTable.getRow(index, row);
             // update chunk
             chunk.set(j, row);
             // quantize and write sh data
-            let off = (i * 256 + j) * outputSHCoeffs * 3;
+            let off = (i * CHUNK_SIZE + j) * outputSHCoeffs * 3;
             for (let k = 0; k < outputSHCoeffs * 3; ++k) {
                 const nvalue = row[shNames$1[k]] / 8 + 0.5;
                 shData[off++] = Math.max(0, Math.min(255, Math.trunc(nvalue * 256)));
             }
         }
         // repeat the last gaussian to fill the rest of the final chunk
-        for (let j = num; j < 256; ++j) {
+        for (let j = num; j < CHUNK_SIZE; ++j) {
             chunk.set(j, row);
         }
         // pack the chunk
@@ -3177,7 +3387,7 @@ const writeCompressedPly = async (fileHandle, dataTable) => {
         // store the float data
         chunkData.set(chunk.chunkData, i * 18);
         // write packed bits
-        const offset = i * 256 * 4;
+        const offset = i * CHUNK_SIZE * 4;
         for (let j = 0; j < num; ++j) {
             splatIData[offset + j * 4 + 0] = chunk.position[j];
             splatIData[offset + j * 4 + 1] = chunk.rotation[j];
@@ -3368,11 +3578,11 @@ const writePly = async (fileHandle, plyData) => {
 
 /**
  * The engine version number. This is in semantic versioning format (MAJOR.MINOR.PATCH).
- */ const version = '2.10.3';
+ */ const version = '2.10.6';
 /**
  * The engine revision number. This is the Git hash of the last commit made to the branch
  * from which the engine was built.
- */ const revision = '2dc84cf';
+ */ const revision = '5322cb8';
 /**
  * Merge the contents of two objects into a single object.
  *
@@ -60807,7 +61017,7 @@ var stdDeclarationPS$1 = /* glsl */ `
         // parallax
         #ifdef STD_HEIGHT_MAP
             vec2 dUvOffset;
-            #ifdef STD_DIFFUSE_TEXTURE_ALLOCATE
+            #ifdef STD_HEIGHT_TEXTURE_ALLOCATE
                 uniform sampler2D texture_heightMap;
             #endif
         #endif
@@ -68855,7 +69065,7 @@ var stdDeclarationPS = /* wgsl */ `
         // parallax
         #ifdef STD_HEIGHT_MAP
             var<private> dUvOffset: vec2f;
-            #ifdef STD_DIFFUSE_TEXTURE_ALLOCATE
+            #ifdef STD_HEIGHT_TEXTURE_ALLOCATE
                 var texture_heightMap : texture_2d<f32>;
                 var texture_heightMapSampler : sampler;
             #endif
@@ -83332,7 +83542,7 @@ const getPrimitiveType = (primitive)=>{
             return PRIMITIVE_TRIANGLES;
     }
 };
-const generateIndices = (numVertices)=>{
+const generateIndices$1 = (numVertices)=>{
     const dummyIndices = new Uint16Array(numVertices);
     for(let i = 0; i < numVertices; i++){
         dummyIndices[i] = i;
@@ -83363,7 +83573,7 @@ const generateNormals = (sourceDesc, indices)=>{
     const numVertices = p.count;
     // generate indices if necessary
     if (!indices) {
-        indices = generateIndices(numVertices);
+        indices = generateIndices$1(numVertices);
     }
     // generate normals
     const normalsTemp = calculateNormals(positions, indices);
@@ -89294,8 +89504,7 @@ ${useF16 ? 'enable f16;' : ''}
 
 struct Uniforms {
     numPoints: u32,
-    numCentroids: u32,
-    pointBase: u32
+    numCentroids: u32
 };
 
 @group(0) @binding(0) var<uniform> uniforms: Uniforms;
@@ -89328,7 +89537,7 @@ fn main(
     @builtin(num_workgroups) num_workgroups: vec3u
 ) {
     // calculate row index for this thread point
-    let pointIndex = uniforms.pointBase + global_id.x + global_id.y * num_workgroups.x * 64u;
+    let pointIndex = global_id.x + global_id.y * num_workgroups.x * 64u;
 
     // copy the point data from global memory
     var point: array<${floatType}, numColumns>;
@@ -89385,37 +89594,37 @@ fn main(
 const roundUp = (value, multiple) => {
     return Math.ceil(value / multiple) * multiple;
 };
-const interleaveData = (dataTable, useF16) => {
-    const { numRows, numColumns } = dataTable;
-    if (useF16) {
-        const result = new Uint16Array(roundUp(numColumns * numRows, 2));
+const interleaveData = (result, dataTable, numRows, rowOffset) => {
+    const { numColumns } = dataTable;
+    if (result instanceof Uint16Array) {
+        // interleave shorts
         for (let c = 0; c < numColumns; ++c) {
             const column = dataTable.columns[c];
             for (let r = 0; r < numRows; ++r) {
-                result[r * numColumns + c] = FloatPacking.float2Half(column.data[r]);
+                result[r * numColumns + c] = FloatPacking.float2Half(column.data[rowOffset + r]);
             }
         }
-        return result;
     }
-    const result = new Float32Array(numColumns * numRows);
-    for (let c = 0; c < numColumns; ++c) {
-        const column = dataTable.columns[c];
-        for (let r = 0; r < numRows; ++r) {
-            result[r * numColumns + c] = column.data[r];
+    else {
+        // interleave floats
+        for (let c = 0; c < numColumns; ++c) {
+            const column = dataTable.columns[c];
+            for (let r = 0; r < numRows; ++r) {
+                result[r * numColumns + c] = column.data[rowOffset + r];
+            }
         }
     }
-    return result;
 };
-class GpuCluster {
+class GpuClustering {
     execute;
     destroy;
-    constructor(gpuDevice, points, numCentroids) {
+    constructor(gpuDevice, numColumns, numCentroids) {
         const device = gpuDevice.app.graphicsDevice;
         // Check if device supports f16
-        const useF16 = 'supportsShaderF16' in device && device.supportsShaderF16;
-        const bytesPerFloat = useF16 ? 2 : 4;
-        const numPoints = points.numRows;
-        const numColumns = points.numColumns;
+        const useF16 = !!('supportsShaderF16' in device && device.supportsShaderF16);
+        const workgroupSize = 64;
+        const workgroupsPerBatch = 1024;
+        const batchSize = workgroupsPerBatch * workgroupSize;
         const bindGroupFormat = new BindGroupFormat(device, [
             new BindUniformBufferFormat('uniforms', SHADERSTAGE_COMPUTE),
             new BindStorageBufferFormat('pointsBuffer', SHADERSTAGE_COMPUTE, true),
@@ -89430,47 +89639,43 @@ class GpuCluster {
             computeUniformBufferFormats: {
                 uniforms: new UniformBufferFormat(device, [
                     new UniformFormat('numPoints', UNIFORMTYPE_UINT),
-                    new UniformFormat('numCentroids', UNIFORMTYPE_UINT),
-                    new UniformFormat('pointBase', UNIFORMTYPE_UINT)
+                    new UniformFormat('numCentroids', UNIFORMTYPE_UINT)
                 ])
             },
             // @ts-ignore
             computeBindGroupFormat: bindGroupFormat
         });
+        const interleavedPoints = useF16 ? new Uint16Array(roundUp(numColumns * batchSize, 2)) : new Float32Array(numColumns * batchSize);
+        const interleavedCentroids = useF16 ? new Uint16Array(roundUp(numColumns * numCentroids, 2)) : new Float32Array(numColumns * numCentroids);
+        const resultsData = new Uint32Array(batchSize);
+        const pointsBuffer = new StorageBuffer(device, interleavedPoints.byteLength, BUFFERUSAGE_COPY_DST);
+        const centroidsBuffer = new StorageBuffer(device, interleavedCentroids.byteLength, BUFFERUSAGE_COPY_DST);
+        const resultsBuffer = new StorageBuffer(device, resultsData.byteLength, BUFFERUSAGE_COPY_SRC | BUFFERUSAGE_COPY_DST);
         const compute = new Compute(device, shader, 'compute-cluster');
-        const pointsBuffer = new StorageBuffer(device, useF16 ? roundUp(numColumns * numPoints, 2) * 2 : numColumns * numPoints * 4, BUFFERUSAGE_COPY_DST);
-        const centroidsBuffer = new StorageBuffer(device, numColumns * numCentroids * bytesPerFloat, BUFFERUSAGE_COPY_DST);
-        const resultsBuffer = new StorageBuffer(device, numPoints * 4, BUFFERUSAGE_COPY_SRC | BUFFERUSAGE_COPY_DST);
-        // interleave the points table data and write to gpu
-        const interleavedPoints = interleaveData(points, useF16);
-        pointsBuffer.write(0, interleavedPoints, 0, interleavedPoints.length);
         compute.setParameter('pointsBuffer', pointsBuffer);
         compute.setParameter('centroidsBuffer', centroidsBuffer);
         compute.setParameter('resultsBuffer', resultsBuffer);
-        this.execute = async (centroids, labels) => {
-            // interleave centroids and write to gpu
-            const interleavedCentroids = interleaveData(centroids, useF16);
-            centroidsBuffer.write(0, interleavedCentroids, 0, interleavedCentroids.length);
-            compute.setParameter('numPoints', points.numRows);
-            compute.setParameter('numCentroids', centroids.numRows);
-            // execute in batches of 1024 worksgroups
-            const workgroupSize = 64;
-            const workgroupsPerBatch = 1024;
-            const batchSize = workgroupsPerBatch * workgroupSize;
+        this.execute = async (points, centroids, labels) => {
+            const numPoints = points.numRows;
             const numBatches = Math.ceil(numPoints / batchSize);
+            // upload centroid data to gpu
+            interleaveData(interleavedCentroids, centroids, numCentroids, 0);
+            centroidsBuffer.write(0, interleavedCentroids, 0, interleavedCentroids.length);
+            compute.setParameter('numCentroids', numCentroids);
             for (let batch = 0; batch < numBatches; batch++) {
                 const currentBatchSize = Math.min(numPoints - batch * batchSize, batchSize);
                 const groups = Math.ceil(currentBatchSize / 64);
-                compute.setParameter('pointBase', batch * batchSize);
+                // write this batch of point data to gpu
+                interleaveData(interleavedPoints, points, currentBatchSize, batch * batchSize);
+                pointsBuffer.write(0, interleavedPoints, 0, useF16 ? roundUp(numColumns * currentBatchSize, 2) : numColumns * currentBatchSize);
+                compute.setParameter('numPoints', currentBatchSize);
                 // start compute job
                 compute.setupDispatch(groups);
                 device.computeDispatch([compute], `cluster-dispatch-${batch}`);
-                // FIXME: submit call is required, but not public API
-                // @ts-ignore
-                device.submit();
+                // read results from gpu and store in labels
+                await resultsBuffer.read(0, currentBatchSize * 4, resultsData, true);
+                labels.set(resultsData.subarray(0, currentBatchSize), batch * batchSize);
             }
-            // read results from gpu
-            await resultsBuffer.read(0, undefined, labels, true);
         };
         this.destroy = () => {
             pointsBuffer.destroy();
@@ -89550,14 +89755,14 @@ const kmeans = async (points, k, iterations, device) => {
     // construct centroids data table and assign initial values
     const centroids = new DataTable(points.columns.map(c => new Column(c.name, new Float32Array(k))));
     initializeCentroids(points, centroids, row);
-    const gpuCluster = device && new GpuCluster(device, points, k);
+    const gpuClustering = device && new GpuClustering(device, points.numColumns, k);
     const labels = new Uint32Array(points.numRows);
     let converged = false;
     let steps = 0;
     console.log(`Running k-means clustering: dims=${points.numColumns} points=${points.numRows} clusters=${k} iterations=${iterations}...`);
     while (!converged) {
-        if (gpuCluster) {
-            await gpuCluster.execute(centroids, labels);
+        if (gpuClustering) {
+            await gpuClustering.execute(points, centroids, labels);
         }
         else {
             clusterKdTreeCpu(points, centroids, labels);
@@ -89574,17 +89779,20 @@ const kmeans = async (points, k, iterations, device) => {
         }
         stdout.write('#');
     }
+    if (gpuClustering) {
+        gpuClustering.destroy();
+    }
     console.log(' done 🎉');
     return { centroids, labels };
 };
 
 const shNames = new Array(45).fill('').map((_, i) => `f_rest_${i}`);
-const calcMinMax = (dataTable, columnNames) => {
+const calcMinMax = (dataTable, columnNames, indices) => {
     const columns = columnNames.map(name => dataTable.getColumnByName(name));
     const minMax = columnNames.map(() => [Infinity, -Infinity]);
     const row = {};
-    for (let i = 0; i < dataTable.numRows; ++i) {
-        const r = dataTable.getRow(i, row, columns);
+    for (let i = 0; i < indices.length; ++i) {
+        const r = dataTable.getRow(indices[i], row, columns);
         for (let j = 0; j < columnNames.length; ++j) {
             const value = r[columnNames[j]];
             if (value < minMax[j][0])
@@ -89602,10 +89810,16 @@ const logTransform = (value) => {
 const identity = (index, width) => {
     return index;
 };
-const writeSogs = async (fileHandle, dataTable, outputFilename, shIterations = 10, shMethod) => {
-    // generate an optimal ordering
-    const sortIndices = generateOrdering(dataTable);
-    const numRows = dataTable.numRows;
+const generateIndices = (dataTable) => {
+    const result = new Uint32Array(dataTable.numRows);
+    for (let i = 0; i < result.length; ++i) {
+        result[i] = i;
+    }
+    generateOrdering(dataTable, result);
+    return result;
+};
+const writeSog = async (fileHandle, dataTable, outputFilename, shIterations = 10, shMethod, indices = generateIndices(dataTable)) => {
+    const numRows = indices.length;
     const width = Math.ceil(Math.sqrt(numRows) / 16) * 16;
     const height = Math.ceil(numRows / width / 16) * 16;
     const channels = 4;
@@ -89623,10 +89837,10 @@ const writeSogs = async (fileHandle, dataTable, outputFilename, shIterations = 1
     const meansL = new Uint8Array(width * height * channels);
     const meansU = new Uint8Array(width * height * channels);
     const meansNames = ['x', 'y', 'z'];
-    const meansMinMax = calcMinMax(dataTable, meansNames).map(v => v.map(logTransform));
+    const meansMinMax = calcMinMax(dataTable, meansNames, indices).map(v => v.map(logTransform));
     const meansColumns = meansNames.map(name => dataTable.getColumnByName(name));
-    for (let i = 0; i < dataTable.numRows; ++i) {
-        dataTable.getRow(sortIndices[i], row, meansColumns);
+    for (let i = 0; i < indices.length; ++i) {
+        dataTable.getRow(indices[i], row, meansColumns);
         const x = 65535 * (logTransform(row.x) - meansMinMax[0][0]) / (meansMinMax[0][1] - meansMinMax[0][0]);
         const y = 65535 * (logTransform(row.y) - meansMinMax[1][0]) / (meansMinMax[1][1] - meansMinMax[1][0]);
         const z = 65535 * (logTransform(row.z) - meansMinMax[2][0]) / (meansMinMax[2][1] - meansMinMax[2][0]);
@@ -89647,8 +89861,8 @@ const writeSogs = async (fileHandle, dataTable, outputFilename, shIterations = 1
     const quatNames = ['rot_0', 'rot_1', 'rot_2', 'rot_3'];
     const quatColumns = quatNames.map(name => dataTable.getColumnByName(name));
     const q = [0, 0, 0, 0];
-    for (let i = 0; i < dataTable.numRows; ++i) {
-        dataTable.getRow(sortIndices[i], row, quatColumns);
+    for (let i = 0; i < indices.length; ++i) {
+        dataTable.getRow(indices[i], row, quatColumns);
         q[0] = row.rot_0;
         q[1] = row.rot_1;
         q[2] = row.rot_2;
@@ -89688,9 +89902,9 @@ const writeSogs = async (fileHandle, dataTable, outputFilename, shIterations = 1
     const scales = new Uint8Array(width * height * channels);
     const scaleNames = ['scale_0', 'scale_1', 'scale_2'];
     const scaleColumns = scaleNames.map(name => dataTable.getColumnByName(name));
-    const scaleMinMax = calcMinMax(dataTable, scaleNames);
-    for (let i = 0; i < dataTable.numRows; ++i) {
-        dataTable.getRow(sortIndices[i], row, scaleColumns);
+    const scaleMinMax = calcMinMax(dataTable, scaleNames, indices);
+    for (let i = 0; i < indices.length; ++i) {
+        dataTable.getRow(indices[i], row, scaleColumns);
         const ti = layout(i);
         scales[ti * 4] = 255 * (row.scale_0 - scaleMinMax[0][0]) / (scaleMinMax[0][1] - scaleMinMax[0][0]);
         scales[ti * 4 + 1] = 255 * (row.scale_1 - scaleMinMax[1][0]) / (scaleMinMax[1][1] - scaleMinMax[1][0]);
@@ -89702,9 +89916,9 @@ const writeSogs = async (fileHandle, dataTable, outputFilename, shIterations = 1
     const sh0 = new Uint8Array(width * height * channels);
     const sh0Names = ['f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity'];
     const sh0Columns = sh0Names.map(name => dataTable.getColumnByName(name));
-    const sh0MinMax = calcMinMax(dataTable, sh0Names);
-    for (let i = 0; i < dataTable.numRows; ++i) {
-        dataTable.getRow(sortIndices[i], row, sh0Columns);
+    const sh0MinMax = calcMinMax(dataTable, sh0Names, indices);
+    for (let i = 0; i < indices.length; ++i) {
+        dataTable.getRow(indices[i], row, sh0Columns);
         const ti = layout(i);
         sh0[ti * 4] = 255 * (row.f_dc_0 - sh0MinMax[0][0]) / (sh0MinMax[0][1] - sh0MinMax[0][0]);
         sh0[ti * 4 + 1] = 255 * (row.f_dc_1 - sh0MinMax[1][0]) / (sh0MinMax[1][1] - sh0MinMax[1][0]);
@@ -89753,14 +89967,18 @@ const writeSogs = async (fileHandle, dataTable, outputFilename, shIterations = 1
         const shColumnNames = shNames.slice(0, shCoeffs * 3);
         const shColumns = shColumnNames.map(name => dataTable.getColumnByName(name));
         // create a table with just spherical harmonics data
+        // NOTE: this step should also copy the rows referenced in indices, but that's a
+        // lot of duplicate data when it's unneeded (which is currently never). so that
+        // means k-means is clustering the full dataset, instead of the rows referenced in
+        // indices.
         const shDataTable = new DataTable(shColumns);
-        const paletteSize = Math.min(64, 2 ** Math.floor(Math.log2(dataTable.numRows / 1024))) * 1024;
+        const paletteSize = Math.min(64, 2 ** Math.floor(Math.log2(indices.length / 1024))) * 1024;
         // calculate kmeans
         const gpuDevice = shMethod === 'gpu' ? await createDevice() : null;
         const { centroids, labels } = await kmeans(shDataTable, paletteSize, shIterations, gpuDevice);
         // write centroids
         const centroidsBuf = new Uint8Array(64 * shCoeffs * Math.ceil(centroids.numRows / 64) * channels);
-        const centroidsMinMax = calcMinMax(shDataTable, shColumnNames);
+        const centroidsMinMax = calcMinMax(shDataTable, shColumnNames, indices);
         const centroidsMin = centroidsMinMax.map(v => v[0]).reduce((a, b) => Math.min(a, b));
         const centroidsMax = centroidsMinMax.map(v => v[1]).reduce((a, b) => Math.max(a, b));
         const centroidsRow = {};
@@ -89779,8 +89997,8 @@ const writeSogs = async (fileHandle, dataTable, outputFilename, shIterations = 1
         await write('shN_centroids.webp', centroidsBuf, 64 * shCoeffs, Math.ceil(centroids.numRows / 64));
         // write labels
         const labelsBuf = new Uint8Array(width * height * channels);
-        for (let i = 0; i < dataTable.numRows; ++i) {
-            const label = labels[sortIndices[i]];
+        for (let i = 0; i < indices.length; ++i) {
+            const label = labels[indices[i]];
             const ti = layout(i);
             labelsBuf[ti * 4] = label & 0xff;
             labelsBuf[ti * 4 + 1] = (label >> 8) & 0xff;
@@ -89789,7 +90007,7 @@ const writeSogs = async (fileHandle, dataTable, outputFilename, shIterations = 1
         }
         await write('shN_labels.webp', labelsBuf);
         meta.shN = {
-            shape: [dataTable.numRows, shCoeffs],
+            shape: [indices.length, shCoeffs],
             dtype: 'float32',
             mins: centroidsMin,
             maxs: centroidsMax,
@@ -89815,7 +90033,16 @@ const readFile = async (filename) => {
         fileData = await readSplat(inputFile);
     }
     else if (lowerFilename.endsWith('.ply')) {
-        fileData = await readPly$1(inputFile);
+        const ply = await readPly$1(inputFile);
+        if (isCompressedPly$1(ply)) {
+            fileData = {
+                comments: ply.comments,
+                elements: [{ name: 'vertex', dataTable: decompressPly(ply) }]
+            };
+        }
+        else {
+            fileData = ply;
+        }
     }
     else {
         await inputFile.close();
@@ -89829,8 +90056,8 @@ const getOutputFormat = (filename) => {
     if (lowerFilename.endsWith('.csv')) {
         return 'csv';
     }
-    else if (lowerFilename.endsWith('.json')) {
-        return 'json';
+    else if (lowerFilename.endsWith('meta.json')) {
+        return 'sog';
     }
     else if (lowerFilename.endsWith('.compressed.ply')) {
         return 'compressed-ply';
@@ -89862,8 +90089,8 @@ const writeFile = async (filename, dataTable, options) => {
         case 'csv':
             await writeCsv(outputFile, dataTable);
             break;
-        case 'json':
-            await writeSogs(outputFile, dataTable, filename, options.iterations, options.gpu ? 'gpu' : 'cpu');
+        case 'sog':
+            await writeSog(outputFile, dataTable, filename, options.iterations, options.gpu ? 'gpu' : 'cpu');
             break;
         case 'compressed-ply':
             await writeCompressedPly(outputFile, dataTable);
@@ -90035,7 +90262,7 @@ const parseArguments = () => {
                     });
                     break;
                 case 'filterByValue': {
-                    const parts = t.value.split(',').map(p => p.trim());
+                    const parts = t.value.split(',').map((p) => p.trim());
                     if (parts.length !== 3) {
                         throw new Error(`Invalid filterByValue value: ${t.value}`);
                     }
@@ -90048,7 +90275,7 @@ const parseArguments = () => {
                     break;
                 }
                 case 'filterBands': {
-                    const shBands = parseNumber(t.value);
+                    const shBands = parseInteger(t.value);
                     if (![0, 1, 2, 3].includes(shBands)) {
                         throw new Error(`Invalid filterBands value: ${t.value}. Must be 0, 1, 2, or 3.`);
                     }
@@ -90143,7 +90370,7 @@ const main = async () => {
     }
     catch (err) {
         // handle errors
-        console.error(`error: ${err.message}`);
+        console.error(err);
         exit(1);
     }
     const endTime = hrtime(startTime);