@luma.gl/webgpu 9.0.0-alpha.15 → 9.0.0-alpha.16

package/dist/adapter/helpers/accessor-to-format.js

@@ -1,2 +1,101 @@
+/*
+import {assert} from '@luma.gl/api';
+import GL from '@luma.gl/constants';
 
-//# sourceMappingURL=accessor-to-format.js.map
+type Accessor = Record<string, any>;
+
+const FORMAT_TO_ACCESSOR: Record<GPUVertexFormat, Accessor> = {
+  uchar2: {type: 'uchar', size: 2},
+  uchar4: {type: 'uchar', size: 4},
+  char2: {type: 'char', size: 2},
+  char4: {type: 'char', size: 4},
+  uchar2norm: {type: 'uchar', size: 2, normalized: true},
+  uchar4norm: {type: 'uchar', size: 4, normalized: true},
+  char2norm: {type: 'char', size: 2, normalized: true},
+  char4norm: {type: 'char', size: 4, normalized: true},
+  ushort2: {type: 'ushort', size: 2},
+  ushort4: {type: 'ushort', size: 4},
+  short2: {type: 'short', size: 2},
+  short4: {type: 'short', size: 4},
+  ushort2norm: {type: 'ushort', size: 2, normalized: true},
+  ushort4norm: {type: 'ushort', size: 4, normalized: true},
+  short2norm: {type: 'short', size: 1, normalized: true},
+  short4norm: {type: 'short', size: 1, normalized: true},
+  half2: {type: 'half', size: 2},
+  half4: {type: 'half', size: 4},
+  float: {type: 'float', size: 1},
+  float2: {type: 'float', size: 2},
+  float3: {type: 'float', size: 3},
+  float4: {type: 'float', size: 4},
+  uint: {type: 'uint', size: 1, integer: true},
+  uint2: {type: 'uint', size: 2, integer: true},
+  uint3: {type: 'uint', size: 3, integer: true},
+  uint4: {type: 'uint', size: 4, integer: true},
+  int: {type: 'int', size: 1, integer: true},
+  int2: {type: 'int', size: 2, integer: true},
+  int3: {type: 'int', size: 3, integer: true},
+  int4: {type: 'int', size: 4, integer: true}
+};
+
+/**
+ * Convert from WebGPU attribute format strings to accessor {type, size, normalized, integer}
+ * @param {*} format
+ *
+export function mapWebGPUFormatToAccessor(format) {
+  const accessorDefinition = FORMAT_TO_ACCESSOR[format];
+  assert(accessorDefinition, 'invalid attribute format');
+  return Object.freeze(accessorDefinition);
+}
+
+/**
+ * Convert from accessor {type, size, normalized, integer} to WebGPU attribute format strings
+ * @param {*} format
+ *
+export function mapAccessorToWebGPUFormat(accessor) {
+  const {type = GL.FLOAT, size = 1, normalized = false, integer = false} = accessor;
+  assert(size >=1 && size <=4);
+  // `norm` suffix (uchar4norm)
+  const norm = normalized ? 'norm' : '';
+  // size 1 is ommitted in format names (float vs float2)
+  const count = size === 1 ? '' : size;
+  switch (type) {
+    case GL.UNSIGNED_BYTE:
+      switch (size) {
+        case 2:
+        case 4:
+          return `uchar${count}${norm}`;
+      }
+    case GL.BYTE:
+      switch (size) {
+        case 2:
+        case 4:
+          return `char${count}${norm}`;
+      }
+    case GL.UNSIGNED_SHORT:
+      switch (size) {
+        case 2:
+        case 4:
+          return `ushort${count}${norm}`;
+      }
+    case GL.SHORT:
+      switch (size) {
+        case 2:
+        case 4:
+          return `short${count}${norm}`;
+      }
+    case GL.HALF_FLOAT:
+      switch (size) {
+        case 2:
+        case 4:
+          return `half${count}`;
+      }
+    case GL.FLOAT:
+      return `float${count}`;
+    case GL.UNSIGNED_INT:
+      return `uint${count}`;
+    case GL.INT:
+      return `int${count}`;
+  }
+  throw new Error('illegal accessor');
+}
+*/ 

