@luma.gl/effects 9.3.0-alpha.9 → 9.3.0

package/dist/dist.dev.js

@@ -75,13 +75,13 @@ var __exports__ = (() => {
     Resource: () => Resource,
     Sampler: () => Sampler,
     Shader: () => Shader,
+    ShaderBlockWriter: () => ShaderBlockWriter,
     ShaderFactory: () => ShaderFactory,
     SharedRenderPipeline: () => SharedRenderPipeline,
     Texture: () => Texture,
     TextureView: () => TextureView,
     TransformFeedback: () => TransformFeedback,
     UniformBlock: () => UniformBlock,
-    UniformBufferLayout: () => UniformBufferLayout,
     UniformStore: () => UniformStore,
     VertexArray: () => VertexArray,
     _getDefaultBindGroupFactory: () => _getDefaultBindGroupFactory,
@@ -102,6 +102,7 @@ var __exports__ = (() => {
     isExternalImage: () => isExternalImage,
     log: () => log,
     luma: () => luma,
+    makeShaderBlockLayout: () => makeShaderBlockLayout,
     normalizeBindingsByGroup: () => normalizeBindingsByGroup,
     readPixel: () => readPixel,
     setTextureImageData: () => setTextureImageData,
@@ -1472,12 +1473,51 @@ var __exports__ = (() => {
           }
           return `${dataType}x${components}`;
         case "snorm8":
+          if (components === 1) {
+            return "snorm8";
+          }
+          if (components === 3) {
+            return "snorm8x3-webgl";
+          }
+          return `${dataType}x${components}`;
         case "uint8":
         case "sint8":
+          if (components === 1 || components === 3) {
+            throw new Error(`size: ${components}`);
+          }
+          return `${dataType}x${components}`;
         case "uint16":
+          if (components === 1) {
+            return "uint16";
+          }
+          if (components === 3) {
+            return "uint16x3-webgl";
+          }
+          return `${dataType}x${components}`;
         case "sint16":
+          if (components === 1) {
+            return "sint16";
+          }
+          if (components === 3) {
+            return "sint16x3-webgl";
+          }
+          return `${dataType}x${components}`;
         case "unorm16":
+          if (components === 1) {
+            return "unorm16";
+          }
+          if (components === 3) {
+            return "unorm16x3-webgl";
+          }
+          return `${dataType}x${components}`;
         case "snorm16":
+          if (components === 1) {
+            return "snorm16";
+          }
+          if (components === 3) {
+            return "snorm16x3-webgl";
+          }
+          return `${dataType}x${components}`;
         case "float16":
           if (components === 1 || components === 3) {
             throw new Error(`size: ${components}`);
@@ -2180,7 +2220,7 @@ or create a device with the 'debug: true' prop.`;
       throw new Error("_createBindGroupLayoutWebGPU() not implemented");
     }
     /** Internal WebGPU-only helper for creating a native bind group. */
-    _createBindGroupWebGPU(_bindGroupLayout, _shaderLayout, _bindings, _group) {
+    _createBindGroupWebGPU(_bindGroupLayout, _shaderLayout, _bindings, _group, _label) {
       throw new Error("_createBindGroupWebGPU() not implemented");
     }
     /**
@@ -4394,12 +4434,14 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       for (const group of getBindGroupIndicesUpToMax(pipeline.shaderLayout.bindings)) {
         const groupBindings = bindingsByGroup[group];
         const bindGroupLayout = this._getBindGroupLayout(pipeline, group);
+        const bindGroupLabel = getBindGroupLabel(pipeline, pipeline.shaderLayout, group);
         if (!groupBindings || Object.keys(groupBindings).length === 0) {
           if (!hasBindingsInGroup(pipeline.shaderLayout.bindings, group)) {
             resolvedBindGroups[group] = this._getEmptyBindGroup(
               bindGroupLayout,
               pipeline.shaderLayout,
-              group
+              group,
+              bindGroupLabel
             );
           }
           continue;
@@ -4415,7 +4457,8 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
             bindGroupLayout,
             pipeline.shaderLayout,
             groupBindings,
-            group
+            group,
+            bindGroupLabel
           );
           layoutCache.bindGroupsBySource.set(bindGroupCacheKey, bindGroup);
           resolvedBindGroups[group] = bindGroup;
@@ -4424,7 +4467,8 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
             bindGroupLayout,
             pipeline.shaderLayout,
             groupBindings,
-            group
+            group,
+            bindGroupLabel
           );
         }
       }
@@ -4439,9 +4483,9 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       layoutCache[group] ||= this.device._createBindGroupLayoutWebGPU(pipeline, group);
       return layoutCache[group];
     }
-    _getEmptyBindGroup(bindGroupLayout, shaderLayout, group) {
+    _getEmptyBindGroup(bindGroupLayout, shaderLayout, group, label) {
       const layoutCache = this._getLayoutBindGroupCache(bindGroupLayout);
-      layoutCache.emptyBindGroup ||= this.device._createBindGroupWebGPU(bindGroupLayout, shaderLayout, {}, group) || null;
+      layoutCache.emptyBindGroup ||= this.device._createBindGroupWebGPU(bindGroupLayout, shaderLayout, {}, group, label) || null;
       return layoutCache.emptyBindGroup;
     }
     _getLayoutBindGroupCache(bindGroupLayout) {
@@ -4467,6 +4511,11 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
   function hasBindingsInGroup(bindings, group) {
     return bindings.some((binding) => binding.group === group);
   }
+  function getBindGroupLabel(pipeline, shaderLayout, group) {
+    const bindingNames = shaderLayout.bindings.filter((binding) => binding.group === group).sort((left, right) => left.location - right.location).map((binding) => binding.name);
+    const bindingSuffix = bindingNames.length > 0 ? bindingNames.join(",") : "empty";
+    return `${pipeline.id}/group${group}[${bindingSuffix}]`;
+  }
 
   // ../core/src/adapter/resources/render-pass.ts
   var _RenderPass = class extends Resource {
@@ -5066,6 +5115,170 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
     sint32: ["sint32", "i32", 4, false, Int32Array]
   };
 
+  // ../core/src/shadertypes/shader-types/shader-block-layout.ts
+  function makeShaderBlockLayout(uniformTypes, options = {}) {
+    const copiedUniformTypes = { ...uniformTypes };
+    const layout = options.layout ?? "std140";
+    const fields = {};
+    let size = 0;
+    for (const [key, uniformType] of Object.entries(copiedUniformTypes)) {
+      size = addToLayout(fields, key, uniformType, size, layout);
+    }
+    size = alignTo(size, getTypeAlignment(copiedUniformTypes, layout));
+    return {
+      layout,
+      byteLength: size * 4,
+      uniformTypes: copiedUniformTypes,
+      fields
+    };
+  }
+  function getLeafLayoutInfo(type, layout) {
+    const resolvedType = resolveVariableShaderTypeAlias(type);
+    const decodedType = getVariableShaderTypeInfo(resolvedType);
+    const matrixMatch = /^mat(\d)x(\d)<.+>$/.exec(resolvedType);
+    if (matrixMatch) {
+      const columns = Number(matrixMatch[1]);
+      const rows = Number(matrixMatch[2]);
+      const columnInfo = getVectorLayoutInfo(
+        rows,
+        resolvedType,
+        decodedType.type,
+        layout
+      );
+      const columnStride = getMatrixColumnStride(columnInfo.size, columnInfo.alignment, layout);
+      return {
+        alignment: columnInfo.alignment,
+        size: columns * columnStride,
+        components: columns * rows,
+        columns,
+        rows,
+        columnStride,
+        shaderType: resolvedType,
+        type: decodedType.type
+      };
+    }
+    const vectorMatch = /^vec(\d)<.+>$/.exec(resolvedType);
+    if (vectorMatch) {
+      return getVectorLayoutInfo(
+        Number(vectorMatch[1]),
+        resolvedType,
+        decodedType.type,
+        layout
+      );
+    }
+    return {
+      alignment: 1,
+      size: 1,
+      components: 1,
+      columns: 1,
+      rows: 1,
+      columnStride: 1,
+      shaderType: resolvedType,
+      type: decodedType.type
+    };
+  }
+  function isCompositeShaderTypeStruct(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  }
+  function addToLayout(fields, name2, type, offset, layout) {
+    if (typeof type === "string") {
+      const info = getLeafLayoutInfo(type, layout);
+      const alignedOffset = alignTo(offset, info.alignment);
+      fields[name2] = {
+        offset: alignedOffset,
+        ...info
+      };
+      return alignedOffset + info.size;
+    }
+    if (Array.isArray(type)) {
+      if (Array.isArray(type[0])) {
+        throw new Error(`Nested arrays are not supported for ${name2}`);
+      }
+      const elementType = type[0];
+      const length = type[1];
+      const stride = getArrayStride(elementType, layout);
+      const arrayOffset = alignTo(offset, getTypeAlignment(type, layout));
+      for (let i = 0; i < length; i++) {
+        addToLayout(fields, `${name2}[${i}]`, elementType, arrayOffset + i * stride, layout);
+      }
+      return arrayOffset + stride * length;
+    }
+    if (isCompositeShaderTypeStruct(type)) {
+      const structAlignment = getTypeAlignment(type, layout);
+      let structOffset = alignTo(offset, structAlignment);
+      for (const [memberName, memberType] of Object.entries(type)) {
+        structOffset = addToLayout(fields, `${name2}.${memberName}`, memberType, structOffset, layout);
+      }
+      return alignTo(structOffset, structAlignment);
+    }
+    throw new Error(`Unsupported CompositeShaderType for ${name2}`);
+  }
+  function getTypeSize(type, layout) {
+    if (typeof type === "string") {
+      return getLeafLayoutInfo(type, layout).size;
+    }
+    if (Array.isArray(type)) {
+      const elementType = type[0];
+      const length = type[1];
+      if (Array.isArray(elementType)) {
+        throw new Error("Nested arrays are not supported");
+      }
+      return getArrayStride(elementType, layout) * length;
+    }
+    let size = 0;
+    for (const memberType of Object.values(type)) {
+      const compositeMemberType = memberType;
+      size = alignTo(size, getTypeAlignment(compositeMemberType, layout));
+      size += getTypeSize(compositeMemberType, layout);
+    }
+    return alignTo(size, getTypeAlignment(type, layout));
+  }
+  function getTypeAlignment(type, layout) {
+    if (typeof type === "string") {
+      return getLeafLayoutInfo(type, layout).alignment;
+    }
+    if (Array.isArray(type)) {
+      const elementType = type[0];
+      const elementAlignment = getTypeAlignment(elementType, layout);
+      return uses16ByteArrayAlignment(layout) ? Math.max(elementAlignment, 4) : elementAlignment;
+    }
+    let maxAlignment = 1;
+    for (const memberType of Object.values(type)) {
+      const memberAlignment = getTypeAlignment(memberType, layout);
+      maxAlignment = Math.max(maxAlignment, memberAlignment);
+    }
+    return uses16ByteStructAlignment(layout) ? Math.max(maxAlignment, 4) : maxAlignment;
+  }
+  function getVectorLayoutInfo(components, shaderType, type, layout) {
+    return {
+      alignment: components === 2 ? 2 : 4,
+      size: components === 3 ? 3 : components,
+      components,
+      columns: 1,
+      rows: components,
+      columnStride: components === 3 ? 3 : components,
+      shaderType,
+      type
+    };
+  }
+  function getArrayStride(elementType, layout) {
+    const elementSize = getTypeSize(elementType, layout);
+    const elementAlignment = getTypeAlignment(elementType, layout);
+    return getArrayLikeStride(elementSize, elementAlignment, layout);
+  }
+  function getArrayLikeStride(size, alignment, layout) {
+    return alignTo(size, uses16ByteArrayAlignment(layout) ? 4 : alignment);
+  }
+  function getMatrixColumnStride(size, alignment, layout) {
+    return layout === "std140" ? 4 : alignTo(size, alignment);
+  }
+  function uses16ByteArrayAlignment(layout) {
+    return layout === "std140" || layout === "wgsl-uniform";
+  }
+  function uses16ByteStructAlignment(layout) {
+    return layout === "std140" || layout === "wgsl-uniform";
+  }
+
   // ../core/src/utils/array-utils-flat.ts
   var arrayBuffer;
   function getScratchArrayBuffer(byteLength) {
@@ -5090,49 +5303,56 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
     return isTypedArray(value);
   }
 
-  // ../core/src/portable/uniform-buffer-layout.ts
-  var minBufferSize = 1024;
-  var UniformBufferLayout = class {
-    layout = {};
-    uniformTypes;
-    /** number of bytes needed for buffer allocation */
-    byteLength;
-    /** Create a new UniformBufferLayout given a map of attributes. */
-    constructor(uniformTypes) {
-      this.uniformTypes = { ...uniformTypes };
-      let size = 0;
-      for (const [key, uniformType] of Object.entries(this.uniformTypes)) {
-        size = this._addToLayout(key, uniformType, size);
-      }
-      size = alignTo(size, 4);
-      this.byteLength = Math.max(size * 4, minBufferSize);
-    }
-    /** Does this layout have a field with specified name */
+  // ../core/src/portable/shader-block-writer.ts
+  var ShaderBlockWriter = class {
+    /** Layout metadata used to flatten and serialize values. */
+    layout;
+    /**
+     * Creates a writer for a precomputed shader-block layout.
+     */
+    constructor(layout) {
+      this.layout = layout;
+    }
+    /**
+     * Returns `true` if the flattened layout contains the given field.
+     */
     has(name2) {
-      return Boolean(this.layout[name2]);
+      return Boolean(this.layout.fields[name2]);
     }
-    /** Get offset and size for a field with specified name */
+    /**
+     * Returns offset and size metadata for a flattened field.
+     */
     get(name2) {
-      const layout = this.layout[name2];
-      return layout;
+      const entry = this.layout.fields[name2];
+      return entry ? { offset: entry.offset, size: entry.size } : void 0;
     }
-    /** Flatten nested uniform values into leaf-path values understood by UniformBlock. */
+    /**
+     * Flattens nested composite values into leaf-path values understood by {@link UniformBlock}.
+     *
+     * Top-level values may be supplied either in nested object form matching the
+     * declared composite shader types or as already-flattened leaf-path values.
+     */
     getFlatUniformValues(uniformValues) {
       const flattenedUniformValues = {};
       for (const [name2, value] of Object.entries(uniformValues)) {
-        const uniformType = this.uniformTypes[name2];
+        const uniformType = this.layout.uniformTypes[name2];
         if (uniformType) {
           this._flattenCompositeValue(flattenedUniformValues, name2, uniformType, value);
-        } else if (this.layout[name2]) {
+        } else if (this.layout.fields[name2]) {
           flattenedUniformValues[name2] = value;
         }
       }
       return flattenedUniformValues;
     }
-    /** Get the data for the complete buffer */
+    /**
+     * Serializes the supplied values into buffer-backed binary data.
+     *
+     * The returned view length matches {@link ShaderBlockLayout.byteLength}, which
+     * is the exact packed size of the block.
+     */
     getData(uniformValues) {
-      const buffer = getScratchArrayBuffer(this.byteLength);
-      new Uint8Array(buffer, 0, this.byteLength).fill(0);
+      const buffer = getScratchArrayBuffer(this.layout.byteLength);
+      new Uint8Array(buffer, 0, this.layout.byteLength).fill(0);
       const typedArrays = {
         i32: new Int32Array(buffer),
         u32: new Uint32Array(buffer),
@@ -5143,46 +5363,16 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       for (const [name2, value] of Object.entries(flattenedUniformValues)) {
         this._writeLeafValue(typedArrays, name2, value);
       }
-      return new Uint8Array(buffer, 0, this.byteLength);
-    }
-    // Recursively add a uniform to the layout
-    _addToLayout(name2, type, offset) {
-      if (typeof type === "string") {
-        const info = getLeafLayoutInfo(type);
-        const alignedOffset = alignTo(offset, info.alignment);
-        this.layout[name2] = {
-          offset: alignedOffset,
-          ...info
-        };
-        return alignedOffset + info.size;
-      }
-      if (Array.isArray(type)) {
-        if (Array.isArray(type[0])) {
-          throw new Error(`Nested arrays are not supported for ${name2}`);
-        }
-        const elementType = type[0];
-        const length = type[1];
-        const stride = alignTo(getTypeSize(elementType), 4);
-        const arrayOffset = alignTo(offset, 4);
-        for (let i = 0; i < length; i++) {
-          this._addToLayout(`${name2}[${i}]`, elementType, arrayOffset + i * stride);
-        }
-        return arrayOffset + stride * length;
-      }
-      if (isCompositeShaderTypeStruct(type)) {
-        let structOffset = alignTo(offset, 4);
-        for (const [memberName, memberType] of Object.entries(type)) {
-          structOffset = this._addToLayout(`${name2}.${memberName}`, memberType, structOffset);
-        }
-        return alignTo(structOffset, 4);
-      }
-      throw new Error(`Unsupported CompositeShaderType for ${name2}`);
+      return new Uint8Array(buffer, 0, this.layout.byteLength);
     }
+    /**
+     * Recursively flattens nested values using the declared composite shader type.
+     */
     _flattenCompositeValue(flattenedUniformValues, baseName, uniformType, value) {
       if (value === void 0) {
         return;
       }
-      if (typeof uniformType === "string" || this.layout[baseName]) {
+      if (typeof uniformType === "string" || this.layout.fields[baseName]) {
         flattenedUniformValues[baseName] = value;
         return;
       }
@@ -5226,9 +5416,12 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       }
       log.warn(`Unsupported uniform value for ${baseName}:`, value)();
     }
+    /**
+     * Expands tightly packed numeric arrays into per-element leaf fields.
+     */
     _flattenPackedArray(flattenedUniformValues, baseName, elementType, length, value) {
       const numericValue = value;
-      const elementLayout = getLeafLayoutInfo(elementType);
+      const elementLayout = getLeafLayoutInfo(elementType, this.layout.layout);
       const packedElementLength = elementLayout.components;
       for (let index = 0; index < length; index++) {
         const start = index * packedElementLength;
@@ -5246,13 +5439,16 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
         }
       }
     }
+    /**
+     * Writes one flattened leaf value into its typed-array view.
+     */
     _writeLeafValue(typedArrays, name2, value) {
-      const layout = this.layout[name2];
-      if (!layout) {
+      const entry = this.layout.fields[name2];
+      if (!entry) {
         log.warn(`Uniform ${name2} not found in layout`)();
         return;
       }
-      const { type, components, columns, rows, offset } = layout;
+      const { type, components, columns, rows, offset, columnStride } = entry;
       const array = typedArrays[type];
       if (components === 1) {
         array[offset] = Number(value);
@@ -5267,85 +5463,13 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       }
       let sourceIndex = 0;
       for (let columnIndex = 0; columnIndex < columns; columnIndex++) {
-        const columnOffset = offset + columnIndex * 4;
+        const columnOffset = offset + columnIndex * columnStride;
         for (let rowIndex = 0; rowIndex < rows; rowIndex++) {
           array[columnOffset + rowIndex] = Number(sourceValue[sourceIndex++] ?? 0);
         }
       }
     }
   };
-  function getTypeSize(type) {
-    if (typeof type === "string") {
-      return getLeafLayoutInfo(type).size;
-    }
-    if (Array.isArray(type)) {
-      const elementType = type[0];
-      const length = type[1];
-      if (Array.isArray(elementType)) {
-        throw new Error("Nested arrays are not supported");
-      }
-      return alignTo(getTypeSize(elementType), 4) * length;
-    }
-    let size = 0;
-    for (const memberType of Object.values(type)) {
-      const compositeMemberType = memberType;
-      size = alignTo(size, getTypeAlignment(compositeMemberType));
-      size += getTypeSize(compositeMemberType);
-    }
-    return alignTo(size, 4);
-  }
-  function getTypeAlignment(type) {
-    if (typeof type === "string") {
-      return getLeafLayoutInfo(type).alignment;
-    }
-    if (Array.isArray(type)) {
-      return 4;
-    }
-    return 4;
-  }
-  function getLeafLayoutInfo(type) {
-    const resolvedType = resolveVariableShaderTypeAlias(type);
-    const decodedType = getVariableShaderTypeInfo(resolvedType);
-    const matrixMatch = /^mat(\d)x(\d)<.+>$/.exec(resolvedType);
-    if (matrixMatch) {
-      const columns = Number(matrixMatch[1]);
-      const rows = Number(matrixMatch[2]);
-      return {
-        alignment: 4,
-        size: columns * 4,
-        components: columns * rows,
-        columns,
-        rows,
-        shaderType: resolvedType,
-        type: decodedType.type
-      };
-    }
-    const vectorMatch = /^vec(\d)<.+>$/.exec(resolvedType);
-    if (vectorMatch) {
-      const components = Number(vectorMatch[1]);
-      return {
-        alignment: components === 2 ? 2 : 4,
-        size: components === 3 ? 4 : components,
-        components,
-        columns: 1,
-        rows: components,
-        shaderType: resolvedType,
-        type: decodedType.type
-      };
-    }
-    return {
-      alignment: 1,
-      size: 1,
-      components: 1,
-      columns: 1,
-      rows: 1,
-      shaderType: resolvedType,
-      type: decodedType.type
-    };
-  }
-  function isCompositeShaderTypeStruct(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-  }
   function isCompositeUniformObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value) && !ArrayBuffer.isView(value);
   }
@@ -5438,26 +5562,33 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
   };
 
   // ../core/src/portable/uniform-store.ts
+  var minUniformBufferSize = 1024;
   var UniformStore = class {
+    /** Device used to infer layout and allocate buffers. */
+    device;
     /** Stores the uniform values for each uniform block */
     uniformBlocks = /* @__PURE__ */ new Map();
-    /** Can generate data for a uniform buffer for each block from data */
-    uniformBufferLayouts = /* @__PURE__ */ new Map();
+    /** Flattened layout metadata for each block. */
+    shaderBlockLayouts = /* @__PURE__ */ new Map();
+    /** Serializers for block-backed uniform data. */
+    shaderBlockWriters = /* @__PURE__ */ new Map();
     /** Actual buffer for the blocks */
     uniformBuffers = /* @__PURE__ */ new Map();
     /**
-     * Create a new UniformStore instance
-     * @param blocks
+     * Creates a new {@link UniformStore} for the supplied device and block definitions.
      */
-    constructor(blocks) {
+    constructor(device, blocks) {
+      this.device = device;
       for (const [bufferName, block] of Object.entries(blocks)) {
         const uniformBufferName = bufferName;
-        const uniformBufferLayout = new UniformBufferLayout(block.uniformTypes ?? {});
-        this.uniformBufferLayouts.set(uniformBufferName, uniformBufferLayout);
+        const shaderBlockLayout = makeShaderBlockLayout(block.uniformTypes ?? {}, {
+          layout: block.layout ?? getDefaultUniformBufferLayout(device)
+        });
+        const shaderBlockWriter = new ShaderBlockWriter(shaderBlockLayout);
+        this.shaderBlockLayouts.set(uniformBufferName, shaderBlockLayout);
+        this.shaderBlockWriters.set(uniformBufferName, shaderBlockWriter);
         const uniformBlock = new UniformBlock({ name: bufferName });
-        uniformBlock.setUniforms(
-          uniformBufferLayout.getFlatUniformValues(block.defaultUniforms || {})
-        );
+        uniformBlock.setUniforms(shaderBlockWriter.getFlatUniformValues(block.defaultUniforms || {}));
         this.uniformBlocks.set(uniformBufferName, uniformBlock);
       }
     }
@@ -5469,38 +5600,51 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
     }
     /**
      * Set uniforms
-     * Makes all properties partial
+     *
+     * Makes all group properties partial and eagerly propagates changes to any
+     * managed GPU buffers.
      */
     setUniforms(uniforms) {
       for (const [blockName, uniformValues] of Object.entries(uniforms)) {
         const uniformBufferName = blockName;
-        const uniformBufferLayout = this.uniformBufferLayouts.get(uniformBufferName);
-        const flattenedUniforms = uniformBufferLayout?.getFlatUniformValues(
+        const shaderBlockWriter = this.shaderBlockWriters.get(uniformBufferName);
+        const flattenedUniforms = shaderBlockWriter?.getFlatUniformValues(
           uniformValues || {}
         );
         this.uniformBlocks.get(uniformBufferName)?.setUniforms(flattenedUniforms || {});
       }
       this.updateUniformBuffers();
     }
-    /** Get the required minimum length of the uniform buffer */
+    /**
+     * Returns the allocation size for the named uniform buffer.
+     *
+     * This may exceed the packed layout size because minimum buffer-size policy is
+     * applied at the store layer.
+     */
     getUniformBufferByteLength(uniformBufferName) {
-      return this.uniformBufferLayouts.get(uniformBufferName)?.byteLength || 0;
+      const packedByteLength = this.shaderBlockLayouts.get(uniformBufferName)?.byteLength || 0;
+      return Math.max(packedByteLength, minUniformBufferSize);
     }
-    /** Get formatted binary memory that can be uploaded to a buffer */
+    /**
+     * Returns packed binary data that can be uploaded to the named uniform buffer.
+     *
+     * The returned view length matches the packed block size and is not padded to
+     * the store's minimum allocation size.
+     */
     getUniformBufferData(uniformBufferName) {
       const uniformValues = this.uniformBlocks.get(uniformBufferName)?.getAllUniforms() || {};
-      return this.uniformBufferLayouts.get(uniformBufferName)?.getData(uniformValues);
+      const shaderBlockWriter = this.shaderBlockWriters.get(uniformBufferName);
+      return shaderBlockWriter?.getData(uniformValues) || new Uint8Array(0);
     }
     /**
-     * Creates an unmanaged uniform buffer (umnanaged means that application is responsible for destroying it)
-     * The new buffer is initialized with current / supplied values
+     * Creates an unmanaged uniform buffer initialized with the current or supplied values.
      */
-    createUniformBuffer(device, uniformBufferName, uniforms) {
+    createUniformBuffer(uniformBufferName, uniforms) {
       if (uniforms) {
         this.setUniforms(uniforms);
       }
       const byteLength = this.getUniformBufferByteLength(uniformBufferName);
-      const uniformBuffer = device.createBuffer({
+      const uniformBuffer = this.device.createBuffer({
         usage: Buffer2.UNIFORM | Buffer2.COPY_DST,
         byteLength
       });
@@ -5508,11 +5652,11 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       uniformBuffer.write(uniformBufferData);
       return uniformBuffer;
     }
-    /** Get the managed uniform buffer. "managed" resources are destroyed when the uniformStore is destroyed. */
-    getManagedUniformBuffer(device, uniformBufferName) {
+    /** Returns the managed uniform buffer for the named block. */
+    getManagedUniformBuffer(uniformBufferName) {
       if (!this.uniformBuffers.get(uniformBufferName)) {
         const byteLength = this.getUniformBufferByteLength(uniformBufferName);
-        const uniformBuffer = device.createBuffer({
+        const uniformBuffer = this.device.createBuffer({
           usage: Buffer2.UNIFORM | Buffer2.COPY_DST,
           byteLength
         });
@@ -5520,7 +5664,11 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       }
       return this.uniformBuffers.get(uniformBufferName);
     }
-    /** Updates all uniform buffers where values have changed */
+    /**
+     * Updates every managed uniform buffer whose source uniforms have changed.
+     *
+     * @returns The first redraw reason encountered, or `false` if nothing changed.
+     */
     updateUniformBuffers() {
       let reason = false;
       for (const uniformBufferName of this.uniformBlocks.keys()) {
@@ -5532,7 +5680,11 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       }
       return reason;
     }
-    /** Update one uniform buffer. Only updates if values have changed */
+    /**
+     * Updates one managed uniform buffer if its corresponding block is dirty.
+     *
+     * @returns The redraw reason for the update, or `false` if no write occurred.
+     */
     updateUniformBuffer(uniformBufferName) {
       const uniformBlock = this.uniformBlocks.get(uniformBufferName);
       let uniformBuffer = this.uniformBuffers.get(uniformBufferName);
@@ -5553,6 +5705,9 @@ ${numberedLines}${positionIndicator}${message.type.toUpperCase()}: ${message.mes
       return reason;
     }
   };
+  function getDefaultUniformBufferLayout(device) {
+    return device.type === "webgpu" ? "wgsl-uniform" : "std140";
+  }
 
   // ../core/src/shadertypes/texture-types/texture-layout.ts
   function getTextureImageView(arrayBuffer2, memoryLayout, format, image = 0) {