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

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

@@ -1,101 +1,2 @@
-/*
-import {assert} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
 
-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');
-}
-*/ 
+//# sourceMappingURL=accessor-to-format.js.map

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

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

package/dist/adapter/helpers/convert-texture-format.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="@webgpu/types" />
+/// <reference types="dist" />
 import { TextureFormat } from '@luma.gl/api';
 /** Ensure a texture format is WebGPU compatible */
 export declare function getWebGPUTextureFormat(format: TextureFormat): GPUTextureFormat;

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

@@ -1,7 +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/convert-texture-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-texture-format.js","names":["getWebGPUTextureFormat","format","includes","Error"],"sources":["../../../src/adapter/helpers/convert-texture-format.ts"],"sourcesContent":["// luma.gl, MIT license\nimport {TextureFormat} from '@luma.gl/api';\n\n/** Ensure a texture format is WebGPU compatible */\nexport function getWebGPUTextureFormat(format: TextureFormat): GPUTextureFormat {\n  if (format.includes('webgl')) {\n    throw new Error('webgl-only format');\n  }\n  return format as GPUTextureFormat;\n}\n"],"mappings":"AAIA,OAAO,SAASA,sBAAsBA,CAACC,MAAqB,EAAoB;EAC9E,IAAIA,MAAM,CAACC,QAAQ,CAAC,OAAO,CAAC,EAAE;IAC5B,MAAM,IAAIC,KAAK,CAAC,mBAAmB,CAAC;EACtC;EACA,OAAOF,MAAM;AACf"}

package/dist/adapter/helpers/generate-mipmaps.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="@webgpu/types" />
+/// <reference types="dist" />
 /** WebGPU does not have built-in mipmap creation */
 export declare class WebGPUMipmapGenerator {
     device: GPUDevice;

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

@@ -1,91 +1,88 @@
-// 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 */
+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}";
 export class WebGPUMipmapGenerator {
-    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;
+  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) {
+    const 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();
     }
+    this.device.queue.submit([commandEncoder.finish()]);
+    return texture;
+  }
 }
+//# sourceMappingURL=generate-mipmaps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-mipmaps.js","names":["VS_GEN_MIPMAP","FS_GEN_MIPMAP","WebGPUMipmapGenerator","constructor","device","glslang","_defineProperty","mipmapSampler","createSampler","minFilter","mipmapPipeline","createRenderPipeline","vertexStage","module","createShaderModule","code","compileGLSL","entryPoint","fragmentStage","primitiveTopology","colorStates","format","generateMipmappedTexture","imageBitmap","textureSize","width","height","depth","mipLevelCount","Math","floor","log2","max","texture","createTexture","size","usage","GPUTextureUsage","COPY_DST","SAMPLED","OUTPUT_ATTACHMENT","queue","copyImageBitmapToTexture","srcTexture","commandEncoder","createCommandEncoder","i","passEncoder","beginRenderPass","colorAttachments","attachment","createView","baseMipLevel","loadValue","r","g","b","a","bindGroup","createBindGroup","layout","getBindGroupLayout","bindings","binding","resource","setPipeline","setBindGroup","draw","endPass","submit","finish"],"sources":["../../../src/adapter/helpers/generate-mipmaps.ts"],"sourcesContent":["// luma.gl, MIT license\n// Forked from Kangz/mipmapper.js under MIT license Copyright 2020 Brandon Jones\n// https://gist.github.com/Kangz/782d5f1ae502daf53910a13f55db2f83\n\n// @ts-nocheck this is written against outdated WebGPU API, needs an update pass\n\nconst 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}`;\n\nconst 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}`;\n\n/** WebGPU does not have built-in mipmap creation */\nexport class WebGPUMipmapGenerator {\n  device: GPUDevice;\n  mipmapSampler: GPUSampler;\n  mipmapPipeline: GPURenderPipeline;\n\n  constructor(device: GPUDevice, glslang) {\n    this.device = device;\n\n    this.mipmapSampler = device.createSampler({ minFilter: 'linear' });\n\n    this.mipmapPipeline = device.createRenderPipeline({\n      vertexStage: {\n        module: device.createShaderModule({\n          code: glslang.compileGLSL(VS_GEN_MIPMAP, 'vertex')\n        }),\n        entryPoint: 'main'\n      },\n      fragmentStage: {\n        module: device.createShaderModule({\n          code: glslang.compileGLSL(FS_GEN_MIPMAP, 'fragment')\n        }),\n        entryPoint: 'main'\n      },\n      primitiveTopology: 'triangle-strip',\n      colorStates: [{\n        format: 'rgba8unorm',\n      }]\n    });\n  }\n\n  generateMipmappedTexture(imageBitmap: ImageBitmap) {\n    const textureSize = {\n      width: imageBitmap.width,\n      height: imageBitmap.height,\n      depth: 1,\n    }\n    const mipLevelCount = Math.floor(Math.log2(Math.max(imageBitmap.width, imageBitmap.height))) + 1;\n\n    // Populate the top level of the srcTexture with the imageBitmap.\n    const texture = this.device.createTexture({\n      size: textureSize,\n      format: 'rgba8unorm',\n      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.SAMPLED | GPUTextureUsage.OUTPUT_ATTACHMENT,\n      mipLevelCount\n    });\n    this.device.queue.copyImageBitmapToTexture({ imageBitmap }, { texture: srcTexture }, textureSize);\n\n    const commandEncoder = this.device.createCommandEncoder({});\n    for (let i = 1; i < mipLevelCount; ++i) {\n      const passEncoder = commandEncoder.beginRenderPass({\n        colorAttachments: [{\n          attachment: texture.createView({\n            baseMipLevel: i,\n            mipLevelCount: 1\n          }),\n          loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 0.0 },\n        }],\n      });\n\n      const bindGroup = this.device.createBindGroup({\n        layout: this.mipmapPipeline.getBindGroupLayout(0),\n        bindings: [{\n          binding: 0,\n          resource: this.mipmapSampler,\n        }, {\n          binding: 1,\n          resource: texture.createView({\n            baseMipLevel: i - 1,\n            mipLevelCount: 1\n          }),\n        }],\n      });\n\n      passEncoder.setPipeline(this.mipmapPipeline);\n      passEncoder.setBindGroup(0, bindGroup);\n      passEncoder.draw(4);\n      passEncoder.endPass();\n    }\n\n    this.device.queue.submit([commandEncoder.finish()]);\n    return texture;\n  }\n}\n"],"mappings":"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"}

