@playcanvas/splat-transform 0.5.2 → 0.5.4

package/dist/index.mjs

@@ -1884,7 +1884,7 @@ let Quat$1 = class Quat {
 		}
 };
 
-var version$1 = "0.5.2";
+var version$1 = "0.5.4";
 
 class Column {
     name;
@@ -3368,11 +3368,11 @@ const writePly = async (fileHandle, plyData) => {
 
 /**
  * The engine version number. This is in semantic versioning format (MAJOR.MINOR.PATCH).
- */ const version = '2.9.2';
+ */ const version = '2.10.3';
 /**
  * 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 = 'ce5f9ca';
+ */ const revision = '2dc84cf';
 /**
  * Merge the contents of two objects into a single object.
  *
@@ -13136,6 +13136,60 @@ const typedArrayIndexFormatsByteSize = [
     2,
     4
 ];
+// map of primitive GLSL types to their corresponding WGSL types
+const primitiveGlslToWgslTypeMap = new Map([
+    // floating-point
+    [
+        'float',
+        'f32'
+    ],
+    [
+        'vec2',
+        'vec2f'
+    ],
+    [
+        'vec3',
+        'vec3f'
+    ],
+    [
+        'vec4',
+        'vec4f'
+    ],
+    // signed integer
+    [
+        'int',
+        'i32'
+    ],
+    [
+        'ivec2',
+        'vec2i'
+    ],
+    [
+        'ivec3',
+        'vec3i'
+    ],
+    [
+        'ivec4',
+        'vec4i'
+    ],
+    // unsigned integer
+    [
+        'uint',
+        'u32'
+    ],
+    [
+        'uvec2',
+        'vec2u'
+    ],
+    [
+        'uvec3',
+        'vec3u'
+    ],
+    [
+        'uvec4',
+        'vec4u'
+    ]
+]);
 /**
  * Map of engine semantics into location on device in range 0..15 (note - semantics mapping to the
  * same location cannot be used at the same time) organized in a way that ATTR0-ATTR7 do not
@@ -15847,12 +15901,12 @@ const deviceCache$2 = new DeviceCache();
         return deviceCache$2.get(graphicsDevice, ()=>{
             return new VertexFormat(graphicsDevice, [
                 {
-                    semantic: SEMANTIC_ATTR12,
+                    semantic: SEMANTIC_ATTR11,
                     components: 4,
                     type: TYPE_FLOAT32
                 },
                 {
-                    semantic: SEMANTIC_ATTR13,
+                    semantic: SEMANTIC_ATTR12,
                     components: 4,
                     type: TYPE_FLOAT32
                 },
@@ -17831,8 +17885,8 @@ const stringIds$1 = new StringIds();
         Debug.trace(TRACEID_RENDER_QUEUE, `writeBuffer: ${this.buffer.label}`);
         wgpu.queue.writeBuffer(this.buffer, 0, data, 0, data.length);
     }
-    read(device, offset, size, data) {
-        return device.readStorageBuffer(this, offset, size, data);
+    read(device, offset, size, data, immediate) {
+        return device.readStorageBuffer(this, offset, size, data, immediate);
     }
     write(device, bufferOffset, data, dataOffset, size) {
         device.writeStorageBuffer(this, bufferOffset, data, dataOffset, size);
@@ -20132,7 +20186,7 @@ class ResourceLine {
     static generateFragmentOutputStruct(src, numRenderTargets) {
         let structCode = 'struct FragmentOutput {\n';
         for(let i = 0; i < numRenderTargets; i++){
-            structCode += `    @location(${i}) color${i > 0 ? i : ''} : vec4f,\n`;
+            structCode += `    @location(${i}) color${i > 0 ? i : ''} : pcOutType${i},\n`;
         }
         // find if the src contains `.fragDepth =`, ignoring whitespace before = sign
         const needsFragDepth = src.search(/\.fragDepth\s*=/) !== -1;
@@ -20896,6 +20950,10 @@ const ENDIF = /(endif|else|elif)(?:[ \t]+([^\r\n]*))?\r?\n?/g;
 const IDENTIFIER$1 = /\{?[\w-]+\}?/;
 // [!]defined(EXPRESSION)
 const DEFINED = /(!|\s)?defined\(([\w-]+)\)/;
+// Matches all defined(...) patterns for parentheses check
+const DEFINED_PARENS = /!?defined\s*\([^)]*\)/g;
+// Matches defined or !defined at the end of a string (for parentheses detection)
+const DEFINED_BEFORE_PAREN = /!?defined\s*$/;
 // Matches comparison operators like ==, !=, <, <=, >, >=
 const COMPARISON = /([a-z_]\w*)\s*(==|!=|<|<=|>|>=)\s*([\w"']+)/i;
 // currently unsupported characters in the expression: + -
@@ -21295,6 +21353,19 @@ const FRAGCOLOR = /(pcFragColor[1-8])\b/g;
         let error = false;
         expr = expr.trim();
         let invert = false;
+        // Handle boolean literals
+        if (expr === 'true') {
+            return {
+                result: true,
+                error
+            };
+        }
+        if (expr === 'false') {
+            return {
+                result: false,
+                error
+            };
+        }
         // Handle defined(expr) and !defined(expr)
         const definedMatch = DEFINED.exec(expr);
         if (definedMatch) {
@@ -21347,9 +21418,88 @@ const FRAGCOLOR = /(pcFragColor[1-8])\b/g;
             error
         };
     }
+    /**
+     * Processes parentheses in an expression by recursively evaluating subexpressions.
+     * Ignores parentheses that are part of defined() calls.
+     *
+     * @param {string} expression - The expression to process.
+     * @param {Map<string, string>} defines - A map containing key-value pairs of defines.
+     * @returns {object} Returns an object containing the processed expression and an error flag.
+     */ static processParentheses(expression, defines) {
+        let error = false;
+        let processed = expression.trim();
+        // Remove outer parentheses that wrap the entire expression
+        while(processed.startsWith('(') && processed.endsWith(')')){
+            let depth = 0;
+            let wrapsEntire = true;
+            for(let i = 0; i < processed.length - 1; i++){
+                if (processed[i] === '(') depth++;
+                else if (processed[i] === ')') {
+                    depth--;
+                    if (depth === 0) {
+                        wrapsEntire = false;
+                        break;
+                    }
+                }
+            }
+            if (wrapsEntire) {
+                processed = processed.slice(1, -1).trim();
+            } else {
+                break;
+            }
+        }
+        // Keep processing until no more precedence parentheses exist
+        while(true){
+            let foundParen = false;
+            let depth = 0;
+            let maxDepth = 0;
+            let deepestStart = -1;
+            let deepestEnd = -1;
+            // Find the deepest nested parentheses that aren't part of defined()
+            let inDefinedParen = 0;
+            for(let i = 0; i < processed.length; i++){
+                if (processed[i] === '(') {
+                    // Check if this is part of defined() - look back for "defined" or "!defined"
+                    const beforeParen = processed.substring(0, i);
+                    if (DEFINED_BEFORE_PAREN.test(beforeParen)) {
+                        inDefinedParen++;
+                    } else if (inDefinedParen === 0) {
+                        depth++;
+                        if (depth > maxDepth) {
+                            maxDepth = depth;
+                            deepestStart = i;
+                        }
+                        foundParen = true;
+                    }
+                } else if (processed[i] === ')') {
+                    if (inDefinedParen > 0) {
+                        inDefinedParen--;
+                    } else if (depth > 0) {
+                        if (depth === maxDepth && deepestStart !== -1) {
+                            deepestEnd = i;
+                        }
+                        depth--;
+                    }
+                }
+            }
+            if (!foundParen || deepestStart === -1 || deepestEnd === -1) {
+                break;
+            }
+            // Extract and evaluate the subexpression
+            const subExpr = processed.substring(deepestStart + 1, deepestEnd);
+            const { result, error: subError } = Preprocessor.evaluate(subExpr, defines);
+            error = error || subError;
+            // Replace the parentheses expression with its result
+            processed = processed.substring(0, deepestStart) + (result ? 'true' : 'false') + processed.substring(deepestEnd + 1);
+        }
+        return {
+            expression: processed,
+            error
+        };
+    }
     /**
      * Evaluates a complex expression with support for `defined`, `!defined`, comparisons, `&&`,
-     * and `||`. It does not currently handle ( and ).
+     * `||`, and parentheses for precedence.
      *
      * @param {string} expression - The expression to evaluate.
      * @param {Map<string, string>} defines - A map containing key-value pairs of defines.
@@ -21357,8 +21507,26 @@ const FRAGCOLOR = /(pcFragColor[1-8])\b/g;
      */ static evaluate(expression, defines) {
         const correct = INVALID.exec(expression) === null;
         Debug.assert(correct, `Resolving expression like this is not supported: ${expression}`);
+        // Process parentheses first (skip if no parentheses exist or only defined() parentheses)
+        let processedExpr = expression;
+        let parenError = false;
+        // Quick check: remove all defined(...) patterns and see if any parentheses remain
+        // If they do, process them recursively to handle nested parentheses
+        const withoutDefined = expression.replace(DEFINED_PARENS, '');
+        if (withoutDefined.indexOf('(') !== -1) {
+            const processed = Preprocessor.processParentheses(expression, defines);
+            processedExpr = processed.expression;
+            parenError = processed.error;
+        }
+        if (parenError) {
+            Debug.log(`Parenthesis parsing error in expression: "${expression}"`);
+            return {
+                result: false,
+                error: true
+            };
+        }
         // Step 1: Split by "||" to handle OR conditions
-        const orSegments = expression.split('||');
+        const orSegments = processedExpr.split('||');
         for (const orSegment of orSegments){
             // Step 2: Split each OR segment by "&&" to handle AND conditions
             const andSegments = orSegment.split('&&');
@@ -21693,19 +21861,23 @@ struct WrappedVec2U { @size(16) element: vec2u }
         Debug.assert(!options.vertexIncludes || options.vertexIncludes instanceof Map);
         Debug.assert(!options.fragmentDefines || options.fragmentDefines instanceof Map);
         Debug.assert(!options.fragmentIncludes || options.fragmentIncludes instanceof Map);
+        // Normalize fragmentOutputTypes to an array
+        const normalizedOutputTypes = (options)=>{
+            let fragmentOutputTypes = options.fragmentOutputTypes ?? 'vec4';
+            if (!Array.isArray(fragmentOutputTypes)) {
+                fragmentOutputTypes = [
+                    fragmentOutputTypes
+                ];
+            }
+            return fragmentOutputTypes;
+        };
         const getDefines = (gpu, gl2, isVertex, options)=>{
             const deviceIntro = device.isWebGPU ? gpu : gl2;
             // a define per supported color attachment, which strips out unsupported output definitions in the deviceIntro
             let attachmentsDefine = '';
             // Define the fragment shader output type, vec4 by default
             if (!isVertex) {
-                // Normalize fragmentOutputTypes to an array
-                let fragmentOutputTypes = options.fragmentOutputTypes ?? 'vec4';
-                if (!Array.isArray(fragmentOutputTypes)) {
-                    fragmentOutputTypes = [
-                        fragmentOutputTypes
-                    ];
-                }
+                const fragmentOutputTypes = normalizedOutputTypes(options);
                 for(let i = 0; i < device.maxColorAttachments; i++){
                     attachmentsDefine += `#define COLOR_ATTACHMENT_${i}\n`;
                     const outType = fragmentOutputTypes[i] ?? 'vec4';
@@ -21714,6 +21886,21 @@ struct WrappedVec2U { @size(16) element: vec2u }
             }
             return attachmentsDefine + deviceIntro;
         };
+        const getDefinesWgsl = (isVertex, options)=>{
+            let attachmentsDefine = '';
+            // Define the fragment shader output type, vec4 by default
+            if (!isVertex) {
+                const fragmentOutputTypes = normalizedOutputTypes(options);
+                // create alias for each output type
+                for(let i = 0; i < device.maxColorAttachments; i++){
+                    const glslOutType = fragmentOutputTypes[i] ?? 'vec4';
+                    const wgslOutType = primitiveGlslToWgslTypeMap.get(glslOutType);
+                    Debug.assert(wgslOutType, `Unknown output type translation: ${glslOutType} -> ${wgslOutType}`);
+                    attachmentsDefine += `alias pcOutType${i} = ${wgslOutType};\n`;
+                }
+            }
+            return attachmentsDefine;
+        };
         const name = options.name ?? 'Untitled';
         let vertCode;
         let fragCode;
@@ -21722,12 +21909,14 @@ struct WrappedVec2U { @size(16) element: vec2u }
         const wgsl = options.shaderLanguage === SHADERLANGUAGE_WGSL;
         if (wgsl) {
             vertCode = `
+                ${getDefinesWgsl(true, options)}
                 ${webgpuVS}
                 ${sharedWGSL}
                 ${vertexDefinesCode}
                 ${options.vertexCode}
             `;
             fragCode = `
+                ${getDefinesWgsl(false, options)}
                 ${webgpuPS}
                 ${sharedWGSL}
                 ${fragmentDefinesCode}
@@ -23339,11 +23528,14 @@ class WebgpuGpuProfiler extends GpuProfiler {
      * storage buffer. When typed array is supplied, enough space needs to be reserved, otherwise
      * only partial data is copied. If not specified, the data is returned in an Uint8Array.
      * Defaults to null.
+     * @param {boolean} [immediate] - If true, the read operation will be executed as soon as
+     * possible. This has a performance impact, so it should be used only when necessary. Defaults
+     * to false.
      * @returns {Promise<ArrayBufferView>} A promise that resolves with the data read from the
      * storage buffer.
      * @ignore
-     */ read(offset = 0, size = this.byteSize, data = null) {
-        return this.impl.read(this.device, offset, size, data);
+     */ read(offset = 0, size = this.byteSize, data = null, immediate = false) {
+        return this.impl.read(this.device, offset, size, data, immediate);
     }
     /**
      * Issues a write operation of the provided data into a storage buffer.
@@ -25257,6 +25449,8 @@ function arrayGet4(offset, outputArray, outputIndex) {
 }
 
 /**
+ * @import { EventHandler } from '../../core/event-handler.js';
+ */ /**
  * @callback HttpResponseCallback
  * Callback used by {@link Http#get}, {@link Http#post}, {@link Http#put}, {@link Http#del}, and
  * {@link Http#request}.
@@ -25334,6 +25528,7 @@ function arrayGet4(offset, outputArray, outputIndex) {
      * @param {boolean} [options.retry] - If true then if the request fails it will be retried with an exponential backoff.
      * @param {number} [options.maxRetries] - If options.retry is true this specifies the maximum number of retries. Defaults to 5.
      * @param {number} [options.maxRetryDelay] - If options.retry is true this specifies the maximum amount of time to wait between retries in milliseconds. Defaults to 5000.
+     * @param {EventHandler} [options.progress] - Object to use for firing progress events.
      * @param {HttpResponseCallback} callback - The callback used when the response has returned. Passed (err, data)
      * where data is the response (format depends on response type: text, Object, ArrayBuffer, XML) and
      * err is the error code.
@@ -25350,7 +25545,25 @@ function arrayGet4(offset, outputArray, outputIndex) {
             callback = options;
             options = {};
         }
-        return this.request('GET', url, options, callback);
+        const result = this.request('GET', url, options, callback);
+        const { progress } = options;
+        if (progress) {
+            const handler = (event)=>{
+                if (event.lengthComputable) {
+                    progress.fire('progress', event.loaded, event.total);
+                }
+            };
+            const endHandler = (event)=>{
+                handler(event);
+                result.removeEventListener('loadstart', handler);
+                result.removeEventListener('progress', handler);
+                result.removeEventListener('loadend', endHandler);
+            };
+            result.addEventListener('loadstart', handler);
+            result.addEventListener('progress', handler);
+            result.addEventListener('loadend', endHandler);
+        }
+        return result;
     }
     /**
      * Perform an HTTP POST request to the given url with additional options such as headers,
@@ -26079,6 +26292,11 @@ const lightFalloffNames = {
         }
     ]
 ]);
+/**
+ * The flag that controls shadow rendering for the all cascades
+ *
+ * @category Graphics
+ */ const SHADOW_CASCADE_ALL = 255;
 /**
  * Gaussian filter. May look smoother than box, but requires more samples.
  *
@@ -28264,13 +28482,14 @@ class GeometryVertexStream {
             ];
             const base = this.primitive[RENDERSTYLE_SOLID].base;
             const count = this.primitive[RENDERSTYLE_SOLID].count;
+            const baseVertex = this.primitive[RENDERSTYLE_SOLID].baseVertex || 0;
             const indexBuffer = this.indexBuffer[RENDERSTYLE_SOLID];
             const srcIndices = new typedArrayIndexFormats[indexBuffer.format](indexBuffer.storage);
             const seen = new Set();
             for(let j = base; j < base + count; j += 3){
                 for(let k = 0; k < 3; k++){
-                    const i1 = srcIndices[j + offsets[k][0]];
-                    const i2 = srcIndices[j + offsets[k][1]];
+                    const i1 = srcIndices[j + offsets[k][0]] + baseVertex;
+                    const i2 = srcIndices[j + offsets[k][1]] + baseVertex;
                     const hash = i1 > i2 ? i2 * numVertices + i1 : i1 * numVertices + i2;
                     if (!seen.has(hash)) {
                         seen.add(hash);
@@ -30099,6 +30318,14 @@ const lookupHashes = new Uint32Array(4);
      * @type {boolean}
      */ this.castShadow = false;
         /**
+     * Specifies a bitmask that controls which shadow cascades a mesh instance contributes
+     * to when rendered with a {@link LIGHTTYPE_DIRECTIONAL} light source.
+     * This setting is only effective if the {@link castShadow} property is enabled.
+     * Defaults to {@link SHADOW_CASCADE_ALL}, which means the mesh casts shadows into all available cascades.
+     *
+     * @type {number}
+     */ this.shadowCascadeMask = SHADOW_CASCADE_ALL;
+        /**
      * Controls whether the mesh instance can be culled by frustum culling (see
      * {@link CameraComponent#frustumCulling}). Defaults to true.
      *
@@ -33325,24 +33552,6 @@ const semverLess = (a, b)=>{
     vertex_boneWeights: SEMANTIC_BLENDWEIGHT,
     vertex_boneIndices: SEMANTIC_BLENDINDICES
 };
-const varyingsWGSLTypes = new Map([
-    [
-        'vec4',
-        'vec4f'
-    ],
-    [
-        'vec3',
-        'vec3f'
-    ],
-    [
-        'vec2',
-        'vec2f'
-    ],
-    [
-        'float',
-        'f32'
-    ]
-]);
 class LitShader {
     /**
      * @param {GraphicsDevice} device - The graphics device.
@@ -33459,8 +33668,8 @@ class LitShader {
             // for the user to provide required attributes using material.setAttribute
             const languageChunks = ShaderChunks.get(this.device, this.shaderLanguage);
             if (this.chunks.get('transformInstancingVS') === languageChunks.get('transformInstancingVS')) {
-                attributes.instance_line1 = SEMANTIC_ATTR12;
-                attributes.instance_line2 = SEMANTIC_ATTR13;
+                attributes.instance_line1 = SEMANTIC_ATTR11;
+                attributes.instance_line2 = SEMANTIC_ATTR12;
                 attributes.instance_line3 = SEMANTIC_ATTR14;
                 attributes.instance_line4 = SEMANTIC_ATTR15;
             }
@@ -33543,7 +33752,7 @@ class LitShader {
         // generate varyings code
         varyings.forEach((type, name)=>{
             this.varyingsCode += `#define VARYING_${name.toUpperCase()}\n`;
-            this.varyingsCode += this.shaderLanguage === SHADERLANGUAGE_WGSL ? `varying ${name}: ${varyingsWGSLTypes.get(type)};\n` : `varying ${type} ${name};\n`;
+            this.varyingsCode += this.shaderLanguage === SHADERLANGUAGE_WGSL ? `varying ${name}: ${primitiveGlslToWgslTypeMap.get(type)};\n` : `varying ${type} ${name};\n`;
         });
         // varyings code exposed as an include
         this.includes.set('varyingsVS', this.varyingsCode);
@@ -37880,6 +38089,7 @@ class ShadowMapCache {
  * @import { Light } from '../light.js'
  * @import { Renderer } from './renderer.js'
  * @import { ShadowRenderer } from './shadow-renderer.js'
+ * @import { MeshInstance } from '../mesh-instance.js';
  */ const visibleSceneAabb = new BoundingBox();
 const center = new Vec3();
 const shadowCamView$1 = new Mat4();
@@ -37997,18 +38207,27 @@ class ShadowRendererDirectional {
             // cull shadow casters
             this.renderer.updateCameraFrustum(shadowCam);
             this.shadowRenderer.cullShadowCasters(comp, light, lightRenderData.visibleCasters, shadowCam, casters);
-            // find out AABB of visible shadow casters
-            let emptyAabb = true;
+            const cascadeFlag = 1 << cascade;
             const visibleCasters = lightRenderData.visibleCasters;
-            for(let i = 0; i < visibleCasters.length; i++){
+            const origNumVisibleCasters = visibleCasters.length;
+            let numVisibleCasters = 0;
+            // exclude all mesh instances that are hidden for this cascade.
+            // find out AABB of visible shadow casters
+            for(let i = 0; i < origNumVisibleCasters; i++){
                 const meshInstance = visibleCasters[i];
-                if (emptyAabb) {
-                    emptyAabb = false;
-                    visibleSceneAabb.copy(meshInstance.aabb);
-                } else {
-                    visibleSceneAabb.add(meshInstance.aabb);
+                if (meshInstance.shadowCascadeMask & cascadeFlag) {
+                    visibleCasters[numVisibleCasters++] = meshInstance;
+                    if (numVisibleCasters === 1) {
+                        visibleSceneAabb.copy(meshInstance.aabb);
+                    } else {
+                        visibleSceneAabb.add(meshInstance.aabb);
+                    }
                 }
             }
+            // remove empty tail
+            if (origNumVisibleCasters !== numVisibleCasters) {
+                visibleCasters.length = numVisibleCasters;
+            }
             // calculate depth range of the caster's AABB from the point of view of the shadow camera
             shadowCamView$1.copy(shadowCamNode.getWorldTransform()).invert();
             const depthRange = getDepthRange(shadowCamView$1, visibleSceneAabb.getMin(), visibleSceneAabb.getMax());
@@ -43513,7 +43732,7 @@ let id = 0;
         if (this.morph.intRenderFormat) defines.set('MORPH_INT', '');
         const outputType = this.morph.intRenderFormat ? 'uvec4' : 'vec4';
         return ShaderUtils.createShader(this.device, {
-            uniqueName: 'TextureMorphShader',
+            uniqueName: `TextureMorphShader_${maxCount}-${this.morph.intRenderFormat ? 'int' : 'float'}`,
             attributes: {
                 vertex_position: SEMANTIC_POSITION
             },
@@ -48518,46 +48737,92 @@ class GSplatSorter extends EventHandler {
 }
 
 var glslGsplatSogsReorderPS = /* glsl */ `
-    uniform usampler2D orderTexture;
-    uniform sampler2D sourceTexture;
+    uniform highp sampler2D means_l;
+    uniform highp sampler2D means_u;
+    uniform highp sampler2D quats;
+    uniform highp sampler2D scales;
+    uniform highp sampler2D sh_labels;
+
     uniform highp uint numSplats;
 
+    uint packU32(vec4 v) {
+        return uint(v.x * 255.0) << 24u |
+               uint(v.y * 255.0) << 16u |
+               uint(v.z * 255.0) << 8u |
+               uint(v.w * 255.0);
+    }
+
+    uvec4 packU32(vec4 a, vec4 b, vec4 c, vec4 d) {
+        return uvec4(packU32(a), packU32(b), packU32(c), packU32(d));
+    }
+
     void main(void) {
-        uint w = uint(textureSize(sourceTexture, 0).x);
-        uint idx = uint(gl_FragCoord.x) + uint(gl_FragCoord.y) * w;
-        if (idx >= numSplats) discard;
+        int w = int(textureSize(means_l, 0).x);
+        ivec2 uv = ivec2(gl_FragCoord.xy);
+        if (uint(uv.x + uv.y * w) >= numSplats) {
+            discard;
+        }
 
-        // fetch the source index and calculate source uv
-        uint sidx = texelFetch(orderTexture, ivec2(gl_FragCoord.xy), 0).x;
-        uvec2 suv = uvec2(sidx % w, sidx / w);
+        vec3 meansLSample = texelFetch(means_l, uv, 0).xyz;
+        vec3 meansUSample = texelFetch(means_u, uv, 0).xyz;
+        vec4 quatsSample = texelFetch(quats, uv, 0);
+        vec3 scalesSample = texelFetch(scales, uv, 0).xyz;
+        vec2 shLabelsSample = texelFetch(sh_labels, uv, 0).xy;
 
-        // sample the source texture
-        gl_FragColor = texelFetch(sourceTexture, ivec2(suv), 0);
+        pcFragColor0 = packU32(
+            vec4(meansLSample, shLabelsSample.x),
+            vec4(meansUSample, shLabelsSample.y),
+            vec4(quatsSample),
+            vec4(scalesSample, 0.0)
+        );
     }
 `;
 
 var wgslGsplatSogsReorderPS = /* wgsl */ `
-    var orderTexture: texture_2d<u32>;
-    var sourceTexture: texture_2d<f32>;
+    var means_l: texture_2d<f32>;
+    var means_u: texture_2d<f32>;
+    var quats: texture_2d<f32>;
+    var scales: texture_2d<f32>;
+    var sh_labels: texture_2d<f32>;
+
     uniform numSplats: u32;
 
+    fn packU32(v: vec4<f32>) -> u32 {
+        return (u32(v.x * 255.0) << 24u)  |
+               (u32(v.y * 255.0) << 16u)  |
+               (u32(v.z * 255.0) << 8u) |
+               u32(v.w * 255.0);
+    }
+
+    fn packUVec32(a: vec4<f32>, b: vec4<f32>, c: vec4<f32>, d: vec4<f32>) -> vec4<u32> {
+        return vec4<u32>(packU32(a), packU32(b), packU32(c), packU32(d));
+    }
+
     @fragment
     fn fragmentMain(input: FragmentInput) -> FragmentOutput {
         var output: FragmentOutput;
 
-        let w: u32 = textureDimensions(sourceTexture, 0).x;
-        let idx: u32 = u32(pcPosition.x) + u32(pcPosition.y) * w;
-        if (idx >= uniform.numSplats) {
+        let w: u32 = textureDimensions(means_l, 0).x;
+        let uv: vec2<u32> = vec2<u32>(pcPosition.xy);
+        if (uv.x + uv.y * w >= uniform.numSplats) {
             discard;
             return output;
         }
 
         // fetch the source index and calculate source uv
-        let sidx: u32 = textureLoad(orderTexture, vec2<i32>(input.position.xy), 0).x;
-        let suv: vec2<u32> = vec2<u32>(sidx % w, sidx / w);
+        let meansLSample: vec3<f32> = textureLoad(means_l, uv, 0).xyz;
+        let meansUSample: vec3<f32> = textureLoad(means_u, uv, 0).xyz;
+        let quatsSample: vec4<f32> = textureLoad(quats, uv, 0);
+        let scalesSample: vec3<f32> = textureLoad(scales, uv, 0).xyz;
+        let shLabelsSample: vec2<f32> = textureLoad(sh_labels, uv, 0).xy;
+
+        output.color = packUVec32(
+            vec4(meansLSample, shLabelsSample.x),
+            vec4(meansUSample, shLabelsSample.y),
+            vec4(quatsSample),
+            vec4(scalesSample, 0.0)
+        );
 
-        // sample the source texture
-        output.color = textureLoad(sourceTexture, vec2<i32>(suv), 0);
         return output;
     }
 `;
@@ -48654,6 +48919,7 @@ class GSplatSogsData {
         this.sh0?.destroy();
         this.sh_centroids?.destroy();
         this.sh_labels?.destroy();
+        this.packedTexture?.destroy();
     }
     createIter(p, r, s, c, sh) {
         return new GSplatSogsIterator(this, p, r, s, c, sh);
@@ -48669,7 +48935,6 @@ class GSplatSogsData {
         const { means } = meta;
         const means_u_data = new Uint32Array(means_u._levels[0].buffer);
         const means_l_data = new Uint32Array(means_l._levels[0].buffer);
-        const order = this.orderTexture?._levels[0];
         const mx = means.mins[0] / 65535;
         const my = means.mins[1] / 65535;
         const mz = means.mins[2] / 65535;
@@ -48677,7 +48942,7 @@ class GSplatSogsData {
         const My = means.maxs[1] / 65535;
         const Mz = means.maxs[2] / 65535;
         for(let i = 0; i < numSplats; i++){
-            const idx = order ? order[i] : i;
+            const idx = i;
             const means_u = means_u_data[idx];
             const means_l = means_l_data[idx];
             const wx = means_u << 8 & 0xff00 | means_l & 0xff;
@@ -48793,10 +49058,10 @@ class GSplatSogsData {
             }
         ]);
     }
-    // reorder the sogs texture data in gpu memory given the ordering encoded in texture data
-    reorderGpuMemory() {
-        const { orderTexture, numSplats } = this;
-        const { device, height, width } = orderTexture;
+    // pack the means, quats, scales and sh_labels data into one RGBA32U texture
+    packGpuMemory() {
+        const { means_l, means_u, quats, scales, sh_labels, numSplats } = this;
+        const { device } = means_l;
         const { scope } = device;
         const shader = ShaderUtils.createShader(device, {
             uniqueName: 'GsplatSogsReorderShader',
@@ -48805,107 +49070,52 @@ class GSplatSogsData {
             },
             vertexChunk: 'fullscreenQuadVS',
             fragmentGLSL: glslGsplatSogsReorderPS,
-            fragmentWGSL: wgslGsplatSogsReorderPS
+            fragmentWGSL: wgslGsplatSogsReorderPS,
+            fragmentOutputTypes: [
+                'uvec4'
+            ]
         });
-        const sourceTexture = new Texture(device, {
-            width: width,
-            height: height,
-            format: PIXELFORMAT_RGBA8,
-            mipmaps: false
+        const renderTarget = new RenderTarget({
+            colorBuffer: this.packedTexture,
+            depth: false,
+            mipLevel: 0
         });
-        const members = [
-            'means_l',
-            'means_u',
-            'quats',
-            'scales',
-            'sh0',
-            'sh_labels'
-        ];
-        device.setBlendState(BlendState.NOBLEND);
         device.setCullMode(CULLFACE_NONE);
+        device.setBlendState(BlendState.NOBLEND);
         device.setDepthState(DepthState.NODEPTH);
-        members.forEach((member)=>{
-            const targetTexture = this[member];
-            // spherical harmonics labels are missing when no SH data is present
-            if (!targetTexture) {
-                return;
-            }
-            const renderTarget = new RenderTarget({
-                colorBuffer: targetTexture,
-                depth: false,
-                mipLevel: 0
-            });
-            // patch source texture with data from target
-            sourceTexture._levels[0] = targetTexture._levels[0];
-            sourceTexture.upload();
-            resolve(scope, {
-                orderTexture,
-                sourceTexture,
-                numSplats
-            });
-            drawQuadWithShader(device, renderTarget, shader);
-            renderTarget.destroy();
+        resolve(scope, {
+            means_l,
+            means_u,
+            quats,
+            scales,
+            // use means_l as dummy texture for sh_labels if there is no spherical harmonics data
+            sh_labels: sh_labels ?? means_l,
+            numSplats
         });
-        sourceTexture.destroy();
+        drawQuadWithShader(device, renderTarget, shader);
+        renderTarget.destroy();
+        shader.destroy();
     }
-    // construct an array containing the Morton order of the splats
-    // returns an array of 32-bit unsigned integers
-    calcMortonOrder() {
-        // https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
-        const encodeMorton3 = (x, y, z)=>{
-            const Part1By2 = (x)=>{
-                x &= 0x000003ff;
-                x = (x ^ x << 16) & 0xff0000ff;
-                x = (x ^ x << 8) & 0x0300f00f;
-                x = (x ^ x << 4) & 0x030c30c3;
-                x = (x ^ x << 2) & 0x09249249;
-                return x;
-            };
-            return (Part1By2(z) << 2) + (Part1By2(y) << 1) + Part1By2(x);
-        };
-        const { means_l, means_u } = this;
-        const means_l_data = means_l._levels[0];
-        const means_u_data = means_u._levels[0];
-        const codes = new BigUint64Array(this.numSplats);
-        // generate Morton codes for each splat based on the means directly (i.e. the log-space coordinates)
-        for(let i = 0; i < this.numSplats; ++i){
-            const ix = means_u_data[i * 4 + 0] << 2 | means_l_data[i * 4 + 0] >>> 6;
-            const iy = means_u_data[i * 4 + 1] << 2 | means_l_data[i * 4 + 1] >>> 6;
-            const iz = means_u_data[i * 4 + 2] << 2 | means_l_data[i * 4 + 2] >>> 6;
-            codes[i] = BigInt(encodeMorton3(ix, iy, iz)) << BigInt(32) | BigInt(i);
-        }
-        codes.sort();
-        // allocate data for the order buffer, but make it texture-memory sized
-        const order = new Uint32Array(means_l.width * means_l.height);
-        for(let i = 0; i < this.numSplats; ++i){
-            order[i] = Number(codes[i] & BigInt(0xffffffff));
-        }
-        return order;
-    }
-    async reorderData() {
+    async prepareGpuData() {
         const { device, height, width } = this.means_l;
-        // copy back means_l and means_u data from gpu so cpu reorder has access to it
+        // copy back means_l and means_u data so cpu reorder has access to it
         this.means_l._levels[0] = await readImageDataAsync(this.means_l);
         this.means_u._levels[0] = await readImageDataAsync(this.means_u);
-        this.orderTexture = new Texture(device, {
-            name: 'orderTexture',
-            width,
-            height,
-            format: PIXELFORMAT_R32U,
-            mipmaps: false,
-            levels: [
-                this.calcMortonOrder()
-            ]
+        this.packedTexture = new Texture(device, {
+            name: 'sogsPackedTexture',
+            width: width,
+            height: height,
+            format: PIXELFORMAT_RGBA32U,
+            mipmaps: false
         });
         device.on('devicerestored', ()=>{
-            this.reorderGpuMemory();
+            this.packGpuMemory();
         });
-        this.reorderGpuMemory();
+        this.packGpuMemory();
     }
-    async readMeansImageData() {
-        const { means_l, means_u } = this;
-        means_l._levels[0] = await readImageDataAsync(means_l);
-        means_u._levels[0] = await readImageDataAsync(means_u);
+    // temporary, for backwards compatibility
+    reorderData() {
+        return this.prepareGpuData();
     }
 }
 
@@ -49095,13 +49305,9 @@ class GSplatSogsResource extends GSplatResourceBase {
         material.setDefine('GSPLAT_SOGS_DATA', true);
         material.setDefine('SH_BANDS', this.gsplatData.shBands);
         [
-            'means_l',
-            'means_u',
-            'quats',
-            'scales',
+            'packedTexture',
             'sh0',
-            'sh_centroids',
-            'sh_labels'
+            'sh_centroids'
         ].forEach((name)=>{
             if (gsplatData[name]) {
                 material.setParameter(name, gsplatData[name]);
@@ -55805,10 +56011,7 @@ vec4 readColor(in SplatSource source) {
 `;
 
 var gsplatSogsDataVS$1 = /* glsl */ `
-uniform highp sampler2D means_u;
-uniform highp sampler2D means_l;
-uniform highp sampler2D quats;
-uniform highp sampler2D scales;
+uniform highp usampler2D packedTexture;
 
 uniform vec3 means_mins;
 uniform vec3 means_maxs;
@@ -55816,13 +56019,28 @@ uniform vec3 means_maxs;
 uniform vec3 scales_mins;
 uniform vec3 scales_maxs;
 
+vec4 unpackU32(uint v) {
+    return vec4(
+        float((v >> 24u) & 0xFFu) / 255.0,
+        float((v >> 16u) & 0xFFu) / 255.0,
+        float((v >> 8u) & 0xFFu) / 255.0,
+        float(v & 0xFFu) / 255.0
+    );
+}
+
+uvec4 packedSample;
+
 // read the model-space center of the gaussian
 vec3 readCenter(SplatSource source) {
-    vec3 u = texelFetch(means_u, source.uv, 0).xyz;
-    vec3 l = texelFetch(means_l, source.uv, 0).xyz;
-    vec3 n = (l * 255.0 + u * 255.0 * 256.0) / 65535.0;
 
+    // read the packed texture sample
+    packedSample = texelFetch(packedTexture, source.uv, 0);
+
+    vec3 l = unpackU32(packedSample.x).xyz;
+    vec3 u = unpackU32(packedSample.y).xyz;
+    vec3 n = (l * 255.0 + u * 255.0 * 256.0) / 65535.0;
     vec3 v = mix(means_mins, means_maxs, n);
+
     return sign(v) * (exp(abs(v)) - 1.0);
 }
 
@@ -55830,7 +56048,9 @@ const float norm = 2.0 / sqrt(2.0);
 
 // sample covariance vectors
 void readCovariance(in SplatSource source, out vec3 covA, out vec3 covB) {
-    vec4 qdata = texelFetch(quats, source.uv, 0);
+    vec4 qdata = unpackU32(packedSample.z);
+    vec3 sdata = unpackU32(packedSample.w).xyz;
+
     vec3 abc = (qdata.xyz - 0.5) * norm;
     float d = sqrt(max(0.0, 1.0 - dot(abc, abc)));
 
@@ -55841,7 +56061,7 @@ void readCovariance(in SplatSource source, out vec3 covA, out vec3 covB) {
                 ((mode == 2u) ? vec4(abc.xy, d, abc.z) : vec4(abc, d)));
 
     mat3 rot = quatToMat3(quat);
-    vec3 scale = exp(mix(scales_mins, scales_maxs, texelFetch(scales, source.uv, 0).xyz));
+    vec3 scale = exp(mix(scales_mins, scales_maxs, sdata));
 
     // M = S * R
     mat3 M = transpose(mat3(
@@ -55856,7 +56076,6 @@ void readCovariance(in SplatSource source, out vec3 covA, out vec3 covB) {
 `;
 
 var gsplatSogsSHVS$1 = /* glsl */ `
-uniform highp sampler2D sh_labels;
 uniform highp sampler2D sh_centroids;
 
 uniform float shN_mins;
@@ -55866,7 +56085,7 @@ uniform float shN_maxs;
 
 void readSHData(in SplatSource source, out vec3 sh[SH_COEFFS], out float scale) {
     // extract spherical harmonics palette index
-    ivec2 t = ivec2(texelFetch(sh_labels, source.uv, 0).xy * 255.0);
+    ivec2 t = ivec2(packedSample.x & 255u, packedSample.y & 255u);
     int n = t.x + t.y * 256;
     int u = (n % 64) * SH_COEFFS;
     int v = n / 64;
@@ -58669,9 +58888,11 @@ var morphPS$1 = /* glsl */ `
     void main (void) {
         highp vec3 color = vec3(0, 0, 0);
 
+        ivec2 pixelCoords = ivec2(uv0 * vec2(textureSize(morphTexture, 0).xy));
+        
         for (int i = 0; i < count; i++) {
             uint textureIndex = morphIndex[i];
-            vec3 delta = texture(morphTexture, vec3(uv0, textureIndex)).xyz;
+            vec3 delta = texelFetch(morphTexture, ivec3(pixelCoords, int(textureIndex)), 0).xyz;
             color += morphFactor[i] * delta;
         }
 
@@ -63810,10 +64031,7 @@ fn readColor(source: ptr<function, SplatSource>) -> vec4f {
 `;
 
 var gsplatSogsDataVS = /* wgsl */ `
-var means_u: texture_2d<f32>;
-var means_l: texture_2d<f32>;
-var quats: texture_2d<f32>;
-var scales: texture_2d<f32>;
+var packedTexture: texture_2d<u32>;
 
 uniform means_mins: vec3f;
 uniform means_maxs: vec3f;
@@ -63821,13 +64039,27 @@ uniform means_maxs: vec3f;
 uniform scales_mins: vec3f;
 uniform scales_maxs: vec3f;
 
+fn unpackU32(u: u32) -> vec4f {
+    return vec4f(
+        f32((u >> 24u) & 0xFFu) / 255.0,
+        f32((u >> 16u) & 0xFFu) / 255.0,
+        f32((u >> 8u) & 0xFFu) / 255.0,
+        f32(u & 0xFFu) / 255.0
+    );
+}
+
+var<private> packedSample: vec4<u32>;
+
 // read the model-space center of the gaussian
 fn readCenter(source: ptr<function, SplatSource>) -> vec3f {
-    let u: vec3f = textureLoad(means_u, source.uv, 0).xyz;
-    let l: vec3f = textureLoad(means_l, source.uv, 0).xyz;
-    let n: vec3f = (l * 255.0 + u * 255.0 * 256.0) / 65535.0;
 
+    packedSample = textureLoad(packedTexture, source.uv, 0);
+
+    let l: vec3f = unpackU32(packedSample.x).xyz;
+    let u: vec3f = unpackU32(packedSample.y).xyz;
+    let n: vec3f = (l * 255.0 + u * 255.0 * 256.0) / 65535.0;
     let v: vec3f = mix(uniform.means_mins, uniform.means_maxs, n);
+
     return sign(v) * (exp(abs(v)) - 1.0);
 }
 
@@ -63835,7 +64067,9 @@ const norm: f32 = 2.0 / sqrt(2.0);
 
 // sample covariance vectors
 fn readCovariance(source: ptr<function, SplatSource>, covA_ptr: ptr<function, vec3f>, covB_ptr: ptr<function, vec3f>) {
-    let qdata: vec4f = textureLoad(quats, source.uv, 0);
+    let qdata: vec4f = unpackU32(packedSample.z);
+    let sdata: vec3f = unpackU32(packedSample.w).xyz;
+
     let abc: vec3f = (qdata.xyz - 0.5) * norm;
     let d: f32 = sqrt(max(0.0, 1.0 - dot(abc, abc)));
 
@@ -63854,7 +64088,7 @@ fn readCovariance(source: ptr<function, SplatSource>, covA_ptr: ptr<function, ve
 
 
     let rot: mat3x3f = quatToMat3(quat);
-    let scale: vec3f = exp(mix(uniform.scales_mins, uniform.scales_maxs, textureLoad(scales, source.uv, 0).xyz));
+    let scale: vec3f = exp(mix(uniform.scales_mins, uniform.scales_maxs, sdata));
 
     // M = S * R
     let M: mat3x3f = transpose(mat3x3f(
@@ -63869,7 +64103,6 @@ fn readCovariance(source: ptr<function, SplatSource>, covA_ptr: ptr<function, ve
 `;
 
 var gsplatSogsSHVS = /* wgsl */ `
-var sh_labels: texture_2d<f32>;
 var sh_centroids: texture_2d<f32>;
 
 uniform shN_mins: f32;
@@ -63877,7 +64110,7 @@ uniform shN_maxs: f32;
 
 fn readSHData(source: ptr<function, SplatSource>, sh: ptr<function, array<vec3f, SH_COEFFS>>, scale: ptr<function, f32>) {
     // extract spherical harmonics palette index
-    let t: vec2<i32> = vec2<i32>(textureLoad(sh_labels, source.uv, 0).xy * 255.0);
+    let t: vec2<i32> = vec2<i32>(i32(packedSample.x & 255u), i32(packedSample.y & 255u));
     let n: i32 = t.x + t.y * 256;
     let u: i32 = (n % 64) * SH_COEFFS;
     let v: i32 = n / 64;
@@ -66805,7 +67038,6 @@ var morphPS = /* wgsl */ `
     varying uv0: vec2f;
 
     var morphTexture: texture_2d_array<f32>;
-    var morphTextureSampler : sampler;
     uniform morphFactor: array<f32, {MORPH_TEXTURE_MAX_COUNT}>;
     uniform morphIndex: array<u32, {MORPH_TEXTURE_MAX_COUNT}>;
     uniform count: u32;
@@ -66813,9 +67045,12 @@ var morphPS = /* wgsl */ `
     @fragment
     fn fragmentMain(input : FragmentInput) -> FragmentOutput {
         var color = vec3f(0, 0, 0);
+        let textureDims = textureDimensions(morphTexture);
+        let pixelCoords = vec2i(input.uv0 * vec2f(textureDims));
+        
         for (var i: u32 = 0; i < uniform.count; i = i + 1) {
             var textureIndex: u32 = uniform.morphIndex[i].element;
-            var delta = textureSample(morphTexture, morphTextureSampler, input.uv0, textureIndex).xyz;
+            var delta = textureLoad(morphTexture, pixelCoords, textureIndex, 0).xyz;
             color += uniform.morphFactor[i].element * delta;
         }
 
@@ -81707,7 +81942,7 @@ let executionOrderCounter = 0;
      */ this._instance = null, /**
      * @type {ShaderMaterial|null}
      * @private
-     */ this._materialTmp = null, /** @private */ this._highQualitySH = false, /**
+     */ this._materialTmp = null, /** @private */ this._highQualitySH = true, /**
      * @type {BoundingBox|null}
      * @private
      */ this._customAabb = null, /**
@@ -86902,6 +87137,37 @@ class PlyParser {
     }
 }
 
+// combine the progress updates from multiple assets
+// and fire progress events on the target
+const combineProgress = (target, assets)=>{
+    const map = new Map();
+    const fire = ()=>{
+        let loaded = 0;
+        let total = 0;
+        map.forEach((value)=>{
+            loaded += value.loaded;
+            total += value.total;
+        });
+        target.fire('progress', loaded, total);
+    };
+    assets.forEach((asset)=>{
+        const progress = (loaded, total)=>{
+            map.set(asset, {
+                loaded,
+                total
+            });
+            fire();
+        };
+        const done = ()=>{
+            asset.off('progress', progress);
+            asset.off('load', done);
+            asset.off('error', done);
+        };
+        asset.on('progress', progress);
+        asset.on('load', done);
+        asset.on('error', done);
+    });
+};
 /**
  * @import { AppBase } from '../app-base.js'
  * @import { ResourceHandlerCallback } from '../handlers/handler.js'
@@ -86938,11 +87204,13 @@ class PlyParser {
                     texture.on('error', (err)=>reject(err));
                 });
                 assets.add(texture);
-                assets.load(texture);
                 promises.push(promise);
                 return texture;
             });
         });
+        const textureAssets = subs.map((sub)=>textures[sub]).flat();
+        combineProgress(asset, textureAssets);
+        textureAssets.forEach((t)=>assets.load(t));
         // wait for all textures to complete loading
         await Promise.allSettled(promises);
         // construct the gsplat resource
@@ -86956,12 +87224,12 @@ class PlyParser {
         data.sh0 = textures.sh0[0].resource;
         data.sh_centroids = textures.shN?.[0]?.resource;
         data.sh_labels = textures.shN?.[1]?.resource;
-        if (asset.data?.reorder ?? true) {
-            await data.reorderData();
-        } else {
-            await data.readMeansImageData();
+        const decompress = asset.data?.decompress;
+        if (!decompress) {
+            // no need to prepare gpu data if decompressing
+            await data.prepareGpuData();
         }
-        const resource = asset.data?.decompress ? new GSplatResource(this.app.graphicsDevice, await data.decompress()) : new GSplatSogsResource(this.app.graphicsDevice, data);
+        const resource = decompress ? new GSplatResource(this.app.graphicsDevice, await data.decompress()) : new GSplatSogsResource(this.app.graphicsDevice, data);
         callback(null, resource);
     }
     /**
@@ -88028,9 +88296,9 @@ class ImgAlphaTest {
             crossOrigin = this.crossOrigin;
         }
         if (this.device.supportsImageBitmap) {
-            this._loadImageBitmap(url.load, url.original, crossOrigin, handler);
+            this._loadImageBitmap(url.load, url.original, crossOrigin, handler, asset);
         } else {
-            this._loadImage(url.load, url.original, crossOrigin, handler);
+            this._loadImage(url.load, url.original, crossOrigin, handler, asset);
         }
     }
     open(url, data, device, textureOptions = {}) {
@@ -88045,7 +88313,7 @@ class ImgAlphaTest {
         texture.setSource(data);
         return texture;
     }
-    _loadImage(url, originalUrl, crossOrigin, callback) {
+    _loadImage(url, originalUrl, crossOrigin, callback, asset) {
         const image = new Image();
         if (crossOrigin) {
             image.crossOrigin = crossOrigin;
@@ -88053,8 +88321,12 @@ class ImgAlphaTest {
         let retries = 0;
         const maxRetries = this.maxRetries;
         let retryTimeout;
+        const dummySize = 1024 * 1024;
+        // HTMLImageElement doesn't support progress events, so we emulate it instead
+        asset?.fire('progress', 0, dummySize);
         // Call success callback after opening Texture
         image.onload = function() {
+            asset?.fire('progress', dummySize, dummySize);
             callback(null, image);
         };
         image.onerror = function() {
@@ -88078,12 +88350,13 @@ class ImgAlphaTest {
         };
         image.src = url;
     }
-    _loadImageBitmap(url, originalUrl, crossOrigin, callback) {
+    _loadImageBitmap(url, originalUrl, crossOrigin, callback, asset) {
         const options = {
             cache: true,
             responseType: 'blob',
             retry: this.maxRetries > 0,
-            maxRetries: this.maxRetries
+            maxRetries: this.maxRetries,
+            progress: asset
         };
         http.get(url, options, (err, blob)=>{
             if (err) {
@@ -89014,173 +89287,185 @@ class KdTree {
     }
 }
 
-const clusterWgsl = (numColumns, numPoints, numCentroids, useF16) => {
+const clusterWgsl = (numColumns, useF16) => {
     const floatType = useF16 ? 'f16' : 'f32';
-    return `
-${useF16 ? 'enable f16;' : ''}
-
-@group(0) @binding(0) var<storage, read> points: array<${floatType}>;
-@group(0) @binding(1) var<storage, read> centroids: array<${floatType}>;
-@group(0) @binding(2) var<storage, read_write> results: array<u32>;
-
-const numColumns = ${numColumns};
-const numPoints = ${numPoints};
-const numCentroids = ${numCentroids};
-
-const chunkSize = 128u; // must be a multiple of 64
-var<workgroup> sharedChunk: array<${floatType}, numColumns * chunkSize>;
-
-// calculate the squared distance between the point and centroid
-fn calcDistanceSqr(point: array<${floatType}, numColumns>, centroid: u32) -> f32 {
-    var result = 0.0;
-
-    var ci = centroid * numColumns;
-
-    for (var i = 0u; i < numColumns; i++) {
-        let v = f32(point[i] - sharedChunk[ci+i]);
-        result += v * v;
-    }
-
-    return result;
-}
-
-@compute @workgroup_size(64)
-fn main(
-    @builtin(local_invocation_index) local_id : u32,
-    @builtin(global_invocation_id) global_id: vec3u,
-    @builtin(num_workgroups) num_workgroups: vec3u
-) {
-    // calculate row index for this thread point
-    let pointIndex = global_id.x + global_id.y * num_workgroups.x * 64;
-
-    // copy the point data from global memory
-    var point: array<${floatType}, numColumns>;
-    if (pointIndex < numPoints) {
-        for (var i = 0u; i < numColumns; i++) {
-            point[i] = points[pointIndex * numColumns + i];
-        }
-    }
-
-    var mind = 1000000.0;
-    var mini = 0u;
-
-    // work through the list of centroids in shared memory chunks
-    let numChunks = u32(ceil(f32(numCentroids) / f32(chunkSize)));
-    for (var i = 0u; i < numChunks; i++) {
-
-        // copy this thread's slice of the centroid shared chunk data
-        let dstRow = local_id * (chunkSize / 64u);
-        let srcRow = min(numCentroids, i * chunkSize + local_id * chunkSize / 64u);
-        let numRows = min(numCentroids, srcRow + chunkSize / 64u) - srcRow;
-
-        var dst = dstRow * numColumns;
-        var src = srcRow * numColumns;
-
-        for (var c = 0u; c < numRows * numColumns; c++) {
-            sharedChunk[dst + c] = centroids[src + c];
-        }
-
-        // wait for all threads to finish writing their part of centroids shared memory buffer
-        workgroupBarrier();
-
-        // loop over the next chunk of centroids finding the closest
-        if (pointIndex < numPoints) {
-            let thisChunkSize = min(chunkSize, numCentroids - i * chunkSize);
-            for (var c = 0u; c < thisChunkSize; c++) {
-                let d = calcDistanceSqr(point, c);
-                if (d < mind) {
-                    mind = d;
-                    mini = i * chunkSize + c;
-                }
-            }
-        }
-
-        // next loop will overwrite the shared memory, so wait
-        workgroupBarrier();
-    }
-
-    if (pointIndex < numPoints) {
-        results[pointIndex] = mini;
-    }
-}
+    return /* wgsl */ `
+${useF16 ? 'enable f16;' : ''}
+
+struct Uniforms {
+    numPoints: u32,
+    numCentroids: u32
+};
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
+@group(0) @binding(1) var<storage, read> points: array<${floatType}>;
+@group(0) @binding(2) var<storage, read> centroids: array<${floatType}>;
+@group(0) @binding(3) var<storage, read_write> results: array<u32>;
+
+const numColumns = ${numColumns};   // number of columns in the points and centroids tables
+const chunkSize = 128u;             // must be a multiple of 64
+var<workgroup> sharedChunk: array<${floatType}, numColumns * chunkSize>;
+
+// calculate the squared distance between the point and centroid
+fn calcDistanceSqr(point: array<${floatType}, numColumns>, centroid: u32) -> f32 {
+    var result = 0.0;
+
+    var ci = centroid * numColumns;
+
+    for (var i = 0u; i < numColumns; i++) {
+        let v = f32(point[i] - sharedChunk[ci+i]);
+        result += v * v;
+    }
+
+    return result;
+}
+
+@compute @workgroup_size(64)
+fn main(
+    @builtin(local_invocation_index) local_id : u32,
+    @builtin(global_invocation_id) global_id: vec3u,
+    @builtin(num_workgroups) num_workgroups: vec3u
+) {
+    // calculate row index for this thread point
+    let pointIndex = global_id.x + global_id.y * num_workgroups.x * 64u;
+
+    // copy the point data from global memory
+    var point: array<${floatType}, numColumns>;
+    if (pointIndex < uniforms.numPoints) {
+        for (var i = 0u; i < numColumns; i++) {
+            point[i] = points[pointIndex * numColumns + i];
+        }
+    }
+
+    var mind = 1000000.0;
+    var mini = 0u;
+
+    // work through the list of centroids in shared memory chunks
+    let numChunks = u32(ceil(f32(uniforms.numCentroids) / f32(chunkSize)));
+    for (var i = 0u; i < numChunks; i++) {
+
+        // copy this thread's slice of the centroid shared chunk data
+        let dstRow = local_id * (chunkSize / 64u);
+        let srcRow = min(uniforms.numCentroids, i * chunkSize + local_id * chunkSize / 64u);
+        let numRows = min(uniforms.numCentroids, srcRow + chunkSize / 64u) - srcRow;
+
+        var dst = dstRow * numColumns;
+        var src = srcRow * numColumns;
+
+        for (var c = 0u; c < numRows * numColumns; c++) {
+            sharedChunk[dst + c] = centroids[src + c];
+        }
+
+        // wait for all threads to finish writing their part of centroids shared memory buffer
+        workgroupBarrier();
+
+        // loop over the next chunk of centroids finding the closest
+        if (pointIndex < uniforms.numPoints) {
+            let thisChunkSize = min(chunkSize, uniforms.numCentroids - i * chunkSize);
+            for (var c = 0u; c < thisChunkSize; c++) {
+                let d = calcDistanceSqr(point, c);
+                if (d < mind) {
+                    mind = d;
+                    mini = i * chunkSize + c;
+                }
+            }
+        }
+
+        // next loop will overwrite the shared memory, so wait
+        workgroupBarrier();
+    }
+
+    if (pointIndex < uniforms.numPoints) {
+        results[pointIndex] = mini;
+    }
+}
 `;
 };
 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;
     }
     else {
-        const result = new Float32Array(numColumns * numRows);
+        // 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[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 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),
             new BindStorageBufferFormat('centroidsBuffer', SHADERSTAGE_COMPUTE, true),
             new BindStorageBufferFormat('resultsBuffer', SHADERSTAGE_COMPUTE)
         ]);
-        const numPoints = points.numRows;
-        const numColumns = points.numColumns;
         const shader = new Shader(device, {
             name: 'compute-cluster',
             shaderLanguage: SHADERLANGUAGE_WGSL,
-            cshader: clusterWgsl(numColumns, numPoints, numCentroids, useF16),
+            cshader: clusterWgsl(numColumns, useF16),
+            // @ts-ignore
+            computeUniformBufferFormats: {
+                uniforms: new UniformBufferFormat(device, [
+                    new UniformFormat('numPoints', 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('columns', numColumns);
-        compute.setParameter('points', numPoints);
-        compute.setParameter('centroids', numCentroids);
         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);
+        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);
-            // calculate the workgroup layout to minimize the number of empty workgroups
-            const groups = Math.ceil(points.numRows / 64);
-            const height = Math.ceil(groups / 65536);
-            const width = Math.ceil(groups / height);
-            // start compute job
-            compute.setupDispatch(width, height);
-            device.computeDispatch([compute], 'cluster-dispatch');
-            // read results from gpu
-            // await resultsBuffer.read(0, undefined, labels, true);
-            // use internal read function until immediate flag is available (see https://github.com/playcanvas/engine/pull/7843)
-            await device.readStorageBuffer(resultsBuffer.impl, 0, resultsBuffer.byteSize, labels, true);
+            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);
+                // 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}`);
+                // read results from gpu and store in labels
+                await resultsBuffer.read(0, currentBatchSize * 4, resultsData, true);
+                labels.set(resultsData.subarray(0, currentBatchSize), batch * batchSize);
+            }
         };
         this.destroy = () => {
             pointsBuffer.destroy();
@@ -89260,14 +89545,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);
@@ -89284,6 +89569,9 @@ const kmeans = async (points, k, iterations, device) => {
         }
         stdout.write('#');
     }
+    if (gpuClustering) {
+        gpuClustering.destroy();
+    }
     console.log(' done 🎉');
     return { centroids, labels };
 };
@@ -89773,46 +90061,46 @@ const parseArguments = () => {
     }
     return { files, options };
 };
-const usage = `
-Apply geometric transforms & filters to Gaussian-splat point clouds
-===================================================================
-
-USAGE
-  splat-transform [GLOBAL]  <input.{ply|splat|ksplat}> [ACTIONS]  ...  <output.{ply|compressed.ply|meta.json|csv}> [ACTIONS]
-
-  • Every time an input file appears, it becomes the current working set; the following
-    ACTIONS are applied in the order listed.  
-  • The last file on the command line is treated as the output; anything after it is
-    interpreted as actions that modify the final result.
-
-SUPPORTED INPUTS
-    .ply   .splat   .ksplat
-
-SUPPORTED OUTPUTS
-    .ply   .compressed.ply   meta.json (SOGS)   .csv
-
-ACTIONS (can be repeated, in any order)
-    -t, --translate  x,y,z                  Translate splats by (x, y, z)
-    -r, --rotate     x,y,z                  Rotate splats by Euler angles (deg)
-    -s, --scale      x                      Uniformly scale splats by factor x
-    -n, --filterNaN                         Remove any Gaussian containing NaN/Inf
-    -c, --filterByValue name,cmp,value      Keep splats where  <name> <cmp> <value>
-                                            cmp ∈ {lt,lte,gt,gte,eq,neq}
-    -b, --filterBands  {0|1|2|3}            Strip spherical-harmonic bands > N
-
-GLOBAL OPTIONS
-    -w, --overwrite                         Overwrite output file if it already exists. Default is false.
-    -h, --help                              Show this help and exit.
-    -v, --version                           Show version and exit.
-    -g, --no-gpu                            Disable gpu when compressing spherical harmonics.
-    -i, --iterations  <number>              Specify the number of iterations when compressing spherical harmonics. More iterations generally lead to better results. Default is 10.
-
-EXAMPLES
-    # Simple scale-then-translate
-    splat-transform bunny.ply -s 0.5 -t 0,0,10 bunny_scaled.ply
-
-    # Chain two inputs and write compressed output, overwriting if necessary
-    splat-transform -w cloudA.ply -r 0,90,0 cloudB.ply -s 2 merged.compressed.ply
+const usage = `
+Apply geometric transforms & filters to Gaussian-splat point clouds
+===================================================================
+
+USAGE
+  splat-transform [GLOBAL]  <input.{ply|splat|ksplat}> [ACTIONS]  ...  <output.{ply|compressed.ply|meta.json|csv}> [ACTIONS]
+
+  • Every time an input file appears, it becomes the current working set; the following
+    ACTIONS are applied in the order listed.  
+  • The last file on the command line is treated as the output; anything after it is
+    interpreted as actions that modify the final result.
+
+SUPPORTED INPUTS
+    .ply   .splat   .ksplat
+
+SUPPORTED OUTPUTS
+    .ply   .compressed.ply   meta.json (SOGS)   .csv
+
+ACTIONS (can be repeated, in any order)
+    -t, --translate  x,y,z                  Translate splats by (x, y, z)
+    -r, --rotate     x,y,z                  Rotate splats by Euler angles (deg)
+    -s, --scale      x                      Uniformly scale splats by factor x
+    -n, --filterNaN                         Remove any Gaussian containing NaN/Inf
+    -c, --filterByValue name,cmp,value      Keep splats where  <name> <cmp> <value>
+                                            cmp ∈ {lt,lte,gt,gte,eq,neq}
+    -b, --filterBands  {0|1|2|3}            Strip spherical-harmonic bands > N
+
+GLOBAL OPTIONS
+    -w, --overwrite                         Overwrite output file if it already exists. Default is false.
+    -h, --help                              Show this help and exit.
+    -v, --version                           Show version and exit.
+    -g, --no-gpu                            Disable gpu when compressing spherical harmonics.
+    -i, --iterations  <number>              Specify the number of iterations when compressing spherical harmonics. More iterations generally lead to better results. Default is 10.
+
+EXAMPLES
+    # Simple scale-then-translate
+    splat-transform bunny.ply -s 0.5 -t 0,0,10 bunny_scaled.ply
+
+    # Chain two inputs and write compressed output, overwriting if necessary
+    splat-transform -w cloudA.ply -r 0,90,0 cloudB.ply -s 2 merged.compressed.ply
 `;
 const main = async () => {
     console.log(`splat-transform v${version$1}`);