package/dist/adapter/helpers/convert-texture-format.js

@@ -1,8 +1,7 @@
+/** Ensure a texture format is WebGPU compatible */
 export function getWebGPUTextureFormat(format) {
-  if (format.includes('webgl')) {
-    throw new Error('webgl-only format');
-  }
-
-  return format;
+    if (format.includes('webgl')) {
+        throw new Error('webgl-only format');
+    }
+    return format;
 }
-//# sourceMappingURL=convert-texture-format.js.map

package/dist/adapter/helpers/generate-mipmaps.js

@@ -1,95 +1,91 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-const VS_GEN_MIPMAP = "#version 450\nconst vec2 pos[4] = vec2[4](vec2(-1.0f, 1.0f), vec2(1.0f, 1.0f), vec2(-1.0f, -1.0f), vec2(1.0f, -1.0f));\nlayout(location = 0) out vec2 vTex;\nvoid main() {\n  gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);\n  vTex = gl_Position / 2.0f + vec2(0.5f);\n}";
-const FS_GEN_MIPMAP = "#version 450\nlayout(set = 0, binding = 0) uniform sampler imgSampler;\nlayout(set = 0, binding = 1) uniform texture2D img;\nlayout(location = 0) in vec2 vTex;\nlayout(location = 0) out vec4 outColor;\nvoid main() {\n  outColor = texture(sampler2D(img, imgSampler), vTex);\n}";
+// luma.gl, MIT license
+// Forked from Kangz/mipmapper.js under MIT license Copyright 2020 Brandon Jones
+// https://gist.github.com/Kangz/782d5f1ae502daf53910a13f55db2f83
+// @ts-nocheck this is written against outdated WebGPU API, needs an update pass
+const VS_GEN_MIPMAP = `\#version 450
+const vec2 pos[4] = vec2[4](vec2(-1.0f, 1.0f), vec2(1.0f, 1.0f), vec2(-1.0f, -1.0f), vec2(1.0f, -1.0f));
+layout(location = 0) out vec2 vTex;
+void main() {
+  gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);
+  vTex = gl_Position / 2.0f + vec2(0.5f);
+}`;
+const FS_GEN_MIPMAP = `#version 450
+layout(set = 0, binding = 0) uniform sampler imgSampler;
+layout(set = 0, binding = 1) uniform texture2D img;
+layout(location = 0) in vec2 vTex;
+layout(location = 0) out vec4 outColor;
+void main() {
+  outColor = texture(sampler2D(img, imgSampler), vTex);
+}`;
+/** WebGPU does not have built-in mipmap creation */
 export class WebGPUMipmapGenerator {
-  constructor(device, glslang) {
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "mipmapSampler", void 0);
-
-    _defineProperty(this, "mipmapPipeline", void 0);
-
-    this.device = device;
-    this.mipmapSampler = device.createSampler({
-      minFilter: 'linear'
-    });
-    this.mipmapPipeline = device.createRenderPipeline({
-      vertexStage: {
-        module: device.createShaderModule({
-          code: glslang.compileGLSL(VS_GEN_MIPMAP, 'vertex')
-        }),
-        entryPoint: 'main'
-      },
-      fragmentStage: {
-        module: device.createShaderModule({
-          code: glslang.compileGLSL(FS_GEN_MIPMAP, 'fragment')
-        }),
-        entryPoint: 'main'
-      },
-      primitiveTopology: 'triangle-strip',
-      colorStates: [{
-        format: 'rgba8unorm'
-      }]
-    });
-  }
-
-  generateMipmappedTexture(imageBitmap) {
-    let textureSize = {
-      width: imageBitmap.width,
-      height: imageBitmap.height,
-      depth: 1
-    };
-    const mipLevelCount = Math.floor(Math.log2(Math.max(imageBitmap.width, imageBitmap.height))) + 1;
-    const texture = this.device.createTexture({
-      size: textureSize,
-      format: 'rgba8unorm',
-      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.SAMPLED | GPUTextureUsage.OUTPUT_ATTACHMENT,
-      mipLevelCount
-    });
-    this.device.queue.copyImageBitmapToTexture({
-      imageBitmap
-    }, {
-      texture: srcTexture
-    }, textureSize);
-    const commandEncoder = this.device.createCommandEncoder({});
-
-    for (let i = 1; i < mipLevelCount; ++i) {
-      const passEncoder = commandEncoder.beginRenderPass({
-        colorAttachments: [{
-          attachment: texture.createView({
-            baseMipLevel: i,
-            mipLevelCount: 1
-          }),
-          loadValue: {
-            r: 1.0,
-            g: 0.0,
-            b: 0.0,
-            a: 0.0
-          }
-        }]
-      });
-      const bindGroup = this.device.createBindGroup({
-        layout: this.mipmapPipeline.getBindGroupLayout(0),
-        bindings: [{
-          binding: 0,
-          resource: this.mipmapSampler
-        }, {
-          binding: 1,
-          resource: texture.createView({
-            baseMipLevel: i - 1,
-            mipLevelCount: 1
-          })
-        }]
-      });
-      passEncoder.setPipeline(this.mipmapPipeline);
-      passEncoder.setBindGroup(0, bindGroup);
-      passEncoder.draw(4);
-      passEncoder.endPass();
+    constructor(device, glslang) {
+        this.device = device;
+        this.mipmapSampler = device.createSampler({ minFilter: 'linear' });
+        this.mipmapPipeline = device.createRenderPipeline({
+            vertexStage: {
+                module: device.createShaderModule({
+                    code: glslang.compileGLSL(VS_GEN_MIPMAP, 'vertex')
+                }),
+                entryPoint: 'main'
+            },
+            fragmentStage: {
+                module: device.createShaderModule({
+                    code: glslang.compileGLSL(FS_GEN_MIPMAP, 'fragment')
+                }),
+                entryPoint: 'main'
+            },
+            primitiveTopology: 'triangle-strip',
+            colorStates: [{
+                    format: 'rgba8unorm',
+                }]
+        });
+    }
+    generateMipmappedTexture(imageBitmap) {
+        let textureSize = {
+            width: imageBitmap.width,
+            height: imageBitmap.height,
+            depth: 1,
+        };
+        const mipLevelCount = Math.floor(Math.log2(Math.max(imageBitmap.width, imageBitmap.height))) + 1;
+        // Populate the top level of the srcTexture with the imageBitmap.
+        const texture = this.device.createTexture({
+            size: textureSize,
+            format: 'rgba8unorm',
+            usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.SAMPLED | GPUTextureUsage.OUTPUT_ATTACHMENT,
+            mipLevelCount
+        });
+        this.device.queue.copyImageBitmapToTexture({ imageBitmap }, { texture: srcTexture }, textureSize);
+        const commandEncoder = this.device.createCommandEncoder({});
+        for (let i = 1; i < mipLevelCount; ++i) {
+            const passEncoder = commandEncoder.beginRenderPass({
+                colorAttachments: [{
+                        attachment: texture.createView({
+                            baseMipLevel: i,
+                            mipLevelCount: 1
+                        }),
+                        loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 0.0 },
+                    }],
+            });
+            const bindGroup = this.device.createBindGroup({
+                layout: this.mipmapPipeline.getBindGroupLayout(0),
+                bindings: [{
+                        binding: 0,
+                        resource: this.mipmapSampler,
+                    }, {
+                        binding: 1,
+                        resource: texture.createView({
+                            baseMipLevel: i - 1,
+                            mipLevelCount: 1
+                        }),
+                    }],
+            });
+            passEncoder.setPipeline(this.mipmapPipeline);
+            passEncoder.setBindGroup(0, bindGroup);
+            passEncoder.draw(4);
+            passEncoder.endPass();
+        }
+        this.device.queue.submit([commandEncoder.finish()]);
+        return texture;
     }
-
-    this.device.queue.submit([commandEncoder.finish()]);
-    return texture;
-  }
-
 }
