@luma.gl/webgpu 9.3.0-alpha.2 → 9.3.0-alpha.4

package/dist/index.cjs

@@ -7,8 +7,8 @@ var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
 var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -30,13 +30,15 @@ var init_webgpu_buffer = __esm({
       device;
       handle;
       byteLength;
+      paddedByteLength;
       constructor(device, props) {
         var _a, _b;
         super(device, props);
         this.device = device;
         this.byteLength = props.byteLength || ((_a = props.data) == null ? void 0 : _a.byteLength) || 0;
+        this.paddedByteLength = Math.ceil(this.byteLength / 4) * 4;
         const mappedAtCreation = Boolean(this.props.onMapped || props.data);
-        const size = Math.ceil(this.byteLength / 4) * 4;
+        const size = this.paddedByteLength;
         this.device.pushErrorScope("out-of-memory");
         this.device.pushErrorScope("validation");
         this.handle = this.props.handle || this.device.handle.createBuffer({
@@ -89,18 +91,21 @@ var init_webgpu_buffer = __esm({
         });
       }
       async mapAndWriteAsync(callback, byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+        const alignedByteLength = Math.ceil(byteLength / 4) * 4;
         const isMappable = (this.usage & import_core.Buffer.MAP_WRITE) !== 0;
-        const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_WRITE | import_core.Buffer.COPY_SRC, 0, this.byteLength) : null;
+        const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_WRITE | import_core.Buffer.COPY_SRC, 0, this.paddedByteLength) : null;
         const writeBuffer = mappableBuffer || this;
         this.device.pushErrorScope("validation");
         try {
           await this.device.handle.queue.onSubmittedWorkDone();
-          await writeBuffer.handle.mapAsync(GPUMapMode.WRITE, byteOffset, byteLength);
-          const arrayBuffer = writeBuffer.handle.getMappedRange(byteOffset, byteLength);
+          await writeBuffer.handle.mapAsync(GPUMapMode.WRITE, byteOffset, alignedByteLength);
+          const mappedRange = writeBuffer.handle.getMappedRange(byteOffset, alignedByteLength);
+          const arrayBuffer = mappedRange.slice(0, byteLength);
           await callback(arrayBuffer, "mapped");
+          new Uint8Array(mappedRange).set(new Uint8Array(arrayBuffer), 0);
           writeBuffer.handle.unmap();
           if (mappableBuffer) {
-            this._copyBuffer(mappableBuffer, byteOffset, byteLength);
+            this._copyBuffer(mappableBuffer, byteOffset, alignedByteLength);
           }
         } finally {
           this.device.popErrorScope((error) => {
@@ -114,24 +119,37 @@ var init_webgpu_buffer = __esm({
         return this.mapAndReadAsync((arrayBuffer) => new Uint8Array(arrayBuffer.slice(0)), byteOffset, byteLength);
       }
       async mapAndReadAsync(callback, byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+        const requestedEnd = byteOffset + byteLength;
+        if (requestedEnd > this.byteLength) {
+          throw new Error("Mapping range exceeds buffer size");
+        }
+        let mappedByteOffset = byteOffset;
+        let mappedByteLength = byteLength;
+        let sliceByteOffset = 0;
+        let lifetime = "mapped";
         if (byteOffset % 8 !== 0 || byteLength % 4 !== 0) {
-          throw new Error("byteOffset must be multiple of 8 and byteLength multiple of 4");
+          mappedByteOffset = Math.floor(byteOffset / 8) * 8;
+          const alignedEnd = Math.ceil(requestedEnd / 4) * 4;
+          mappedByteLength = alignedEnd - mappedByteOffset;
+          sliceByteOffset = byteOffset - mappedByteOffset;
+          lifetime = "copied";
         }
-        if (byteOffset + byteLength > this.handle.size) {
+        if (mappedByteOffset + mappedByteLength > this.paddedByteLength) {
           throw new Error("Mapping range exceeds buffer size");
         }
         const isMappable = (this.usage & import_core.Buffer.MAP_READ) !== 0;
-        const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST, 0, this.byteLength) : null;
+        const mappableBuffer = !isMappable ? this._getMappableBuffer(import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST, 0, this.paddedByteLength) : null;
         const readBuffer = mappableBuffer || this;
         this.device.pushErrorScope("validation");
         try {
           await this.device.handle.queue.onSubmittedWorkDone();
           if (mappableBuffer) {
-            mappableBuffer._copyBuffer(this);
+            mappableBuffer._copyBuffer(this, mappedByteOffset, mappedByteLength);
           }
-          await readBuffer.handle.mapAsync(GPUMapMode.READ, byteOffset, byteLength);
-          const arrayBuffer = readBuffer.handle.getMappedRange(byteOffset, byteLength);
-          const result = await callback(arrayBuffer, "mapped");
+          await readBuffer.handle.mapAsync(GPUMapMode.READ, mappedByteOffset, mappedByteLength);
+          const arrayBuffer = readBuffer.handle.getMappedRange(mappedByteOffset, mappedByteLength);
+          const mappedRange = lifetime === "mapped" ? arrayBuffer : arrayBuffer.slice(sliceByteOffset, sliceByteOffset + byteLength);
+          const result = await callback(mappedRange, lifetime);
           readBuffer.handle.unmap();
           return result;
         } finally {
@@ -824,7 +842,7 @@ function getBindGroupEntries(bindings, shaderLayout) {
   for (const [bindingName, value] of Object.entries(bindings)) {
     let bindingLayout = getShaderLayoutBinding(shaderLayout, bindingName);
     if (bindingLayout) {
-      const entry = getBindGroupEntry(value, bindingLayout.location);
+      const entry = getBindGroupEntry(value, bindingLayout.location, void 0, bindingName);
       if (entry) {
         entries.push(entry);
       }
@@ -834,7 +852,7 @@ function getBindGroupEntries(bindings, shaderLayout) {
         ignoreWarnings: true
       });
       if (bindingLayout) {
-        const entry = getBindGroupEntry(value, bindingLayout.location, { sampler: true });
+        const entry = getBindGroupEntry(value, bindingLayout.location, { sampler: true }, bindingName);
         if (entry) {
           entries.push(entry);
         }
@@ -843,7 +861,7 @@ function getBindGroupEntries(bindings, shaderLayout) {
   }
   return entries;
 }
-function getBindGroupEntry(binding, index, options) {
+function getBindGroupEntry(binding, index, options, bindingName = "unknown") {
   if (binding instanceof import_core8.Buffer) {
     return {
       binding: index,
@@ -858,6 +876,12 @@ function getBindGroupEntry(binding, index, options) {
       resource: binding.handle
     };
   }
+  if (binding instanceof import_core8.TextureView) {
+    return {
+      binding: index,
+      resource: binding.handle
+    };
+  }
   if (binding instanceof import_core8.Texture) {
     if (options == null ? void 0 : options.sampler) {
       return {
@@ -870,7 +894,7 @@ function getBindGroupEntry(binding, index, options) {
       resource: binding.view.handle
     };
   }
-  import_core8.log.warn(`invalid binding ${name}`, binding);
+  import_core8.log.warn(`invalid binding ${bindingName}`, binding);
   return null;
 }
 var import_core8;
@@ -952,17 +976,17 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
   });
   return vertexBufferLayouts;
 }
-function findAttributeLayout(shaderLayout, name2, attributeNames) {
-  const attribute = shaderLayout.attributes.find((attribute_) => attribute_.name === name2);
+function findAttributeLayout(shaderLayout, name, attributeNames) {
+  const attribute = shaderLayout.attributes.find((attribute_) => attribute_.name === name);
   if (!attribute) {
-    import_core9.log.warn(`Supplied attribute not present in shader layout: ${name2}`)();
+    import_core9.log.warn(`Supplied attribute not present in shader layout: ${name}`)();
     return null;
   }
   if (attributeNames) {
-    if (attributeNames.has(name2)) {
-      throw new Error(`Found multiple entries for attribute: ${name2}`);
+    if (attributeNames.has(name)) {
+      throw new Error(`Found multiple entries for attribute: ${name}`);
     }
-    attributeNames.add(name2);
+    attributeNames.add(name);
   }
   return attribute;
 }
@@ -1026,8 +1050,8 @@ var init_webgpu_render_pipeline = __esm({
        * @todo Do we want to expose BindGroups in the API and remove this?
        */
       setBindings(bindings) {
-        for (const [name2, binding] of Object.entries(bindings)) {
-          if (this._bindings[name2] !== binding) {
+        for (const [name, binding] of Object.entries(bindings)) {
+          if (this._bindings[name] !== binding) {
             this._bindGroup = null;
           }
         }
@@ -1763,8 +1787,7 @@ var init_webgpu_pipeline_layout = __esm({
       }
       mapShaderLayoutToBindGroupEntries() {
         const bindGroupEntries = [];
-        for (let i = 0; i < this.props.shaderLayout.bindings.length; i++) {
-          const binding = this.props.shaderLayout.bindings[i];
+        for (const binding of this.props.shaderLayout.bindings) {
           const bindingTypeInfo = {};
           switch (binding.type) {
             case "uniform": {