@luma.gl/webgpu 9.0.0-alpha.9 → 9.0.0-beta.10

package/src/adapter/resources/webgpu-render-pass.ts

@@ -1,11 +1,17 @@
-import type {RenderPassProps, RenderPassParameters, Binding} from '@luma.gl/api';
-import {Buffer, RenderPass, RenderPipeline, cast, log} from '@luma.gl/api';
-import WebGPUDevice from '../webgpu-device';
-import WebGPUBuffer from './webgpu-buffer';
-// import WebGPUCommandEncoder from './webgpu-command-encoder';
-import WebGPURenderPipeline from './webgpu-render-pipeline';
-
-export default class WebGPURenderPass extends RenderPass {
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {RenderPassProps, RenderPassParameters, Binding, Framebuffer} from '@luma.gl/core';
+import {Buffer, RenderPass, RenderPipeline, cast, log} from '@luma.gl/core';
+import {WebGPUDevice} from '../webgpu-device';
+import {WebGPUBuffer} from './webgpu-buffer';
+import {WebGPUTextureView} from './webgpu-texture-view';
+// import {WebGPUCommandEncoder} from './webgpu-command-encoder';
+import {WebGPURenderPipeline} from './webgpu-render-pipeline';
+import {WebGPUQuerySet} from './webgpu-query-set';
+
+export class WebGPURenderPass extends RenderPass {
   readonly device: WebGPUDevice;
   readonly handle: GPURenderPassEncoder;
 
@@ -16,16 +22,35 @@ export default class WebGPURenderPass extends RenderPass {
     super(device, props);
     this.device = device;
     const framebuffer = props.framebuffer || device.canvasContext.getCurrentFramebuffer();
-    // @ts-expect-error
-    const renderPassDescriptor = framebuffer.renderPassDescriptor;
+    const renderPassDescriptor = this.getRenderPassDescriptor(framebuffer);
+
+    const webgpuQuerySet = props.timestampQuerySet as WebGPUQuerySet;
+    if (webgpuQuerySet) {
+      renderPassDescriptor.occlusionQuerySet = webgpuQuerySet.handle;
+    }
+
+    if (device.features.has('timestamp-query')) {
+      const webgpuQuerySet = props.timestampQuerySet as WebGPUQuerySet;
+      renderPassDescriptor.timestampWrites = webgpuQuerySet
+        ? ({
+            querySet: webgpuQuerySet.handle,
+            beginningOfPassWriteIndex: props.beginTimestampIndex,
+            endOfPassWriteIndex: props.endTimestampIndex
+          } as GPUComputePassTimestampWrites)
+        : undefined;
+    }
+
     this.handle = this.props.handle || device.commandEncoder.beginRenderPass(renderPassDescriptor);
     this.handle.label = this.props.id;
+    log.groupCollapsed(3, `new WebGPURenderPass(${this.id})`)();
+    log.probe(3, JSON.stringify(renderPassDescriptor, null, 2))();
+    log.groupEnd(3)();
   }
 
-  destroy() {}
+  override destroy(): void {}
 
-  endPass(): void {
-    this.handle.endPass();
+  end(): void {
+    this.handle.end();
   }
 
   setPipeline(pipeline: RenderPipeline): void {
@@ -75,7 +100,7 @@ export default class WebGPURenderPass extends RenderPass {
     } else {
       this.handle.draw(
         options.vertexCount || 0,
-        options.instanceCount,
+        options.instanceCount || 1,
         options.firstIndex,
         options.firstInstance
       );
@@ -121,11 +146,62 @@ export default class WebGPURenderPass extends RenderPass {
     this.handle.insertDebugMarker(markerLabel);
   }
 
-  // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
-  // beginOcclusionQuery(queryIndex: number): void;
-  // endOcclusionQuery(): void;
-  // beginPipelineStatisticsQuery(querySet: GPUQuerySet, queryIndex: number): void;
-  // endPipelineStatisticsQuery(querySet: GPUQuerySet, queryIndex: number): void;
+  beginOcclusionQuery(queryIndex: number): void {
+    this.handle.beginOcclusionQuery(queryIndex);
+  }
+  endOcclusionQuery(): void {
+    this.handle.endOcclusionQuery();
+  }
 
   // executeBundles(bundles: Iterable<GPURenderBundle>): void;
+
+  // INTERNAL
+
+  /**
+   * Partial render pass descriptor. Used by WebGPURenderPass.
+   * @returns attachments fields of a renderpass descriptor.
+   */
+  protected getRenderPassDescriptor(framebuffer: Framebuffer): GPURenderPassDescriptor {
+    const renderPassDescriptor: GPURenderPassDescriptor = {
+      colorAttachments: []
+    };
+
+    renderPassDescriptor.colorAttachments = framebuffer.colorAttachments.map(colorAttachment => ({
+      // clear values
+      loadOp: this.props.clearColor !== false ? 'clear' : 'load',
+      colorClearValue: this.props.clearColor || [0, 0, 0, 0],
+      storeOp: this.props.discard ? 'discard' : 'store',
+      // ...colorAttachment,
+      view: (colorAttachment as WebGPUTextureView).handle
+    }));
+
+    if (framebuffer.depthStencilAttachment) {
+      renderPassDescriptor.depthStencilAttachment = {
+        view: (framebuffer.depthStencilAttachment as WebGPUTextureView).handle
+      };
+      const {depthStencilAttachment} = renderPassDescriptor;
+
+      // DEPTH
+      if (this.props.depthReadOnly) {
+        depthStencilAttachment.depthReadOnly = true;
+      }
+      depthStencilAttachment.depthClearValue = this.props.clearDepth || 0;
+
+      // WebGPU only wants us to set these parameters if the texture format actually has a depth aspect
+      const hasDepthAspect = true;
+      if (hasDepthAspect) {
+        depthStencilAttachment.depthLoadOp = this.props.clearDepth !== false ? 'clear' : 'load';
+        depthStencilAttachment.depthStoreOp = 'store'; // TODO - support 'discard'?
+      }
+
+      // WebGPU only wants us to set these parameters if the texture format actually has a stencil aspect
+      const hasStencilAspect = false;
+      if (hasStencilAspect) {
+        depthStencilAttachment.stencilLoadOp = this.props.clearStencil !== false ? 'clear' : 'load';
+        depthStencilAttachment.stencilStoreOp = 'store'; // TODO - support 'discard'?
+      }
+    }
+
+    return renderPassDescriptor;
+  }
 }

package/src/adapter/resources/webgpu-render-pipeline.ts

@@ -1,157 +1,179 @@
-import type {Binding, RenderPass, Shader} from '@luma.gl/api';
-import {Buffer, RenderPipeline, RenderPipelineProps, cast, log, isObjectEmpty} from '@luma.gl/api';
+// luma.gl MIT license
+
+import type {Binding, RenderPass, VertexArray} from '@luma.gl/core';
+import {RenderPipeline, RenderPipelineProps, cast, log} from '@luma.gl/core';
 import {applyParametersToRenderPipelineDescriptor} from '../helpers/webgpu-parameters';
 import {getWebGPUTextureFormat} from '../helpers/convert-texture-format';
 import {getBindGroup} from '../helpers/get-bind-group';
-import {getVertexBufferLayout, getBufferSlots} from '../helpers/get-vertex-buffer-layout';
+import {getVertexBufferLayout} from '../helpers/get-vertex-buffer-layout';
 // import {convertAttributesVertexBufferToLayout} from '../helpers/get-vertex-buffer-layout';
 // import {mapAccessorToWebGPUFormat} from './helpers/accessor-to-format';
 // import type {BufferAccessors} from './webgpu-pipeline';
 
-import type WebGPUDevice from '../webgpu-device';
-import type WebGPUBuffer from './webgpu-buffer';
-import type WebGPUShader from './webgpu-shader';
-import type WebGPURenderPass from './webgpu-render-pass';
+import type {WebGPUDevice} from '../webgpu-device';
+// import type {WebGPUBuffer} from './webgpu-buffer';
+import type {WebGPUShader} from './webgpu-shader';
+import type {WebGPURenderPass} from './webgpu-render-pass';
 
 // RENDER PIPELINE
 
 /** Creates a new render pipeline when parameters change */
-export default class WebGPURenderPipeline extends RenderPipeline {
+export class WebGPURenderPipeline extends RenderPipeline {
   device: WebGPUDevice;
   handle: GPURenderPipeline;
 
   vs: WebGPUShader;
   fs: WebGPUShader | null = null;
 
-  private _bufferSlots: Record<string, number>;
-  private _buffers: Buffer[];
-  private _indexBuffer: WebGPUBuffer | null = null;
-  // private _firstIndex: number;
-  // private _lastIndex: number;
-
   /** For internal use to create BindGroups */
-  private _bindGroupLayout: GPUBindGroupLayout;
+  private _bindings: Record<string, Binding>;
+  private _bindGroupLayout: GPUBindGroupLayout | null = null;
   private _bindGroup: GPUBindGroup | null = null;
 
   constructor(device: WebGPUDevice, props: RenderPipelineProps) {
     super(device, props);
     this.device = device;
-    this.handle = (this.props.handle as GPURenderPipeline) || this.createHandle();
+    this.handle = this.props.handle as GPURenderPipeline;
+    if (!this.handle) {
+      const descriptor = this._getRenderPipelineDescriptor();
+      log.groupCollapsed(1, `new WebGPURenderPipeline(${this.id})`)();
+      log.probe(1, JSON.stringify(descriptor, null, 2))();
+      log.groupEnd(1)();
+      this.handle = this.device.handle.createRenderPipeline(descriptor);
+    }
     this.handle.label = this.props.id;
 
     this.vs = cast<WebGPUShader>(props.vs);
     this.fs = cast<WebGPUShader>(props.fs);
 
-    this._bufferSlots = getBufferSlots(this.props.layout, this.props.bufferMap);
-    this._buffers = new Array<Buffer>(Object.keys(this._bufferSlots).length).fill(null);
-    this._bindGroupLayout = this.handle.getBindGroupLayout(0);
+    this._bindings = {...this.props.bindings};
   }
 
-  protected createHandle(): GPURenderPipeline {
-    const descriptor = this._getRenderPipelineDescriptor();
-    const renderPipeline = this.device.handle.createRenderPipeline(descriptor);
-    log.groupCollapsed(1, `new WebGPRenderPipeline(${this.id})`)();
-    log.log(1, JSON.stringify(descriptor, null, 2))();
-    log.groupEnd(1)();
-    return renderPipeline;
-  }
-
-  destroy() {
+  override destroy(): void {
     // WebGPURenderPipeline has no destroy method.
+    this.handle = null;
   }
 
-  setIndexBuffer(indexBuffer: Buffer): void {
-    this._indexBuffer = cast<WebGPUBuffer>(indexBuffer);
+  /**
+   * @todo Use renderpass.setBindings() ?
+   * @todo Do we want to expose BindGroups in the API and remove this?
+   */
+  setBindings(bindings: Record<string, Binding>): void {
+    Object.assign(this._bindings, bindings);
   }
 
-  setAttributes(attributes: Record<string, Buffer>): void {
-    for (const [name, buffer] of Object.entries(attributes)) {
-      const bufferIndex = this._bufferSlots[name];
-      if (bufferIndex >= 0) {
-        this._buffers[bufferIndex] = buffer;
-      } else {
-        throw new Error(
-          `Setting attribute '${name}' not listed in shader layout for program ${this.id}`
-        );
-      }
+  /** @todo - should this be moved to renderpass? */
+  draw(options: {
+    renderPass: RenderPass;
+    vertexArray: VertexArray;
+    vertexCount?: number;
+    indexCount?: number;
+    instanceCount?: number;
+    firstVertex?: number;
+    firstIndex?: number;
+    firstInstance?: number;
+    baseVertex?: number;
+  }): boolean {
+    const webgpuRenderPass = options.renderPass as WebGPURenderPass;
+
+    // Set pipeline
+    webgpuRenderPass.handle.setPipeline(this.handle);
+
+    // Set bindings (uniform buffers, textures etc)
+    const bindGroup = this._getBindGroup();
+    if (bindGroup) {
+      webgpuRenderPass.handle.setBindGroup(0, bindGroup);
     }
-    // for (let i = 0; i < this._bufferSlots.length; ++i) {
-    //   const bufferName = this._bufferSlots[i];
-    //   if (attributes[bufferName]) {
-    //     this.handle
-    //   }
-    // }
-  }
 
-  /** Set the bindings */
-  setBindings(bindings: Record<string, Binding>): void {
-    if (!isObjectEmpty(this.props.bindings)) {
-      Object.assign(this.props.bindings, bindings);
-      // Set up the bindings
-      this._bindGroup = getBindGroup(
-        this.device.handle,
-        this._bindGroupLayout,
-        this.props.layout,
-        this.props.bindings
+    // Set attributes
+    // Note: Rebinds constant attributes before each draw call
+    options.vertexArray.bindBeforeRender(options.renderPass);
+
+    // Draw
+    if (options.indexCount) {
+      webgpuRenderPass.handle.drawIndexed(
+        options.indexCount,
+        options.instanceCount,
+        options.firstIndex,
+        options.baseVertex,
+        options.firstInstance
+      );
+    } else {
+      webgpuRenderPass.handle.draw(
+        options.vertexCount || 0,
+        options.instanceCount || 1, // If 0, nothing will be drawn
+        options.firstInstance
       );
     }
-  }
 
-  setUniforms(uniforms: Record<string, any>): void {
-    if (!isObjectEmpty(uniforms)) {
-      throw new Error('WebGPU does not support uniforms');
-    }
-  }
+    // Note: Rebinds constant attributes before each draw call
+    options.vertexArray.unbindAfterRender(options.renderPass);
 
-  _getBuffers() {
-    return this._buffers;
+    return true;
   }
 
   /** Return a bind group created by setBindings */
   _getBindGroup() {
-    // assert(this._bindGroup);
+    if (this.props.shaderLayout.bindings.length === 0) {
+      return null;
+    }
+
+    // Get hold of the bind group layout. We don't want to do this unless we know there is at least one bind group
+    this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
+
+    // Set up the bindings
+    // TODO what if bindings change? We need to rebuild the bind group!
+    this._bindGroup =
+      this._bindGroup ||
+      getBindGroup(
+        this.device.handle,
+        this._bindGroupLayout,
+        this.props.shaderLayout,
+        this._bindings
+      );
+
     return this._bindGroup;
   }
 
-  /** Populate the complex WebGPU GPURenderPipelineDescriptor */
+  /**
+   * Populate the complex WebGPU GPURenderPipelineDescriptor
+   */
   protected _getRenderPipelineDescriptor() {
     // Set up the vertex stage
     const vertex: GPUVertexState = {
       module: cast<WebGPUShader>(this.props.vs).handle,
-      entryPoint: this.props.vsEntryPoint || 'main',
-      buffers: getVertexBufferLayout(this.props.layout, this.props.bufferMap)
+      entryPoint: this.props.vertexEntryPoint || 'main',
+      buffers: getVertexBufferLayout(this.props.shaderLayout, this.props.bufferLayout)
     };
 
     // Set up the fragment stage
-    let fragment: GPUFragmentState | undefined;
-    if (this.props.fs) {
-      fragment = {
-        module: cast<WebGPUShader>(this.props.fs).handle,
-        entryPoint: this.props.fsEntryPoint || 'main',
-        targets: [
-          {
-            // TODO exclamation mark hack!
-            format: getWebGPUTextureFormat(this.device?.canvasContext?.format!)
-          }
-        ]
-      };
-    }
+    const fragment: GPUFragmentState = {
+      module: cast<WebGPUShader>(this.props.fs).handle,
+      entryPoint: this.props.fragmentEntryPoint || 'main',
+      targets: [
+        {
+          // TODO exclamation mark hack!
+          format: getWebGPUTextureFormat(this.device?.canvasContext?.format)
+        }
+      ]
+    };
 
     // WebGPU has more restrictive topology support than WebGL
     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:
     }
 
     // Create a partially populated descriptor
-    let descriptor: GPURenderPipelineDescriptor = {
+    const descriptor: GPURenderPipelineDescriptor = {
       vertex,
       fragment,
       primitive: {
         topology: this.props.topology
-      }
+      },
+      layout: 'auto'
     };
 
     // Set parameters on the descriptor
@@ -159,88 +181,46 @@ export default class WebGPURenderPipeline extends RenderPipeline {
 
     return descriptor;
   }
+}
+/**
+_setAttributeBuffers(webgpuRenderPass: WebGPURenderPass) {
+  if (this._indexBuffer) {
+    webgpuRenderPass.handle.setIndexBuffer(this._indexBuffer.handle, this._indexBuffer.props.indexType);
+  }
 
-  draw(options: {
-    renderPass?: RenderPass;
-    vertexCount?: number;
-    indexCount?: number;
-    instanceCount?: number;
-    firstVertex?: number;
-    firstIndex?: number;
-    firstInstance?: number;
-    baseVertex?: number;
-  }): void {
-    const webgpuRenderPass =
-      cast<WebGPURenderPass>(options.renderPass) || this.device.getDefaultRenderPass();
-
-    // Set pipeline
-    webgpuRenderPass.handle.setPipeline(this.handle);
-
-    // Set bindings (uniform buffers, textures etc)
-    if (this._getBindGroup()) {
-      webgpuRenderPass.handle.setBindGroup(0, this._getBindGroup());
-    }
-
-    // Set attributes
-    this._setAttributeBuffers(webgpuRenderPass);
-
-    // Draw
-    if (options.indexCount) {
-      webgpuRenderPass.handle.drawIndexed(
-        options.indexCount,
-        options.instanceCount,
-        options.firstIndex,
-        options.baseVertex,
-        options.firstInstance
+  const buffers = this._getBuffers();
+  for (let i = 0; i < buffers.length; ++i) {
+    const buffer = cast<WebGPUBuffer>(buffers[i]);
+    if (!buffer) {
+      const attribute = this.props.shaderLayout.attributes.find(
+        (attribute) => attribute.location === i
       );
-    } else {
-      webgpuRenderPass.handle.draw(
-        options.vertexCount || 0,
-        options.instanceCount,
-        options.firstIndex,
-        options.firstInstance
+      throw new Error(
+        `No buffer provided for attribute '${attribute?.name || ''}' in Model '${this.props.id}'`
       );
     }
+    webgpuRenderPass.handle.setVertexBuffer(i, buffer.handle);
   }
 
-  _setAttributeBuffers(webgpuRenderPass: WebGPURenderPass) {
-    if (this._indexBuffer) {
-      webgpuRenderPass.handle.setIndexBuffer(this._indexBuffer.handle, this._indexBuffer.props.indexType);
+  // TODO - HANDLE buffer maps
+  /*
+  for (const [bufferName, attributeMapping] of Object.entries(this.props.bufferLayout)) {
+    const buffer = cast<WebGPUBuffer>(this.props.attributes[bufferName]);
+    if (!buffer) {
+      log.warn(`Missing buffer for buffer map ${bufferName}`)();
+      continue;
     }
 
-    const buffers = this._getBuffers();
-    for (let i = 0; i < buffers.length; ++i) {
-      const buffer = cast<WebGPUBuffer>(buffers[i]);
-      if (!buffer) {
-        const attribute = this.props.layout.attributes.find(
-          (attribute) => attribute.location === i
-        );
-        throw new Error(
-          `No buffer provided for attribute '${attribute?.name || ''}' in Model '${this.props.id}'`
-        );
-      }
-      webgpuRenderPass.handle.setVertexBuffer(i, buffer.handle);
-    }
-
-    // TODO - HANDLE buffer maps
-    /*
-    for (const [bufferName, attributeMapping] of Object.entries(this.props.bufferMap)) {
-      const buffer = cast<WebGPUBuffer>(this.props.attributes[bufferName]);
-      if (!buffer) {
-        log.warn(`Missing buffer for buffer map ${bufferName}`)();
-        continue;
-      }
-
-      if ('location' in attributeMapping) {
+    if ('location' in attributeMapping) {
+      // @ts-expect-error TODO model must not depend on webgpu
+      renderPass.handle.setVertexBuffer(layout.location, buffer.handle);
+    } else {
+      for (const [bufferName, mapping] of Object.entries(attributeMapping)) {
         // @ts-expect-error TODO model must not depend on webgpu
-        renderPass.handle.setVertexBuffer(layout.location, buffer.handle);
-      } else {
-        for (const [bufferName, mapping] of Object.entries(attributeMapping)) {
-          // @ts-expect-error TODO model must not depend on webgpu
-          renderPass.handle.setVertexBuffer(field.location, buffer.handle);
-        }
+        renderPass.handle.setVertexBuffer(field.location, buffer.handle);
       }
     }
-    */
   }
+  *
 }
+*/

package/src/adapter/resources/webgpu-sampler.ts

@@ -1,14 +1,14 @@
-import {Sampler, SamplerProps} from '@luma.gl/api';
-import type WebGPUDevice from '../webgpu-device';
+import {Sampler, SamplerProps} from '@luma.gl/core';
+import type {WebGPUDevice} from '../webgpu-device';
 
 export type WebGPUSamplerProps = SamplerProps & {
   handle?: GPUSampler;
-}
+};
 
 /**
  *
  */
-export default class WebGPUSampler extends Sampler {
+export class WebGPUSampler extends Sampler {
   readonly device: WebGPUDevice;
   readonly handle: GPUSampler;
 
@@ -17,16 +17,19 @@ export default class WebGPUSampler extends Sampler {
     this.device = device;
 
     // Prepare sampler props
-    const samplerProps = this.props;
+    const samplerProps: Partial<WebGPUSamplerProps> = {...this.props};
     if (samplerProps.type !== 'comparison-sampler') {
       delete samplerProps.compare;
     }
 
-    this.handle = this.handle || this.device.handle.createSampler(this.props);
+    this.handle = this.handle || this.device.handle.createSampler(samplerProps);
     this.handle.label = this.props.id;
   }
 
-  destroy(): void {
+  override destroy(): void {
+    // GPUSampler does not have a destroy method
     // this.handle.destroy();
+    // @ts-expect-error readonly
+    this.handle = null;
   }
 }

package/src/adapter/resources/webgpu-shader.ts

@@ -1,19 +1,19 @@
-import type {ShaderProps, CompilerMessage} from '@luma.gl/api';
-import {Shader, log} from '@luma.gl/api';
-import type WebGPUDevice from '../webgpu-device';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
-export type WebGPUShaderProps = ShaderProps & {
-  handle?: GPUShaderModule;
-};
+import type {ShaderProps, CompilerMessage} from '@luma.gl/core';
+import {Shader, log} from '@luma.gl/core';
+import type {WebGPUDevice} from '../webgpu-device';
 
 /**
  * Immutable shader
  */
-export default class WebGPUShader extends Shader {
+export class WebGPUShader extends Shader {
   readonly device: WebGPUDevice;
   readonly handle: GPUShaderModule;
 
-  constructor(device: WebGPUDevice, props: WebGPUShaderProps) {
+  constructor(device: WebGPUDevice, props: ShaderProps) {
     super(device, props);
     this.device = device;
 
@@ -25,10 +25,13 @@ export default class WebGPUShader extends Shader {
     this._checkCompilationError(this.device.handle.popErrorScope());
   }
 
-  async _checkCompilationError(errorScope: Promise<GPUError>): Promise<void> {
-    const error = await errorScope as GPUValidationError;
+  async _checkCompilationError(errorScope: Promise<GPUError | null>): Promise<void> {
+    const error = (await errorScope) as GPUValidationError;
     if (error) {
-      const shaderLog = await this.compilationInfo();
+      // The `Shader` base class will determine if debug window should be opened based on props
+      this.debugShader();
+
+      const shaderLog = await this.getCompilationInfo();
       log.error(`Shader compilation error: ${error.message}`, shaderLog)();
       // Note: Even though this error is asynchronous and thrown after the constructor completes,
       // it will result in a useful stack trace leading back to the constructor
@@ -36,37 +39,29 @@ export default class WebGPUShader extends Shader {
     }
   }
 
-  destroy() {
+  override destroy(): void {
+    // Note: WebGPU does not offer a method to destroy shaders
     // this.handle.destroy();
+    // @ts-expect-error readonly
+    this.handle = null;
+  }
+
+  /** Returns compilation info for this shader */
+  async getCompilationInfo(): Promise<readonly CompilerMessage[]> {
+    const compilationInfo = await this.handle.getCompilationInfo();
+    return compilationInfo.messages;
   }
 
+  // PRIVATE METHODS
+
   protected createHandle(): GPUShaderModule {
     const {source} = this.props;
 
-    let language = this.props.language;
-    // Compile from src
-    if (!language) {
-      // wgsl uses C++ "auto" style arrow notation
-      language = source.includes('->') ? 'wgsl' : 'glsl';
+    const isGLSL = source.includes('#version');
+    if (this.props.language === 'glsl' || isGLSL) {
+      throw new Error('GLSL shaders are not supported in WebGPU');
     }
 
-    switch(language) {
-      case 'wgsl':
-        return this.device.handle.createShaderModule({code: source});
-      case 'glsl':
-        return this.device.handle.createShaderModule({
-          code: source,
-          // @ts-expect-error
-          transform: (glsl) => this.device.glslang.compileGLSL(glsl, type)
-        });
-      default:
-        throw new Error(language);
-    }
-  }
-
-  /** Returns compilation info for this shader */
-  async compilationInfo(): Promise<readonly CompilerMessage[]> {
-    const compilationInfo = await this.handle.compilationInfo();
-    return compilationInfo.messages;
+    return this.device.handle.createShaderModule({code: source});
   }
 }