-//# sourceMappingURL=generate-mipmaps.js.map

package/dist/adapter/helpers/get-bind-group.js

@@ -1,60 +1,66 @@
 import { Buffer, Sampler, Texture, log, cast } from '@luma.gl/api';
+/**
+ * Create a WebGPU "bind group layout" from an array of luma.gl bindings
+ * @note bind groups can be automatically generated by WebGPU.
+ */
 export function makeBindGroupLayout(device, layout, bindings) {
-  throw new Error('not implemented');
+    throw new Error('not implemented');
+    // return device.createBindGroupLayout({
+    //   layout,
+    //   entries: getBindGroupEntries(bindings)
+    // })
 }
+/**
+ * Create a WebGPU "bind group" from an array of luma.gl bindings
+ */
 export function getBindGroup(device, bindGroupLayout, layout, bindings) {
-  const entries = getBindGroupEntries(bindings, layout);
-  return device.createBindGroup({
-    layout: bindGroupLayout,
-    entries
-  });
+    const entries = getBindGroupEntries(bindings, layout);
+    return device.createBindGroup({
+        layout: bindGroupLayout,
+        entries
+    });
 }
 export function getShaderLayoutBinding(layout, bindingName) {
-  const bindingLayout = layout.bindings.find(binding => binding.name === bindingName);
-
-  if (!bindingLayout) {
-    log.warn("Binding ".concat(bindingName, " not set: Not found in shader layout."))();
-  }
-
-  return bindingLayout;
+    const bindingLayout = layout.bindings.find(binding => binding.name === bindingName);
+    if (!bindingLayout) {
+        log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();
+    }
+    return bindingLayout;
 }
