@luma.gl/core 9.3.0-alpha.8 → 9.3.0

package/dist/index.cjs

@@ -47,13 +47,13 @@ __export(dist_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,
@@ -74,6 +74,7 @@ __export(dist_exports, {
   isExternalImage: () => isExternalImage,
   log: () => log,
   luma: () => luma,
+  makeShaderBlockLayout: () => makeShaderBlockLayout,
   normalizeBindingsByGroup: () => normalizeBindingsByGroup,
   readPixel: () => readPixel,
   setTextureImageData: () => setTextureImageData,
@@ -731,12 +732,51 @@ var VertexFormatDecoder = class {
         }
         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}`);
@@ -1427,7 +1467,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");
   }
   /**
@@ -1652,7 +1692,7 @@ var _Luma = class {
   VERSION = (
     // Version detection using build plugin
     // @ts-expect-error no-undef
-    true ? "9.3.0-alpha.8" : "running from source"
+    true ? "9.3.0" : "running from source"
   );
   spector;
   preregisteredAdapters = /* @__PURE__ */ new Map();
@@ -3608,9 +3648,10 @@ var BindGroupFactory = class {
     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);
+          resolvedBindGroups[group] = this._getEmptyBindGroup(bindGroupLayout, pipeline.shaderLayout, group, bindGroupLabel);
         }
         continue;
       }
@@ -3621,11 +3662,11 @@ var BindGroupFactory = class {
           resolvedBindGroups[group] = layoutCache.bindGroupsBySource.get(bindGroupCacheKey) || null;
           continue;
         }
-        const bindGroup = this.device._createBindGroupWebGPU(bindGroupLayout, pipeline.shaderLayout, groupBindings, group);
+        const bindGroup = this.device._createBindGroupWebGPU(bindGroupLayout, pipeline.shaderLayout, groupBindings, group, bindGroupLabel);
         layoutCache.bindGroupsBySource.set(bindGroupCacheKey, bindGroup);
         resolvedBindGroups[group] = bindGroup;
       } else {
-        resolvedBindGroups[group] = this.device._createBindGroupWebGPU(bindGroupLayout, pipeline.shaderLayout, groupBindings, group);
+        resolvedBindGroups[group] = this.device._createBindGroupWebGPU(bindGroupLayout, pipeline.shaderLayout, groupBindings, group, bindGroupLabel);
       }
     }
     return resolvedBindGroups;
@@ -3639,9 +3680,9 @@ var BindGroupFactory = class {
     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) {
@@ -3664,6 +3705,11 @@ function getBindGroupIndicesUpToMax(bindings) {
 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}]`;
+}
 
 // dist/adapter/resources/render-pass.js
 var _RenderPass = class extends Resource {
@@ -4257,6 +4303,160 @@ var NORMALIZED_TYPE_MAP2 = {
   sint32: ["sint32", "i32", 4, false, Int32Array]
 };
 
+// dist/shadertypes/shader-types/shader-block-layout.js
+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";
+}
+
 // dist/utils/array-utils-flat.js
 var arrayBuffer;
 function getScratchArrayBuffer(byteLength) {
@@ -4281,49 +4481,56 @@ function isNumberArray(value) {
   return isTypedArray(value);
 }
 
-// dist/portable/uniform-buffer-layout.js
-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 */
+// dist/portable/shader-block-writer.js
+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),
@@ -4334,46 +4541,16 @@ var UniformBufferLayout = class {
     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;
     }
@@ -4412,9 +4589,12 @@ var UniformBufferLayout = class {
     }
     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;
@@ -4428,13 +4608,16 @@ var UniformBufferLayout = class {
       }
     }
   }
+  /**
+   * 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);
@@ -4449,85 +4632,13 @@ var UniformBufferLayout = class {
     }
     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);
 }
@@ -4619,24 +4730,33 @@ var UniformBlock = class {
 };
 
 // dist/portable/uniform-store.js
+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);
     }
   }
@@ -4648,39 +4768,52 @@ var UniformStore = class {
   }
   /**
    * Set uniforms
-   * Makes all properties partial
+   *
+   * Makes all group properties partial and eagerly propagates changes to any
+   * managed GPU buffers.
    */
   setUniforms(uniforms) {
     var _a;
     for (const [blockName, uniformValues] of Object.entries(uniforms)) {
       const uniformBufferName = blockName;
-      const uniformBufferLayout = this.uniformBufferLayouts.get(uniformBufferName);
-      const flattenedUniforms = uniformBufferLayout == null ? void 0 : uniformBufferLayout.getFlatUniformValues(uniformValues || {});
+      const shaderBlockWriter = this.shaderBlockWriters.get(uniformBufferName);
+      const flattenedUniforms = shaderBlockWriter == null ? void 0 : shaderBlockWriter.getFlatUniformValues(uniformValues || {});
       (_a = this.uniformBlocks.get(uniformBufferName)) == null ? void 0 : _a.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) {
     var _a;
-    return ((_a = this.uniformBufferLayouts.get(uniformBufferName)) == null ? void 0 : _a.byteLength) || 0;
+    const packedByteLength = ((_a = this.shaderBlockLayouts.get(uniformBufferName)) == null ? void 0 : _a.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) {
-    var _a, _b;
+    var _a;
     const uniformValues = ((_a = this.uniformBlocks.get(uniformBufferName)) == null ? void 0 : _a.getAllUniforms()) || {};
-    return (_b = this.uniformBufferLayouts.get(uniformBufferName)) == null ? void 0 : _b.getData(uniformValues);
+    const shaderBlockWriter = this.shaderBlockWriters.get(uniformBufferName);
+    return (shaderBlockWriter == null ? void 0 : 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
     });
@@ -4688,11 +4821,11 @@ var UniformStore = class {
     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
       });
@@ -4700,7 +4833,11 @@ var UniformStore = class {
     }
     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()) {
@@ -4712,7 +4849,11 @@ var UniformStore = class {
     }
     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) {
     var _a;
     const uniformBlock = this.uniformBlocks.get(uniformBufferName);
@@ -4729,6 +4870,9 @@ var UniformStore = class {
     return reason;
   }
 };
+function getDefaultUniformBufferLayout(device) {
+  return device.type === "webgpu" ? "wgsl-uniform" : "std140";
+}
 
 // dist/shadertypes/texture-types/texture-layout.js
 function getTextureImageView(arrayBuffer2, memoryLayout, format, image = 0) {