@luma.gl/webgpu 9.0.0-alpha.29 → 9.0.0-alpha.30

package/dist/index.cjs

@@ -65,15 +65,15 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/adapter/webgpu-device.ts
-var import_api14 = require("@luma.gl/api");
+var import_core14 = require("@luma.gl/core");
 
 // src/adapter/resources/webgpu-buffer.ts
-var import_api = require("@luma.gl/api");
+var import_core = require("@luma.gl/core");
 function getByteLength(props) {
   var _a;
   return props.byteLength || ((_a = props.data) == null ? void 0 : _a.byteLength) || 0;
 }
-var WebGPUBuffer = class extends import_api.Buffer {
+var WebGPUBuffer = class extends import_core.Buffer {
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -108,7 +108,7 @@ var WebGPUBuffer = class extends import_api.Buffer {
   }
   readAsync() {
     return __async(this, arguments, function* (byteOffset = 0, byteLength = this.byteLength) {
-      const tempBuffer = new WebGPUBuffer(this.device, { usage: import_api.Buffer.MAP_READ | import_api.Buffer.COPY_DST, byteLength });
+      const tempBuffer = new WebGPUBuffer(this.device, { usage: import_core.Buffer.MAP_READ | import_core.Buffer.COPY_DST, byteLength });
       const commandEncoder = this.device.handle.createCommandEncoder();
       commandEncoder.copyBufferToBuffer(this.handle, byteOffset, tempBuffer.handle, 0, byteLength);
       this.device.handle.queue.submit([commandEncoder.finish()]);
@@ -136,7 +136,7 @@ var WebGPUBuffer = class extends import_api.Buffer {
 };
 
 // src/adapter/resources/webgpu-texture.ts
-var import_api3 = require("@luma.gl/api");
+var import_core3 = require("@luma.gl/core");
 
 // src/adapter/helpers/convert-texture-format.ts
 function getWebGPUTextureFormat(format) {
@@ -147,8 +147,8 @@ function getWebGPUTextureFormat(format) {
 }
 
 // src/adapter/resources/webgpu-sampler.ts
-var import_api2 = require("@luma.gl/api");
-var WebGPUSampler = class extends import_api2.Sampler {
+var import_core2 = require("@luma.gl/core");
+var WebGPUSampler = class extends import_core2.Sampler {
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -172,7 +172,7 @@ var BASE_DIMENSIONS = {
   "cube-array": "2d",
   "3d": "3d"
 };
-var WebGPUTexture = class extends import_api3.Texture {
+var WebGPUTexture = class extends import_core3.Texture {
   // static async createFromImageURL(src, usage = 0) {
   //   const img = document.createElement('img');
   //   img.src = src;
@@ -361,8 +361,8 @@ var WebGPUTexture = class extends import_api3.Texture {
 };
 
 // src/adapter/resources/webgpu-external-texture.ts
-var import_api4 = require("@luma.gl/api");
-var WebGPUExternalTexture = class extends import_api4.ExternalTexture {
+var import_core4 = require("@luma.gl/core");
+var WebGPUExternalTexture = class extends import_core4.ExternalTexture {
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -382,8 +382,8 @@ var WebGPUExternalTexture = class extends import_api4.ExternalTexture {
 };
 
 // src/adapter/resources/webgpu-shader.ts
-var import_api5 = require("@luma.gl/api");
-var WebGPUShader = class extends import_api5.Shader {
+var import_core5 = require("@luma.gl/core");
+var WebGPUShader = class extends import_core5.Shader {
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -397,7 +397,7 @@ var WebGPUShader = class extends import_api5.Shader {
       const error = yield errorScope;
       if (error) {
         const shaderLog = yield this.compilationInfo();
-        import_api5.log.error(`Shader compilation error: ${error.message}`, shaderLog)();
+        import_core5.log.error(`Shader compilation error: ${error.message}`, shaderLog)();
         throw new Error(`Shader compilation error: ${error.message}`);
       }
     });
@@ -433,7 +433,7 @@ var WebGPUShader = class extends import_api5.Shader {
 };
 
 // src/adapter/resources/webgpu-render-pipeline.ts
-var import_api8 = require("@luma.gl/api");
+var import_core8 = require("@luma.gl/core");
 
 // src/adapter/helpers/webgpu-parameters.ts
 function addDepthStencil(descriptor) {
@@ -621,7 +621,7 @@ function addColorState(descriptor) {
 }
 
 // src/adapter/helpers/get-bind-group.ts
-var import_api6 = require("@luma.gl/api");
+var import_core6 = require("@luma.gl/core");
 function getBindGroup(device, bindGroupLayout, layout, bindings) {
   const entries = getBindGroupEntries(bindings, layout);
   return device.createBindGroup({
@@ -632,7 +632,7 @@ function getBindGroup(device, bindGroupLayout, layout, bindings) {
 function getShaderLayoutBinding(layout, bindingName) {
   const bindingLayout = layout.bindings.find((binding) => binding.name === bindingName);
   if (!bindingLayout) {
-    import_api6.log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
+    import_core6.log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
   }
   return bindingLayout;
 }
@@ -647,30 +647,36 @@ function getBindGroupEntries(bindings, layout) {
   return entries;
 }
 function getBindGroupEntry(binding, index) {
-  if (binding instanceof import_api6.Buffer) {
+  if (binding instanceof import_core6.Buffer) {
     return {
       binding: index,
       resource: {
-        buffer: (0, import_api6.cast)(binding).handle
+        buffer: (0, import_core6.cast)(binding).handle
       }
     };
   }
-  if (binding instanceof import_api6.Sampler) {
+  if (binding instanceof import_core6.Sampler) {
     return {
       binding: index,
-      resource: (0, import_api6.cast)(binding).handle
+      resource: (0, import_core6.cast)(binding).handle
     };
-  } else if (binding instanceof import_api6.Texture) {
+  } else if (binding instanceof import_core6.Texture) {
     return {
       binding: index,
-      resource: (0, import_api6.cast)(binding).handle.createView()
+      resource: (0, import_core6.cast)(binding).handle.createView()
     };
   }
   throw new Error("invalid binding");
 }
 
 // src/adapter/helpers/get-vertex-buffer-layout.ts
-var import_api7 = require("@luma.gl/api");
+var import_core7 = require("@luma.gl/core");
+function getWebGPUVertexFormat(format) {
+  if (format.endsWith("-webgl")) {
+    throw new Error(`WebGPU does not support vertex format ${format}`);
+  }
+  return format;
+}
 function getVertexBufferLayout(layout, bufferMap) {
   const vertexBufferLayouts = [];
   const usedAttributes = /* @__PURE__ */ new Set();
@@ -684,18 +690,18 @@ function getVertexBufferLayout(layout, bufferMap) {
         const attributeLayout = findAttributeLayout(layout, interleaved.name, usedAttributes);
         stepMode = attributeLayout.stepMode || "vertex";
         vertexAttributes.push({
-          format: attributeLayout.format,
+          format: getWebGPUVertexFormat(attributeLayout.format),
           offset: byteOffset + byteStride,
           shaderLocation: attributeLayout.location
         });
-        byteStride += (0, import_api7.decodeVertexFormat)(attributeLayout.format).byteLength;
+        byteStride += (0, import_core7.decodeVertexFormat)(attributeLayout.format).byteLength;
       }
     } else {
       const attributeLayout = findAttributeLayout(layout, mapping.name, usedAttributes);
-      byteStride = (0, import_api7.decodeVertexFormat)(attributeLayout.format).byteLength;
+      byteStride = (0, import_core7.decodeVertexFormat)(attributeLayout.format).byteLength;
       stepMode = attributeLayout.stepMode || "vertex";
       vertexAttributes.push({
-        format: attributeLayout.format,
+        format: getWebGPUVertexFormat(attributeLayout.format),
         offset: byteOffset,
         shaderLocation: attributeLayout.location
       });
@@ -709,10 +715,10 @@ function getVertexBufferLayout(layout, bufferMap) {
   for (const attribute of layout.attributes) {
     if (!usedAttributes.has(attribute.name)) {
       vertexBufferLayouts.push({
-        arrayStride: (0, import_api7.decodeVertexFormat)(attribute.format).byteLength,
+        arrayStride: (0, import_core7.decodeVertexFormat)(attribute.format).byteLength,
         stepMode: attribute.stepMode || "vertex",
         attributes: [{
-          format: attribute.format,
+          format: getWebGPUVertexFormat(attribute.format),
           offset: 0,
           shaderLocation: attribute.location
         }]
@@ -755,7 +761,7 @@ function findAttributeLayout(layout, name, attributeNames) {
 }
 
 // src/adapter/resources/webgpu-render-pipeline.ts
-var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
+var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
   constructor(device, props) {
     super(device, props);
     this.fs = null;
@@ -764,8 +770,8 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
     this.device = device;
     this.handle = this.props.handle || this.createHandle();
     this.handle.label = this.props.id;
-    this.vs = (0, import_api8.cast)(props.vs);
-    this.fs = (0, import_api8.cast)(props.fs);
+    this.vs = (0, import_core8.cast)(props.vs);
+    this.fs = (0, import_core8.cast)(props.fs);
     this._bufferSlots = getBufferSlots(this.props.layout, this.props.bufferMap);
     this._buffers = new Array(Object.keys(this._bufferSlots).length).fill(null);
     this._bindGroupLayout = this.handle.getBindGroupLayout(0);
@@ -773,15 +779,15 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
   createHandle() {
     const descriptor = this._getRenderPipelineDescriptor();
     const renderPipeline = this.device.handle.createRenderPipeline(descriptor);
-    import_api8.log.groupCollapsed(1, `new WebGPRenderPipeline(${this.id})`)();
-    import_api8.log.log(1, JSON.stringify(descriptor, null, 2))();
-    import_api8.log.groupEnd(1)();
+    import_core8.log.groupCollapsed(1, `new WebGPRenderPipeline(${this.id})`)();
+    import_core8.log.log(1, JSON.stringify(descriptor, null, 2))();
+    import_core8.log.groupEnd(1)();
     return renderPipeline;
   }
   destroy() {
   }
   setIndexBuffer(indexBuffer) {
-    this._indexBuffer = (0, import_api8.cast)(indexBuffer);
+    this._indexBuffer = (0, import_core8.cast)(indexBuffer);
   }
   setAttributes(attributes) {
     for (const [name, buffer] of Object.entries(attributes)) {
@@ -801,7 +807,7 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
   }
   /** Set the bindings */
   setBindings(bindings) {
-    if (!(0, import_api8.isObjectEmpty)(this.props.bindings)) {
+    if (!(0, import_core8.isObjectEmpty)(this.props.bindings)) {
       Object.assign(this.props.bindings, bindings);
       this._bindGroup = getBindGroup(
         this.device.handle,
@@ -812,7 +818,7 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
     }
   }
   setUniforms(uniforms) {
-    if (!(0, import_api8.isObjectEmpty)(uniforms)) {
+    if (!(0, import_core8.isObjectEmpty)(uniforms)) {
       throw new Error("WebGPU does not support uniforms");
     }
   }
@@ -827,14 +833,14 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
   _getRenderPipelineDescriptor() {
     var _a, _b;
     const vertex = {
-      module: (0, import_api8.cast)(this.props.vs).handle,
+      module: (0, import_core8.cast)(this.props.vs).handle,
       entryPoint: this.props.vsEntryPoint || "main",
       buffers: getVertexBufferLayout(this.props.layout, this.props.bufferMap)
     };
     let fragment;
     if (this.props.fs) {
       fragment = {
-        module: (0, import_api8.cast)(this.props.fs).handle,
+        module: (0, import_core8.cast)(this.props.fs).handle,
         entryPoint: this.props.fsEntryPoint || "main",
         targets: [
           {
@@ -845,8 +851,8 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
       };
     }
     switch (this.props.topology) {
-      case "triangle-fan":
-      case "line-loop":
+      case "triangle-fan-webgl":
+      case "line-loop-webgl":
         throw new Error(`WebGPU does not support primitive topology ${this.props.topology}`);
       default:
     }
@@ -862,7 +868,7 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
     return descriptor;
   }
   draw(options) {
-    const webgpuRenderPass = (0, import_api8.cast)(options.renderPass) || this.device.getDefaultRenderPass();
+    const webgpuRenderPass = (0, import_core8.cast)(options.renderPass) || this.device.getDefaultRenderPass();
     webgpuRenderPass.handle.setPipeline(this.handle);
     const bindGroup = this._getBindGroup();
     if (bindGroup) {
@@ -892,7 +898,7 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
     }
     const buffers = this._getBuffers();
     for (let i = 0; i < buffers.length; ++i) {
-      const buffer = (0, import_api8.cast)(buffers[i]);
+      const buffer = (0, import_core8.cast)(buffers[i]);
       if (!buffer) {
         const attribute = this.props.layout.attributes.find(
           (attribute2) => attribute2.location === i
@@ -907,12 +913,12 @@ var WebGPURenderPipeline = class extends import_api8.RenderPipeline {
 };
 
 // src/adapter/resources/webgpu-compute-pipeline.ts
-var import_api9 = require("@luma.gl/api");
-var WebGPUComputePipeline = class extends import_api9.ComputePipeline {
+var import_core9 = require("@luma.gl/core");
+var WebGPUComputePipeline = class extends import_core9.ComputePipeline {
   constructor(device, props) {
     super(device, props);
     this.device = device;
-    const module2 = (0, import_api9.cast)(this.props.cs).handle;
+    const module2 = (0, import_core9.cast)(this.props.cs).handle;
     this.handle = this.props.handle || this.device.handle.createComputePipeline({
       label: this.props.id,
       compute: {
@@ -930,8 +936,8 @@ var WebGPUComputePipeline = class extends import_api9.ComputePipeline {
 };
 
 // src/adapter/resources/webgpu-render-pass.ts
-var import_api10 = require("@luma.gl/api");
-var WebGPURenderPass = class extends import_api10.RenderPass {
+var import_core10 = require("@luma.gl/core");
+var WebGPURenderPass = class extends import_core10.RenderPass {
   constructor(device, props = {}) {
     super(device, props);
     /** Active pipeline */
@@ -948,7 +954,7 @@ var WebGPURenderPass = class extends import_api10.RenderPass {
     this.handle.end();
   }
   setPipeline(pipeline) {
-    this.pipeline = (0, import_api10.cast)(pipeline);
+    this.pipeline = (0, import_core10.cast)(pipeline);
     this.handle.setPipeline(this.pipeline.handle);
   }
   /** Sets an array of bindings (uniform buffers, samplers, textures, ...) */
@@ -961,10 +967,10 @@ var WebGPURenderPass = class extends import_api10.RenderPass {
     }
   }
   setIndexBuffer(buffer, indexFormat, offset = 0, size) {
-    this.handle.setIndexBuffer((0, import_api10.cast)(buffer).handle, indexFormat, offset, size);
+    this.handle.setIndexBuffer((0, import_core10.cast)(buffer).handle, indexFormat, offset, size);
   }
   setVertexBuffer(slot, buffer, offset = 0) {
-    this.handle.setVertexBuffer(slot, (0, import_api10.cast)(buffer).handle, offset);
+    this.handle.setVertexBuffer(slot, (0, import_core10.cast)(buffer).handle, offset);
   }
   draw(options) {
     if (options.indexCount) {
@@ -1050,8 +1056,8 @@ var WebGPURenderPass = class extends import_api10.RenderPass {
 };
 
 // src/adapter/resources/webgpu-compute-pass.ts
-var import_api11 = require("@luma.gl/api");
-var WebGPUComputePass = class extends import_api11.ComputePass {
+var import_core11 = require("@luma.gl/core");
+var WebGPUComputePass = class extends import_core11.ComputePass {
   constructor(device, props) {
     var _a;
     super(device, props);
@@ -1069,7 +1075,7 @@ var WebGPUComputePass = class extends import_api11.ComputePass {
     this.handle.end();
   }
   setPipeline(pipeline) {
-    const wgpuPipeline = (0, import_api11.cast)(pipeline);
+    const wgpuPipeline = (0, import_core11.cast)(pipeline);
     this.handle.setPipeline(wgpuPipeline.handle);
     this._bindGroupLayout = wgpuPipeline._getBindGroupLayout();
   }
@@ -1092,7 +1098,7 @@ var WebGPUComputePass = class extends import_api11.ComputePass {
    * @param indirectOffset
    */
   dispatchIndirect(indirectBuffer, indirectOffset = 0) {
-    this.handle.dispatchWorkgroupsIndirect((0, import_api11.cast)(indirectBuffer).handle, indirectOffset);
+    this.handle.dispatchWorkgroupsIndirect((0, import_core11.cast)(indirectBuffer).handle, indirectOffset);
   }
   pushDebugGroup(groupLabel) {
     this.handle.pushDebugGroup(groupLabel);
@@ -1109,11 +1115,11 @@ var WebGPUComputePass = class extends import_api11.ComputePass {
 };
 
 // src/adapter/webgpu-canvas-context.ts
-var import_api13 = require("@luma.gl/api");
+var import_core13 = require("@luma.gl/core");
 
 // src/adapter/resources/webgpu-framebuffer.ts
-var import_api12 = require("@luma.gl/api");
-var WebGPUFramebuffer = class extends import_api12.Framebuffer {
+var import_core12 = require("@luma.gl/core");
+var WebGPUFramebuffer = class extends import_core12.Framebuffer {
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -1122,7 +1128,7 @@ var WebGPUFramebuffer = class extends import_api12.Framebuffer {
 };
 
 // src/adapter/webgpu-canvas-context.ts
-var WebGPUCanvasContext = class extends import_api13.CanvasContext {
+var WebGPUCanvasContext = class extends import_core13.CanvasContext {
   constructor(device, adapter, props) {
     super(props);
     this.depthStencilFormat = "depth24plus";
@@ -1172,7 +1178,7 @@ var WebGPUCanvasContext = class extends import_api13.CanvasContext {
         colorSpace: this.props.colorSpace,
         alphaMode: this.props.alphaMode
       });
-      import_api13.log.log(1, `Resized to ${this.width}x${this.height}px`)();
+      import_core13.log.log(1, `Resized to ${this.width}x${this.height}px`)();
     }
   }
   resize(options) {
@@ -1194,9 +1200,9 @@ var WebGPUCanvasContext = class extends import_api13.CanvasContext {
 };
 
 // src/adapter/webgpu-device.ts
-var _WebGPUDevice = class extends import_api14.Device {
+var _WebGPUDevice = class extends import_core14.Device {
   constructor(device, adapter, props) {
-    super(__spreadProps(__spreadValues({}, props), { id: props.id || (0, import_api14.uid)("webgpu-device") }));
+    super(__spreadProps(__spreadValues({}, props), { id: props.id || (0, import_core14.uid)("webgpu-device") }));
     this.canvasContext = null;
     this.commandEncoder = null;
     this.renderPass = null;
@@ -1239,7 +1245,7 @@ var _WebGPUDevice = class extends import_api14.Device {
           "WebGPU not available. Open in Chrome Canary and turn on chrome://flags/#enable-unsafe-webgpu"
         );
       }
-      import_api14.log.groupCollapsed(1, "WebGPUDevice created")();
+      import_core14.log.groupCollapsed(1, "WebGPUDevice created")();
       const adapter = yield navigator.gpu.requestAdapter({
         powerPreference: "high-performance"
         // forceSoftware: false
@@ -1248,21 +1254,21 @@ var _WebGPUDevice = class extends import_api14.Device {
         throw new Error("Failed to request WebGPU adapter");
       }
       const adapterInfo = yield adapter.requestAdapterInfo();
-      import_api14.log.probe(1, "Adapter available", adapterInfo)();
+      import_core14.log.probe(1, "Adapter available", adapterInfo)();
       const gpuDevice = yield adapter.requestDevice({
         requiredFeatures: adapter.features
         // TODO ensure we obtain best limits
         // requiredLimits: adapter.limits
       });
-      import_api14.log.probe(1, "GPUDevice available")();
+      import_core14.log.probe(1, "GPUDevice available")();
       if (typeof props.canvas === "string") {
-        yield import_api14.CanvasContext.pageLoaded;
-        import_api14.log.probe(1, "DOM is loaded")();
+        yield import_core14.CanvasContext.pageLoaded;
+        import_core14.log.probe(1, "DOM is loaded")();
       }
       const device = new _WebGPUDevice(gpuDevice, adapter, props);
-      import_api14.log.probe(1, "Device created", device.info)();
-      import_api14.log.table(1, device.info)();
-      import_api14.log.groupEnd(1)();
+      import_core14.log.probe(1, "Device created", device.info)();
+      import_core14.log.table(1, device.info)();
+      import_core14.log.groupEnd(1)();
       return device;
     });
   }