-
+/**
+ * @param bindings
+ * @returns
+ */
 function getBindGroupEntries(bindings, layout) {
-  const entries = [];
-
-  for (const [bindingName, value] of Object.entries(bindings)) {
-    const bindingLayout = getShaderLayoutBinding(layout, bindingName);
-
-    if (bindingLayout) {
-      entries.push(getBindGroupEntry(value, bindingLayout.location));
+    const entries = [];
+    for (const [bindingName, value] of Object.entries(bindings)) {
+        const bindingLayout = getShaderLayoutBinding(layout, bindingName);
+        if (bindingLayout) {
+            entries.push(getBindGroupEntry(value, bindingLayout.location));
+        }
     }
-  }
-
-  return entries;
+    return entries;
 }
-
 function getBindGroupEntry(binding, index) {
-  if (binding instanceof Buffer) {
-    return {
-      binding: index,
-      resource: {
-        buffer: cast(binding).handle
-      }
-    };
-  }
-
-  if (binding instanceof Sampler) {
-    return {
-      binding: index,
-      resource: cast(binding).handle
-    };
-  } else if (binding instanceof Texture) {
-    return {
-      binding: index,
-      resource: cast(binding).handle.createView()
-    };
-  }
-
-  throw new Error('invalid binding');
+    if (binding instanceof Buffer) {
+        return {
+            binding: index,
+            resource: {
+                buffer: cast(binding).handle
+            }
+        };
+    }
+    if (binding instanceof Sampler) {
+        return {
+            binding: index,
+            resource: cast(binding).handle
+        };
+    }
+    else if (binding instanceof Texture) {
+        return {
+            binding: index,
+            resource: cast(binding).handle.createView()
+        };
+    }
+    throw new Error('invalid binding');
 }
-//# sourceMappingURL=get-bind-group.js.map

package/dist/adapter/helpers/get-vertex-buffer-layout.js

@@ -1,96 +1,109 @@
 import { decodeVertexFormat } from '@luma.gl/api';
+/**
+ * Build a WebGPU vertex buffer layout intended for use in a GPURenderPassDescriptor.
+ * Converts luma.gl attribute definitions to a WebGPU GPUVertexBufferLayout[] array
+ * @param layout
+ * @param bufferMap The buffer map is optional
+ * @returns WebGPU layout intended for a GPURenderPassDescriptor.
+ */
 export function getVertexBufferLayout(layout, bufferMap) {
-  const vertexBufferLayouts = [];
-  const usedAttributes = new Set();
-
-  for (const mapping of bufferMap) {
-    const vertexAttributes = [];
-    let stepMode = 'vertex';
-    let byteStride = 0;
-    let byteOffset = mapping.byteOffset || 0;
-
-    if ('attributes' in mapping) {
-      for (const interleaved of mapping.attributes) {
-        const attributeLayout = findAttributeLayout(layout, interleaved.name, usedAttributes);
-        stepMode = attributeLayout.stepMode || 'vertex';
-        vertexAttributes.push({
-          format: attributeLayout.format,
-          offset: byteOffset + byteStride,
-          shaderLocation: attributeLayout.location
+    const vertexBufferLayouts = [];
+    const usedAttributes = new Set();
+    // First handle any buffers mentioned in `bufferMapping`
+    for (const mapping of bufferMap) {
+        // Build vertex attributes for one buffer
+        const vertexAttributes = [];
+        // TODO verify that all stepModes for one buffer are the same
+        let stepMode = 'vertex';
+        let byteStride = 0;
+        let byteOffset = mapping.byteOffset || 0;
+        // interleaved mapping {..., attributes: [{...}, ...]}
+        if ('attributes' in mapping) {
+            // const arrayStride = mapping.byteStride; TODO 
+            for (const interleaved of mapping.attributes) {
+                const attributeLayout = findAttributeLayout(layout, interleaved.name, usedAttributes);
+                stepMode = attributeLayout.stepMode || 'vertex';
+                vertexAttributes.push({
+                    format: attributeLayout.format,
+                    offset: byteOffset + byteStride,
+                    shaderLocation: attributeLayout.location
+                });
+                byteStride += decodeVertexFormat(attributeLayout.format).byteLength;
+            }
+            // non-interleaved mapping (just set offset and stride)
+        }
+        else {
+            const attributeLayout = findAttributeLayout(layout, mapping.name, usedAttributes);
+            byteStride = decodeVertexFormat(attributeLayout.format).byteLength,
+                stepMode = attributeLayout.stepMode || 'vertex';
+            vertexAttributes.push({
+                format: attributeLayout.format,
+                offset: byteOffset,
+                shaderLocation: attributeLayout.location
+            });
+        }
+        // Store all the attribute bindings for one buffer
+        vertexBufferLayouts.push({
+            arrayStride: mapping.byteStride || byteStride,
+            stepMode: stepMode || 'vertex',
+            attributes: vertexAttributes
         });
-        byteStride += decodeVertexFormat(attributeLayout.format).byteLength;
-      }
-    } else {
-      const attributeLayout = findAttributeLayout(layout, mapping.name, usedAttributes);
-      byteStride = decodeVertexFormat(attributeLayout.format).byteLength, stepMode = attributeLayout.stepMode || 'vertex';
-      vertexAttributes.push({
-        format: attributeLayout.format,
-        offset: byteOffset,
-        shaderLocation: attributeLayout.location
-      });
     }
-
-    vertexBufferLayouts.push({
-      arrayStride: mapping.byteStride || byteStride,
-      stepMode: stepMode || 'vertex',
-      attributes: vertexAttributes
-    });
-  }
-
-  for (const attribute of layout.attributes) {
-    if (!usedAttributes.has(attribute.name)) {
-      vertexBufferLayouts.push({
-        arrayStride: decodeVertexFormat(attribute.format).byteLength,
-        stepMode: attribute.stepMode || 'vertex',
-        attributes: [{
-          format: attribute.format,
-          offset: 0,
-          shaderLocation: attribute.location
-        }]
-      });
+    // Add any non-mapped attributes
+    for (const attribute of layout.attributes) {
+        if (!usedAttributes.has(attribute.name)) {
+            vertexBufferLayouts.push({
+                arrayStride: decodeVertexFormat(attribute.format).byteLength,
+                stepMode: attribute.stepMode || 'vertex',
+                attributes: [{
+                        format: attribute.format,
+                        offset: 0,
+                        shaderLocation: attribute.location
+                    }]
+            });
+        }
     }
-  }
-
-  return vertexBufferLayouts;
+    return vertexBufferLayouts;
 }
 export function getBufferSlots(layout, bufferMap) {
-  const usedAttributes = new Set();
-  let bufferSlot = 0;
-  const bufferSlots = {};
-
-  for (const mapping of bufferMap) {
-    if ('attributes' in mapping) {
-      for (const interleaved of mapping.attributes) {
-        usedAttributes.add(interleaved.name);
-      }
-    } else {
-      usedAttributes.add(mapping.name);
+    const usedAttributes = new Set();
+    let bufferSlot = 0;
+    const bufferSlots = {};
+    // First handle any buffers mentioned in `bufferMapping`
+    for (const mapping of bufferMap) {
+        // interleaved mapping {..., attributes: [{...}, ...]}
+        if ('attributes' in mapping) {
+            for (const interleaved of mapping.attributes) {
+                usedAttributes.add(interleaved.name);
+            }
+            // non-interleaved mapping (just set offset and stride)
+        }
+        else {
+            usedAttributes.add(mapping.name);
+        }
+        bufferSlots[mapping.name] = bufferSlot++;
     }
-
-    bufferSlots[mapping.name] = bufferSlot++;
-  }
-
-  for (const attribute of layout.attributes) {
-    if (!usedAttributes.has(attribute.name)) {
-      bufferSlots[attribute.name] = bufferSlot++;
+    // Add any non-mapped attributes
+    for (const attribute of layout.attributes) {
+        if (!usedAttributes.has(attribute.name)) {
+            bufferSlots[attribute.name] = bufferSlot++;
+        }
     }
-  }
-
-  return bufferSlots;
+    return bufferSlots;
 }
-
+/**
+ * Looks up an attribute in the ShaderLayout.
+ * @throws if name is not in ShaderLayout
+ * @throws if name has already been referenced
+ */
 function findAttributeLayout(layout, name, attributeNames) {
-  const attribute = layout.attributes.find(attribute => attribute.name === name);
-
-  if (!attribute) {
-    throw new Error("Unknown attribute ".concat(name));
-  }
-
-  if (attributeNames.has(name)) {
-    throw new Error("Duplicate attribute ".concat(name));
-  }
-
-  attributeNames.add(name);
-  return attribute;
+    const attribute = layout.attributes.find(attribute => attribute.name === name);
+    if (!attribute) {
+        throw new Error(`Unknown attribute ${name}`);
+    }
+    if (attributeNames.has(name)) {
+        throw new Error(`Duplicate attribute ${name}`);
+    }
+    attributeNames.add(name);
+    return attribute;
 }
-//# sourceMappingURL=get-vertex-buffer-layout.js.map

package/dist/adapter/helpers/webgpu-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgpu-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/webgpu-parameters.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAYxC;;;GAGG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,UAAU,EAAE,QAAQ,CAsJ9D,CAAC;AA8BF,wBAAgB,yCAAyC,CACvD,kBAAkB,EAAE,2BAA2B,EAC/C,UAAU,GAAE,UAAe,GAC1B,IAAI,CAIN"}
+{"version":3,"file":"webgpu-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/webgpu-parameters.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAexC;;;GAGG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,UAAU,EAAE,QAAQ,CAsJ9D,CAAC;AAgCF,wBAAgB,yCAAyC,CACvD,kBAAkB,EAAE,2BAA2B,EAC/C,UAAU,GAAE,UAAe,GAC1B,IAAI,CAIN"}