package/dist/adapter/helpers/get-bind-group.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="@webgpu/types" />
+/// <reference types="dist" />
 import type { ShaderLayout, BindingLayout, Binding } from '@luma.gl/api';
 /**
  * Create a WebGPU "bind group layout" from an array of luma.gl bindings

package/dist/adapter/helpers/get-bind-group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-bind-group.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-bind-group.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAE,OAAO,EAAC,MAAM,cAAc,CAAC;AAMvE;;;GAGG;AACF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,kBAAkB,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,kBAAkB,CAM3H;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,EACjB,eAAe,EAAE,kBAAkB,EACnC,MAAM,EAAE,YAAY,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,YAAY,CAMd;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,CAM/F"}
+{"version":3,"file":"get-bind-group.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-bind-group.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAE,OAAO,EAAC,MAAM,cAAc,CAAC;AAMvE;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,kBAAkB,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,kBAAkB,CAM1H;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,EACjB,eAAe,EAAE,kBAAkB,EACnC,MAAM,EAAE,YAAY,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,YAAY,CAMd;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,CAM/F"}

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

@@ -1,66 +1,51 @@
 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');
-    // return device.createBindGroupLayout({
-    //   layout,
-    //   entries: getBindGroupEntries(bindings)
-    // })
+  throw new Error('not implemented');
 }
-/**
- * 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 ${bindingName} not set: Not found in shader layout.`)();
-    }
-    return bindingLayout;
+  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;
 }
-/**
- * @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-bind-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-bind-group.js","names":["Buffer","Sampler","Texture","log","cast","makeBindGroupLayout","device","layout","bindings","Error","getBindGroup","bindGroupLayout","entries","getBindGroupEntries","createBindGroup","getShaderLayoutBinding","bindingName","bindingLayout","find","binding","name","warn","concat","value","Object","push","getBindGroupEntry","location","index","resource","buffer","handle","createView"],"sources":["../../../src/adapter/helpers/get-bind-group.ts"],"sourcesContent":["// luma.gl, MIT license\nimport type {ShaderLayout, BindingLayout, Binding} from '@luma.gl/api';\nimport {Buffer, Sampler, Texture, log, cast} from '@luma.gl/api';\nimport type WebGPUBuffer from '../resources/webgpu-buffer';\nimport type WebGPUSampler from '../resources/webgpu-sampler';\nimport type WebGPUTexture from '../resources/webgpu-texture';\n\n/**\n * Create a WebGPU \"bind group layout\" from an array of luma.gl bindings\n * @note bind groups can be automatically generated by WebGPU.\n */\nexport function makeBindGroupLayout(device: GPUDevice, layout: GPUBindGroupLayout, bindings: Binding[]): GPUBindGroupLayout {\n  throw new Error('not implemented');\n  // return device.createBindGroupLayout({\n  //   layout,\n  //   entries: getBindGroupEntries(bindings)\n  // })\n}\n\n/**\n * Create a WebGPU \"bind group\" from an array of luma.gl bindings\n */\nexport function getBindGroup(\n  device: GPUDevice,\n  bindGroupLayout: GPUBindGroupLayout,\n  layout: ShaderLayout,\n  bindings: Record<string, Binding>\n): GPUBindGroup {\n  const entries = getBindGroupEntries(bindings, layout);\n  return device.createBindGroup({\n    layout: bindGroupLayout,\n    entries\n  });\n}\n\nexport function getShaderLayoutBinding(layout: ShaderLayout, bindingName: string): BindingLayout {\n  const bindingLayout = layout.bindings.find(binding => binding.name === bindingName);\n  if (!bindingLayout) {\n    log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();\n  }\n  return bindingLayout;\n}\n\n/**\n * @param bindings\n * @returns\n */\nfunction getBindGroupEntries(bindings: Record<string, Binding>, layout: ShaderLayout): GPUBindGroupEntry[] {\n  const entries: GPUBindGroupEntry[] = [];\n\n  for (const [bindingName, value] of Object.entries(bindings)) {\n    const bindingLayout = getShaderLayoutBinding(layout, bindingName);\n    if (bindingLayout) {\n      entries.push(getBindGroupEntry(value, bindingLayout.location));\n    }\n  }\n\n  return entries;\n}\n\nfunction getBindGroupEntry(binding: Binding, index: number): GPUBindGroupEntry {\n  if (binding instanceof Buffer) {\n    return {\n      binding: index,\n      resource: {\n        buffer: cast<WebGPUBuffer>(binding).handle\n      }\n    };\n  }\n  if (binding instanceof Sampler) {\n    return {\n      binding: index,\n      resource: cast<WebGPUSampler>(binding).handle\n    };\n  } else if (binding instanceof Texture) {\n    return {\n      binding: index,\n      resource: cast<WebGPUTexture>(binding).handle.createView()\n    };\n  }\n  throw new Error('invalid binding');\n}\n"],"mappings":"AAEA,SAAQA,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAEC,GAAG,EAAEC,IAAI,QAAO,cAAc;AAShE,OAAO,SAASC,mBAAmBA,CAACC,MAAiB,EAAEC,MAA0B,EAAEC,QAAmB,EAAsB;EAC1H,MAAM,IAAIC,KAAK,CAAC,iBAAiB,CAAC;AAKpC;AAKA,OAAO,SAASC,YAAYA,CAC1BJ,MAAiB,EACjBK,eAAmC,EACnCJ,MAAoB,EACpBC,QAAiC,EACnB;EACd,MAAMI,OAAO,GAAGC,mBAAmB,CAACL,QAAQ,EAAED,MAAM,CAAC;EACrD,OAAOD,MAAM,CAACQ,eAAe,CAAC;IAC5BP,MAAM,EAAEI,eAAe;IACvBC;EACF,CAAC,CAAC;AACJ;AAEA,OAAO,SAASG,sBAAsBA,CAACR,MAAoB,EAAES,WAAmB,EAAiB;EAC/F,MAAMC,aAAa,GAAGV,MAAM,CAACC,QAAQ,CAACU,IAAI,CAACC,OAAO,IAAIA,OAAO,CAACC,IAAI,KAAKJ,WAAW,CAAC;EACnF,IAAI,CAACC,aAAa,EAAE;IAClBd,GAAG,CAACkB,IAAI,YAAAC,MAAA,CAAYN,WAAW,2CAAwC,EAAE;EAC3E;EACA,OAAOC,aAAa;AACtB;AAMA,SAASJ,mBAAmBA,CAACL,QAAiC,EAAED,MAAoB,EAAuB;EACzG,MAAMK,OAA4B,GAAG,EAAE;EAEvC,KAAK,MAAM,CAACI,WAAW,EAAEO,KAAK,CAAC,IAAIC,MAAM,CAACZ,OAAO,CAACJ,QAAQ,CAAC,EAAE;IAC3D,MAAMS,aAAa,GAAGF,sBAAsB,CAACR,MAAM,EAAES,WAAW,CAAC;IACjE,IAAIC,aAAa,EAAE;MACjBL,OAAO,CAACa,IAAI,CAACC,iBAAiB,CAACH,KAAK,EAAEN,aAAa,CAACU,QAAQ,CAAC,CAAC;IAChE;EACF;EAEA,OAAOf,OAAO;AAChB;AAEA,SAASc,iBAAiBA,CAACP,OAAgB,EAAES,KAAa,EAAqB;EAC7E,IAAIT,OAAO,YAAYnB,MAAM,EAAE;IAC7B,OAAO;MACLmB,OAAO,EAAES,KAAK;MACdC,QAAQ,EAAE;QACRC,MAAM,EAAE1B,IAAI,CAAee,OAAO,CAAC,CAACY;MACtC;IACF,CAAC;EACH;EACA,IAAIZ,OAAO,YAAYlB,OAAO,EAAE;IAC9B,OAAO;MACLkB,OAAO,EAAES,KAAK;MACdC,QAAQ,EAAEzB,IAAI,CAAgBe,OAAO,CAAC,CAACY;IACzC,CAAC;EACH,CAAC,MAAM,IAAIZ,OAAO,YAAYjB,OAAO,EAAE;IACrC,OAAO;MACLiB,OAAO,EAAES,KAAK;MACdC,QAAQ,EAAEzB,IAAI,CAAgBe,OAAO,CAAC,CAACY,MAAM,CAACC,UAAU;IAC1D,CAAC;EACH;EACA,MAAM,IAAIvB,KAAK,CAAC,iBAAiB,CAAC;AACpC"}

package/dist/adapter/helpers/get-vertex-buffer-layout.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="@webgpu/types" />
+/// <reference types="dist" />
 import type { ShaderLayout, BufferMapping } from '@luma.gl/api';
 /**
  * Build a WebGPU vertex buffer layout intended for use in a GPURenderPassDescriptor.