three-stdlib 2.15.1 → 2.16.0

package/renderers/webgpu/WebGPURenderPipelines.js

@@ -1,6 +1,6 @@
-import { GPUInputStepMode, OneMinusBlendColorFactor, BlendColorFactor, GPUColorWriteFlags, GPUPrimitiveTopology, GPUStencilOperation, GPUVertexFormat, GPUIndexFormat, GPUBlendFactor, GPUBlendOperation, GPUTextureFormat, GPUCompareFunction, GPUFrontFace, GPUCullMode } from './constants.js';
-import { NoBlending, CustomBlending, MultiplyBlending, SubtractiveBlending, AdditiveBlending, NormalBlending, SrcAlphaSaturateFactor, OneMinusDstAlphaFactor, DstAlphaFactor, OneMinusDstColorFactor, DstColorFactor, OneMinusSrcAlphaFactor, SrcAlphaFactor, OneMinusSrcColorFactor, SrcColorFactor, OneFactor, ZeroFactor, MaxEquation, MinEquation, ReverseSubtractEquation, SubtractEquation, AddEquation, NotEqualDepth, GreaterDepth, GreaterEqualDepth, EqualDepth, LessEqualDepth, LessDepth, AlwaysDepth, NeverDepth, DoubleSide, BackSide, FrontSide, NotEqualStencilFunc, GreaterStencilFunc, GreaterEqualStencilFunc, EqualStencilFunc, LessEqualStencilFunc, LessStencilFunc, AlwaysStencilFunc, NeverStencilFunc, DecrementWrapStencilOp, IncrementWrapStencilOp, DecrementStencilOp, IncrementStencilOp, InvertStencilOp, ReplaceStencilOp, ZeroStencilOp, KeepStencilOp } from 'three';
-
+"use strict";
+const constants = require("./constants.js");
+const THREE = require("three");
 class WebGPURenderPipelines {
   constructor(renderer, properties, device, glslang, sampleCount, nodes) {
     this.renderer = renderer;
@@ -9,115 +9,76 @@ class WebGPURenderPipelines {
     this.glslang = glslang;
     this.sampleCount = sampleCount;
     this.nodes = nodes;
-    this.pipelines = new WeakMap();
-    this.shaderAttributes = new WeakMap();
+    this.pipelines = /* @__PURE__ */ new WeakMap();
+    this.shaderAttributes = /* @__PURE__ */ new WeakMap();
     this.shaderModules = {
-      vertex: new Map(),
-      fragment: new Map()
+      vertex: /* @__PURE__ */ new Map(),
+      fragment: /* @__PURE__ */ new Map()
     };
   }
-
   get(object) {
-    // @TODO: Avoid a 1:1 relationship between pipelines and objects. It's necessary
-    // to check various conditions in order to request an appropriate pipeline.
-    //
-    // - material's version and node configuration
-    // - environment map (material)
-    // - fog and environment (scene)
-    // - output encoding (renderer)
-    // - light state
-    // - clipping planes
-    //
-    // The renderer needs to manage multiple pipelines per object so
-    // GPUDevice.createRenderPipeline() is only called when no pipeline exists for the
-    // current configuration.
     let pipeline = this.pipelines.get(object);
-
-    if (pipeline === undefined) {
+    if (pipeline === void 0) {
       const device = this.device;
       const properties = this.properties;
-      const material = object.material; // get shader
-
-      const nodeBuilder = this.nodes.get(material); // shader modules
-
+      const material = object.material;
+      const nodeBuilder = this.nodes.get(material);
       const glslang = this.glslang;
       let moduleVertex = this.shaderModules.vertex.get(nodeBuilder.vertexShader);
-
-      if (moduleVertex === undefined) {
-        const byteCodeVertex = glslang.compileGLSL(nodeBuilder.vertexShader, 'vertex');
+      if (moduleVertex === void 0) {
+        const byteCodeVertex = glslang.compileGLSL(nodeBuilder.vertexShader, "vertex");
         moduleVertex = {
-          module: device.createShaderModule({
-            code: byteCodeVertex
-          }),
-          entryPoint: 'main'
+          module: device.createShaderModule({ code: byteCodeVertex }),
+          entryPoint: "main"
         };
         this.shaderModules.vertex.set(nodeBuilder.vertexShader, moduleVertex);
       }
-
       let moduleFragment = this.shaderModules.fragment.get(nodeBuilder.fragmentShader);
-
-      if (moduleFragment === undefined) {
-        const byteCodeFragment = glslang.compileGLSL(nodeBuilder.fragmentShader, 'fragment');
+      if (moduleFragment === void 0) {
+        const byteCodeFragment = glslang.compileGLSL(nodeBuilder.fragmentShader, "fragment");
         moduleFragment = {
-          module: device.createShaderModule({
-            code: byteCodeFragment
-          }),
-          entryPoint: 'main'
+          module: device.createShaderModule({ code: byteCodeFragment }),
+          entryPoint: "main"
         };
         this.shaderModules.fragment.set(nodeBuilder.fragmentShader, moduleFragment);
-      } // dispose material
-
-
+      }
       const materialProperties = properties.get(material);
-
-      if (materialProperties.disposeCallback === undefined) {
+      if (materialProperties.disposeCallback === void 0) {
         const disposeCallback = onMaterialDispose.bind(this);
         materialProperties.disposeCallback = disposeCallback;
-        material.addEventListener('dispose', disposeCallback);
-      } // determine shader attributes
-
-
-      const shaderAttributes = this._parseShaderAttributes(nodeBuilder.vertexShader); // vertex buffers
-
-
+        material.addEventListener("dispose", disposeCallback);
+      }
+      const shaderAttributes = this._parseShaderAttributes(nodeBuilder.vertexShader);
       const vertexBuffers = [];
       const geometry = object.geometry;
-
       for (let attribute of shaderAttributes) {
         const name = attribute.name;
         const geometryAttribute = geometry.getAttribute(name);
-        const stepMode = geometryAttribute !== undefined && geometryAttribute.isInstancedBufferAttribute ? GPUInputStepMode.Instance : GPUInputStepMode.Vertex;
+        const stepMode = geometryAttribute !== void 0 && geometryAttribute.isInstancedBufferAttribute ? constants.GPUInputStepMode.Instance : constants.GPUInputStepMode.Vertex;
         vertexBuffers.push({
           arrayStride: attribute.arrayStride,
-          attributes: [{
-            shaderLocation: attribute.slot,
-            offset: 0,
-            format: attribute.format
-          }],
-          stepMode: stepMode
+          attributes: [
+            {
+              shaderLocation: attribute.slot,
+              offset: 0,
+              format: attribute.format
+            }
+          ],
+          stepMode
         });
-      } //
-
-
+      }
       let indexFormat;
-
       if (object.isLine) {
         const count = geometry.index ? geometry.index.count : geometry.attributes.position.count;
-        indexFormat = count > 65535 ? GPUIndexFormat.Uint32 : GPUIndexFormat.Uint16; // define data type for primitive restart value
-      } //
-
-
+        indexFormat = count > 65535 ? constants.GPUIndexFormat.Uint32 : constants.GPUIndexFormat.Uint16;
+      }
       let alphaBlend = {};
       let colorBlend = {};
-
-      if (material.transparent === true && material.blending !== NoBlending) {
+      if (material.transparent === true && material.blending !== THREE.NoBlending) {
         alphaBlend = this._getAlphaBlend(material);
         colorBlend = this._getColorBlend(material);
-      } //
-
-
+      }
       let stencilFront = {};
-
       if (material.stencilWrite === true) {
         stencilFront = {
           compare: this._getStencilCompare(material),
@@ -125,133 +86,122 @@ class WebGPURenderPipelines {
           depthFailOp: this._getStencilOperation(material.stencilZFail),
           passOp: this._getStencilOperation(material.stencilZPass)
         };
-      } // pipeline
-
-
+      }
       const primitiveTopology = this._getPrimitiveTopology(object);
-
       const rasterizationState = this._getRasterizationStateDescriptor(material);
-
       const colorWriteMask = this._getColorWriteMask(material);
-
       const depthCompare = this._getDepthCompare(material);
-
       const colorFormat = this._getColorFormat(this.renderer);
-
       const depthStencilFormat = this._getDepthStencilFormat(this.renderer);
-
       pipeline = device.createRenderPipeline({
         vertexStage: moduleVertex,
         fragmentStage: moduleFragment,
-        primitiveTopology: primitiveTopology,
-        rasterizationState: rasterizationState,
-        colorStates: [{
-          format: colorFormat,
-          alphaBlend: alphaBlend,
-          colorBlend: colorBlend,
-          writeMask: colorWriteMask
-        }],
+        primitiveTopology,
+        rasterizationState,
+        colorStates: [
+          {
+            format: colorFormat,
+            alphaBlend,
+            colorBlend,
+            writeMask: colorWriteMask
+          }
+        ],
         depthStencilState: {
           format: depthStencilFormat,
           depthWriteEnabled: material.depthWrite,
-          depthCompare: depthCompare,
-          stencilFront: stencilFront,
+          depthCompare,
+          stencilFront,
           stencilBack: {},
-          // three.js does not provide an API to configure the back function (gl.stencilFuncSeparate() was never used)
           stencilReadMask: material.stencilFuncMask,
           stencilWriteMask: material.stencilWriteMask
         },
         vertexState: {
-          indexFormat: indexFormat,
-          vertexBuffers: vertexBuffers
+          indexFormat,
+          vertexBuffers
         },
         sampleCount: this.sampleCount
       });
       this.pipelines.set(object, pipeline);
       this.shaderAttributes.set(pipeline, shaderAttributes);
     }
-
     return pipeline;
   }
-
   getShaderAttributes(pipeline) {
     return this.shaderAttributes.get(pipeline);
   }
-
   dispose() {
-    this.pipelines = new WeakMap();
-    this.shaderAttributes = new WeakMap();
+    this.pipelines = /* @__PURE__ */ new WeakMap();
+    this.shaderAttributes = /* @__PURE__ */ new WeakMap();
     this.shaderModules = {
-      vertex: new Map(),
-      fragment: new Map()
+      vertex: /* @__PURE__ */ new Map(),
+      fragment: /* @__PURE__ */ new Map()
     };
   }
-
   _getArrayStride(type) {
-    // @TODO: This code is GLSL specific. We need to update when we switch to WGSL.
-    if (type === 'float') return 4;
-    if (type === 'vec2') return 8;
-    if (type === 'vec3') return 12;
-    if (type === 'vec4') return 16;
-    if (type === 'int') return 4;
-    if (type === 'ivec2') return 8;
-    if (type === 'ivec3') return 12;
-    if (type === 'ivec4') return 16;
-    if (type === 'uint') return 4;
-    if (type === 'uvec2') return 8;
-    if (type === 'uvec3') return 12;
-    if (type === 'uvec4') return 16;
-    console.error('THREE.WebGPURenderer: Shader variable type not supported yet.', type);
+    if (type === "float")
+      return 4;
+    if (type === "vec2")
+      return 8;
+    if (type === "vec3")
+      return 12;
+    if (type === "vec4")
+      return 16;
+    if (type === "int")
+      return 4;
+    if (type === "ivec2")
+      return 8;
+    if (type === "ivec3")
+      return 12;
+    if (type === "ivec4")
+      return 16;
+    if (type === "uint")
+      return 4;
+    if (type === "uvec2")
+      return 8;
+    if (type === "uvec3")
+      return 12;
+    if (type === "uvec4")
+      return 16;
+    console.error("THREE.WebGPURenderer: Shader variable type not supported yet.", type);
   }
-
   _getAlphaBlend(material) {
     const blending = material.blending;
     const premultipliedAlpha = material.premultipliedAlpha;
-    let alphaBlend = undefined;
-
+    let alphaBlend = void 0;
     switch (blending) {
-      case NormalBlending:
+      case THREE.NormalBlending:
         if (premultipliedAlpha === false) {
           alphaBlend = {
-            srcFactor: GPUBlendFactor.One,
-            dstFactor: GPUBlendFactor.OneMinusSrcAlpha,
-            operation: GPUBlendOperation.Add
+            srcFactor: constants.GPUBlendFactor.One,
+            dstFactor: constants.GPUBlendFactor.OneMinusSrcAlpha,
+            operation: constants.GPUBlendOperation.Add
           };
         }
-
         break;
-
-      case AdditiveBlending:
-        // no alphaBlend settings
+      case THREE.AdditiveBlending:
         break;
-
-      case SubtractiveBlending:
+      case THREE.SubtractiveBlending:
         if (premultipliedAlpha === true) {
           alphaBlend = {
-            srcFactor: GPUBlendFactor.OneMinusSrcColor,
-            dstFactor: GPUBlendFactor.OneMinusSrcAlpha,
-            operation: GPUBlendOperation.Add
+            srcFactor: constants.GPUBlendFactor.OneMinusSrcColor,
+            dstFactor: constants.GPUBlendFactor.OneMinusSrcAlpha,
+            operation: constants.GPUBlendOperation.Add
           };
         }
-
         break;
-
-      case MultiplyBlending:
+      case THREE.MultiplyBlending:
         if (premultipliedAlpha === true) {
           alphaBlend = {
-            srcFactor: GPUBlendFactor.Zero,
-            dstFactor: GPUBlendFactor.SrcAlpha,
-            operation: GPUBlendOperation.Add
+            srcFactor: constants.GPUBlendFactor.Zero,
+            dstFactor: constants.GPUBlendFactor.SrcAlpha,
+            operation: constants.GPUBlendOperation.Add
           };
         }
-
         break;
-
-      case CustomBlending:
+      case THREE.CustomBlending:
         const blendSrcAlpha = material.blendSrcAlpha;
         const blendDstAlpha = material.blendDstAlpha;
         const blendEquationAlpha = material.blendEquationAlpha;
-
         if (blendSrcAlpha !== null && blendDstAlpha !== null && blendEquationAlpha !== null) {
           alphaBlend = {
             srcFactor: this._getBlendFactor(blendSrcAlpha),
@@ -259,110 +209,82 @@ class WebGPURenderPipelines {
             operation: this._getBlendOperation(blendEquationAlpha)
           };
         }
-
         break;
-
       default:
-        console.error('THREE.WebGPURenderer: Blending not supported.', blending);
+        console.error("THREE.WebGPURenderer: Blending not supported.", blending);
     }
-
     return alphaBlend;
   }
-
   _getBlendFactor(blend) {
     let blendFactor;
-
     switch (blend) {
-      case ZeroFactor:
-        blendFactor = GPUBlendFactor.Zero;
+      case THREE.ZeroFactor:
+        blendFactor = constants.GPUBlendFactor.Zero;
         break;
-
-      case OneFactor:
-        blendFactor = GPUBlendFactor.One;
+      case THREE.OneFactor:
+        blendFactor = constants.GPUBlendFactor.One;
         break;
-
-      case SrcColorFactor:
-        blendFactor = GPUBlendFactor.SrcColor;
+      case THREE.SrcColorFactor:
+        blendFactor = constants.GPUBlendFactor.SrcColor;
         break;
-
-      case OneMinusSrcColorFactor:
-        blendFactor = GPUBlendFactor.OneMinusSrcColor;
+      case THREE.OneMinusSrcColorFactor:
+        blendFactor = constants.GPUBlendFactor.OneMinusSrcColor;
         break;
-
-      case SrcAlphaFactor:
-        blendFactor = GPUBlendFactor.SrcAlpha;
+      case THREE.SrcAlphaFactor:
+        blendFactor = constants.GPUBlendFactor.SrcAlpha;
         break;
-
-      case OneMinusSrcAlphaFactor:
-        blendFactor = GPUBlendFactor.OneMinusSrcAlpha;
+      case THREE.OneMinusSrcAlphaFactor:
+        blendFactor = constants.GPUBlendFactor.OneMinusSrcAlpha;
         break;
-
-      case DstColorFactor:
-        blendFactor = GPUBlendFactor.DstColor;
+      case THREE.DstColorFactor:
+        blendFactor = constants.GPUBlendFactor.DstColor;
         break;
-
-      case OneMinusDstColorFactor:
-        blendFactor = GPUBlendFactor.OneMinusDstColor;
+      case THREE.OneMinusDstColorFactor:
+        blendFactor = constants.GPUBlendFactor.OneMinusDstColor;
         break;
-
-      case DstAlphaFactor:
-        blendFactor = GPUBlendFactor.DstAlpha;
+      case THREE.DstAlphaFactor:
+        blendFactor = constants.GPUBlendFactor.DstAlpha;
         break;
-
-      case OneMinusDstAlphaFactor:
-        blendFactor = GPUBlendFactor.OneMinusDstAlpha;
+      case THREE.OneMinusDstAlphaFactor:
+        blendFactor = constants.GPUBlendFactor.OneMinusDstAlpha;
         break;
-
-      case SrcAlphaSaturateFactor:
-        blendFactor = GPUBlendFactor.SrcAlphaSaturated;
+      case THREE.SrcAlphaSaturateFactor:
+        blendFactor = constants.GPUBlendFactor.SrcAlphaSaturated;
         break;
-
-      case BlendColorFactor:
-        blendFactor = GPUBlendFactor.BlendColor;
+      case constants.BlendColorFactor:
+        blendFactor = constants.GPUBlendFactor.BlendColor;
         break;
-
-      case OneMinusBlendColorFactor:
-        blendFactor = GPUBlendFactor.OneMinusBlendColor;
+      case constants.OneMinusBlendColorFactor:
+        blendFactor = constants.GPUBlendFactor.OneMinusBlendColor;
         break;
-
       default:
-        console.error('THREE.WebGPURenderer: Blend factor not supported.', blend);
+        console.error("THREE.WebGPURenderer: Blend factor not supported.", blend);
     }
-
     return blendFactor;
   }
-
   _getBlendOperation(blendEquation) {
     let blendOperation;
-
     switch (blendEquation) {
-      case AddEquation:
-        blendOperation = GPUBlendOperation.Add;
+      case THREE.AddEquation:
+        blendOperation = constants.GPUBlendOperation.Add;
         break;
-
-      case SubtractEquation:
-        blendOperation = GPUBlendOperation.Subtract;
+      case THREE.SubtractEquation:
+        blendOperation = constants.GPUBlendOperation.Subtract;
         break;
-
-      case ReverseSubtractEquation:
-        blendOperation = GPUBlendOperation.ReverseSubtract;
+      case THREE.ReverseSubtractEquation:
+        blendOperation = constants.GPUBlendOperation.ReverseSubtract;
         break;
-
-      case MinEquation:
-        blendOperation = GPUBlendOperation.Min;
+      case THREE.MinEquation:
+        blendOperation = constants.GPUBlendOperation.Min;
         break;
-
-      case MaxEquation:
-        blendOperation = GPUBlendOperation.Max;
+      case THREE.MaxEquation:
+        blendOperation = constants.GPUBlendOperation.Max;
         break;
-
       default:
-        console.error('THREE.WebGPURenderer: Blend equation not supported.', blendEquation);
+        console.error("THREE.WebGPURenderer: Blend equation not supported.", blendEquation);
     }
-
     return blendOperation;
   }
-
   _getColorBlend(material) {
     const blending = material.blending;
     const premultipliedAlpha = material.premultipliedAlpha;
@@ -371,289 +293,241 @@ class WebGPURenderPipelines {
       dstFactor: null,
       operation: null
     };
-
     switch (blending) {
-      case NormalBlending:
-        colorBlend.srcFactor = premultipliedAlpha === true ? GPUBlendFactor.One : GPUBlendFactor.SrcAlpha;
-        colorBlend.dstFactor = GPUBlendFactor.OneMinusSrcAlpha;
-        colorBlend.operation = GPUBlendOperation.Add;
-        break;
-
-      case AdditiveBlending:
-        colorBlend.srcFactor = premultipliedAlpha === true ? GPUBlendFactor.One : GPUBlendFactor.SrcAlpha;
-        colorBlend.operation = GPUBlendOperation.Add;
-        break;
-
-      case SubtractiveBlending:
-        colorBlend.srcFactor = GPUBlendFactor.Zero;
-        colorBlend.dstFactor = premultipliedAlpha === true ? GPUBlendFactor.Zero : GPUBlendFactor.OneMinusSrcColor;
-        colorBlend.operation = GPUBlendOperation.Add;
-        break;
-
-      case MultiplyBlending:
-        colorBlend.srcFactor = GPUBlendFactor.Zero;
-        colorBlend.dstFactor = GPUBlendFactor.SrcColor;
-        colorBlend.operation = GPUBlendOperation.Add;
-        break;
-
-      case CustomBlending:
+      case THREE.NormalBlending:
+        colorBlend.srcFactor = premultipliedAlpha === true ? constants.GPUBlendFactor.One : constants.GPUBlendFactor.SrcAlpha;
+        colorBlend.dstFactor = constants.GPUBlendFactor.OneMinusSrcAlpha;
+        colorBlend.operation = constants.GPUBlendOperation.Add;
+        break;
+      case THREE.AdditiveBlending:
+        colorBlend.srcFactor = premultipliedAlpha === true ? constants.GPUBlendFactor.One : constants.GPUBlendFactor.SrcAlpha;
+        colorBlend.operation = constants.GPUBlendOperation.Add;
+        break;
+      case THREE.SubtractiveBlending:
+        colorBlend.srcFactor = constants.GPUBlendFactor.Zero;
+        colorBlend.dstFactor = premultipliedAlpha === true ? constants.GPUBlendFactor.Zero : constants.GPUBlendFactor.OneMinusSrcColor;
+        colorBlend.operation = constants.GPUBlendOperation.Add;
+        break;
+      case THREE.MultiplyBlending:
+        colorBlend.srcFactor = constants.GPUBlendFactor.Zero;
+        colorBlend.dstFactor = constants.GPUBlendFactor.SrcColor;
+        colorBlend.operation = constants.GPUBlendOperation.Add;
+        break;
+      case THREE.CustomBlending:
         colorBlend.srcFactor = this._getBlendFactor(material.blendSrc);
         colorBlend.dstFactor = this._getBlendFactor(material.blendDst);
         colorBlend.operation = this._getBlendOperation(material.blendEquation);
         break;
-
       default:
-        console.error('THREE.WebGPURenderer: Blending not supported.', blending);
+        console.error("THREE.WebGPURenderer: Blending not supported.", blending);
     }
-
     return colorBlend;
   }
-
   _getColorFormat(renderer) {
     let format;
     const renderTarget = renderer.getRenderTarget();
-
     if (renderTarget !== null) {
       const renderTargetProperties = this.properties.get(renderTarget);
       format = renderTargetProperties.colorTextureFormat;
     } else {
-      format = GPUTextureFormat.BRGA8Unorm; // default swap chain format
+      format = constants.GPUTextureFormat.BRGA8Unorm;
     }
-
     return format;
   }
-
   _getColorWriteMask(material) {
-    return material.colorWrite === true ? GPUColorWriteFlags.All : GPUColorWriteFlags.None;
+    return material.colorWrite === true ? constants.GPUColorWriteFlags.All : constants.GPUColorWriteFlags.None;
   }
-
   _getDepthCompare(material) {
     let depthCompare;
-
     if (material.depthTest === false) {
-      depthCompare = GPUCompareFunction.Always;
+      depthCompare = constants.GPUCompareFunction.Always;
     } else {
       const depthFunc = material.depthFunc;
-
       switch (depthFunc) {
-        case NeverDepth:
-          depthCompare = GPUCompareFunction.Never;
+        case THREE.NeverDepth:
+          depthCompare = constants.GPUCompareFunction.Never;
           break;
-
-        case AlwaysDepth:
-          depthCompare = GPUCompareFunction.Always;
+        case THREE.AlwaysDepth:
+          depthCompare = constants.GPUCompareFunction.Always;
           break;
-
-        case LessDepth:
-          depthCompare = GPUCompareFunction.Less;
+        case THREE.LessDepth:
+          depthCompare = constants.GPUCompareFunction.Less;
           break;
-
-        case LessEqualDepth:
-          depthCompare = GPUCompareFunction.LessEqual;
+        case THREE.LessEqualDepth:
+          depthCompare = constants.GPUCompareFunction.LessEqual;
           break;
-
-        case EqualDepth:
-          depthCompare = GPUCompareFunction.Equal;
+        case THREE.EqualDepth:
+          depthCompare = constants.GPUCompareFunction.Equal;
           break;
-
-        case GreaterEqualDepth:
-          depthCompare = GPUCompareFunction.GreaterEqual;
+        case THREE.GreaterEqualDepth:
+          depthCompare = constants.GPUCompareFunction.GreaterEqual;
           break;
-
-        case GreaterDepth:
-          depthCompare = GPUCompareFunction.Greater;
+        case THREE.GreaterDepth:
+          depthCompare = constants.GPUCompareFunction.Greater;
           break;
-
-        case NotEqualDepth:
-          depthCompare = GPUCompareFunction.NotEqual;
+        case THREE.NotEqualDepth:
+          depthCompare = constants.GPUCompareFunction.NotEqual;
           break;
-
         default:
-          console.error('THREE.WebGPURenderer: Invalid depth function.', depthFunc);
+          console.error("THREE.WebGPURenderer: Invalid depth function.", depthFunc);
       }
     }
-
     return depthCompare;
   }
-
   _getDepthStencilFormat(renderer) {
     let format;
     const renderTarget = renderer.getRenderTarget();
-
     if (renderTarget !== null) {
       const renderTargetProperties = this.properties.get(renderTarget);
       format = renderTargetProperties.depthTextureFormat;
     } else {
-      format = GPUTextureFormat.Depth24PlusStencil8;
+      format = constants.GPUTextureFormat.Depth24PlusStencil8;
     }
-
     return format;
   }
-
   _getPrimitiveTopology(object) {
-    if (object.isMesh) return GPUPrimitiveTopology.TriangleList;else if (object.isPoints) return GPUPrimitiveTopology.PointList;else if (object.isLine) return GPUPrimitiveTopology.LineStrip;else if (object.isLineSegments) return GPUPrimitiveTopology.LineList;
+    if (object.isMesh)
+      return constants.GPUPrimitiveTopology.TriangleList;
+    else if (object.isPoints)
+      return constants.GPUPrimitiveTopology.PointList;
+    else if (object.isLine)
+      return constants.GPUPrimitiveTopology.LineStrip;
+    else if (object.isLineSegments)
+      return constants.GPUPrimitiveTopology.LineList;
   }
-
   _getRasterizationStateDescriptor(material) {
     const descriptor = {};
-
     switch (material.side) {
-      case FrontSide:
-        descriptor.frontFace = GPUFrontFace.CCW;
-        descriptor.cullMode = GPUCullMode.Back;
+      case THREE.FrontSide:
+        descriptor.frontFace = constants.GPUFrontFace.CCW;
+        descriptor.cullMode = constants.GPUCullMode.Back;
         break;
-
-      case BackSide:
-        descriptor.frontFace = GPUFrontFace.CW;
-        descriptor.cullMode = GPUCullMode.Back;
+      case THREE.BackSide:
+        descriptor.frontFace = constants.GPUFrontFace.CW;
+        descriptor.cullMode = constants.GPUCullMode.Back;
         break;
-
-      case DoubleSide:
-        descriptor.frontFace = GPUFrontFace.CCW;
-        descriptor.cullMode = GPUCullMode.None;
+      case THREE.DoubleSide:
+        descriptor.frontFace = constants.GPUFrontFace.CCW;
+        descriptor.cullMode = constants.GPUCullMode.None;
         break;
-
       default:
-        console.error('THREE.WebGPURenderer: Unknown Material.side value.', material.side);
+        console.error("THREE.WebGPURenderer: Unknown Material.side value.", material.side);
         break;
     }
-
     return descriptor;
   }
-
   _getStencilCompare(material) {
     let stencilCompare;
     const stencilFunc = material.stencilFunc;
-
     switch (stencilFunc) {
-      case NeverStencilFunc:
-        stencilCompare = GPUCompareFunction.Never;
+      case THREE.NeverStencilFunc:
+        stencilCompare = constants.GPUCompareFunction.Never;
         break;
-
-      case AlwaysStencilFunc:
-        stencilCompare = GPUCompareFunction.Always;
+      case THREE.AlwaysStencilFunc:
+        stencilCompare = constants.GPUCompareFunction.Always;
         break;
-
-      case LessStencilFunc:
-        stencilCompare = GPUCompareFunction.Less;
+      case THREE.LessStencilFunc:
+        stencilCompare = constants.GPUCompareFunction.Less;
         break;
-
-      case LessEqualStencilFunc:
-        stencilCompare = GPUCompareFunction.LessEqual;
+      case THREE.LessEqualStencilFunc:
+        stencilCompare = constants.GPUCompareFunction.LessEqual;
         break;
-
-      case EqualStencilFunc:
-        stencilCompare = GPUCompareFunction.Equal;
+      case THREE.EqualStencilFunc:
+        stencilCompare = constants.GPUCompareFunction.Equal;
         break;
-
-      case GreaterEqualStencilFunc:
-        stencilCompare = GPUCompareFunction.GreaterEqual;
+      case THREE.GreaterEqualStencilFunc:
+        stencilCompare = constants.GPUCompareFunction.GreaterEqual;
         break;
-
-      case GreaterStencilFunc:
-        stencilCompare = GPUCompareFunction.Greater;
+      case THREE.GreaterStencilFunc:
+        stencilCompare = constants.GPUCompareFunction.Greater;
         break;
-
-      case NotEqualStencilFunc:
-        stencilCompare = GPUCompareFunction.NotEqual;
+      case THREE.NotEqualStencilFunc:
+        stencilCompare = constants.GPUCompareFunction.NotEqual;
         break;
-
       default:
-        console.error('THREE.WebGPURenderer: Invalid stencil function.', stencilFunc);
+        console.error("THREE.WebGPURenderer: Invalid stencil function.", stencilFunc);
     }
-
     return stencilCompare;
   }
-
   _getStencilOperation(op) {
     let stencilOperation;
-
     switch (op) {
-      case KeepStencilOp:
-        stencilOperation = GPUStencilOperation.Keep;
+      case THREE.KeepStencilOp:
+        stencilOperation = constants.GPUStencilOperation.Keep;
         break;
-
-      case ZeroStencilOp:
-        stencilOperation = GPUStencilOperation.Zero;
+      case THREE.ZeroStencilOp:
+        stencilOperation = constants.GPUStencilOperation.Zero;
         break;
-
-      case ReplaceStencilOp:
-        stencilOperation = GPUStencilOperation.Replace;
+      case THREE.ReplaceStencilOp:
+        stencilOperation = constants.GPUStencilOperation.Replace;
         break;
-
-      case InvertStencilOp:
-        stencilOperation = GPUStencilOperation.Invert;
+      case THREE.InvertStencilOp:
+        stencilOperation = constants.GPUStencilOperation.Invert;
         break;
-
-      case IncrementStencilOp:
-        stencilOperation = GPUStencilOperation.IncrementClamp;
+      case THREE.IncrementStencilOp:
+        stencilOperation = constants.GPUStencilOperation.IncrementClamp;
         break;
-
-      case DecrementStencilOp:
-        stencilOperation = GPUStencilOperation.DecrementClamp;
+      case THREE.DecrementStencilOp:
+        stencilOperation = constants.GPUStencilOperation.DecrementClamp;
         break;
-
-      case IncrementWrapStencilOp:
-        stencilOperation = GPUStencilOperation.IncrementWrap;
+      case THREE.IncrementWrapStencilOp:
+        stencilOperation = constants.GPUStencilOperation.IncrementWrap;
         break;
-
-      case DecrementWrapStencilOp:
-        stencilOperation = GPUStencilOperation.DecrementWrap;
+      case THREE.DecrementWrapStencilOp:
+        stencilOperation = constants.GPUStencilOperation.DecrementWrap;
         break;
-
       default:
-        console.error('THREE.WebGPURenderer: Invalid stencil operation.', stencilOperation);
+        console.error("THREE.WebGPURenderer: Invalid stencil operation.", stencilOperation);
     }
-
     return stencilOperation;
   }
-
   _getVertexFormat(type) {
-    // @TODO: This code is GLSL specific. We need to update when we switch to WGSL.
-    if (type === 'float') return GPUVertexFormat.Float;
-    if (type === 'vec2') return GPUVertexFormat.Float2;
-    if (type === 'vec3') return GPUVertexFormat.Float3;
-    if (type === 'vec4') return GPUVertexFormat.Float4;
-    if (type === 'int') return GPUVertexFormat.Int;
-    if (type === 'ivec2') return GPUVertexFormat.Int2;
-    if (type === 'ivec3') return GPUVertexFormat.Int3;
-    if (type === 'ivec4') return GPUVertexFormat.Int4;
-    if (type === 'uint') return GPUVertexFormat.UInt;
-    if (type === 'uvec2') return GPUVertexFormat.UInt2;
-    if (type === 'uvec3') return GPUVertexFormat.UInt3;
-    if (type === 'uvec4') return GPUVertexFormat.UInt4;
-    console.error('THREE.WebGPURenderer: Shader variable type not supported yet.', type);
+    if (type === "float")
+      return constants.GPUVertexFormat.Float;
+    if (type === "vec2")
+      return constants.GPUVertexFormat.Float2;
+    if (type === "vec3")
+      return constants.GPUVertexFormat.Float3;
+    if (type === "vec4")
+      return constants.GPUVertexFormat.Float4;
+    if (type === "int")
+      return constants.GPUVertexFormat.Int;
+    if (type === "ivec2")
+      return constants.GPUVertexFormat.Int2;
+    if (type === "ivec3")
+      return constants.GPUVertexFormat.Int3;
+    if (type === "ivec4")
+      return constants.GPUVertexFormat.Int4;
+    if (type === "uint")
+      return constants.GPUVertexFormat.UInt;
+    if (type === "uvec2")
+      return constants.GPUVertexFormat.UInt2;
+    if (type === "uvec3")
+      return constants.GPUVertexFormat.UInt3;
+    if (type === "uvec4")
+      return constants.GPUVertexFormat.UInt4;
+    console.error("THREE.WebGPURenderer: Shader variable type not supported yet.", type);
   }
-
   _parseShaderAttributes(shader) {
-    // find "layout (location = num) in type name" in vertex shader
     const regex = /\s*layout\s*\(\s*location\s*=\s*(?<location>[0-9]+)\s*\)\s*in\s+(?<type>\w+)\s+(?<name>\w+)\s*;/gim;
     let shaderAttribute = null;
     const attributes = [];
-
     while (shaderAttribute = regex.exec(shader)) {
       const shaderLocation = parseInt(shaderAttribute.groups.location);
-
       const arrayStride = this._getArrayStride(shaderAttribute.groups.type);
-
       const vertexFormat = this._getVertexFormat(shaderAttribute.groups.type);
-
       attributes.push({
         name: shaderAttribute.groups.name,
-        arrayStride: arrayStride,
+        arrayStride,
         slot: shaderLocation,
         format: vertexFormat
       });
-    } // the sort ensures to setup vertex buffers in the correct order
-
-
-    return attributes.sort(function (a, b) {
+    }
+    return attributes.sort(function(a, b) {
       return a.slot - b.slot;
     });
   }
-
 }
-
 function onMaterialDispose(event) {
   const properties = this.properties;
   const nodes = this.nodes;
@@ -661,11 +535,10 @@ function onMaterialDispose(event) {
   const material = event.target;
   const materialProperties = properties.get(material);
   const nodeBuilder = nodes.get(material);
-  material.removeEventListener('dispose', materialProperties.disposeCallback);
+  material.removeEventListener("dispose", materialProperties.disposeCallback);
   properties.remove(material);
   nodes.remove(material);
   shaderModules.vertex.delete(nodeBuilder.vertexShader);
-  shaderModules.fragment.delete(nodeBuilder.fragmentShader); // @TODO: still needed remove bindings and pipeline
+  shaderModules.fragment.delete(nodeBuilder.fragmentShader);
 }
-
-export default WebGPURenderPipelines;
+module.exports = WebGPURenderPipelines;