three-stdlib 2.15.0 → 2.15.2

package/renderers/webgpu/WebGPURenderPipelines.mjs

@@ -0,0 +1,545 @@
+import { GPUInputStepMode, GPUIndexFormat, GPUBlendFactor, GPUBlendOperation, OneMinusBlendColorFactor, BlendColorFactor, GPUTextureFormat, GPUColorWriteFlags, GPUCompareFunction, GPUPrimitiveTopology, GPUFrontFace, GPUCullMode, GPUStencilOperation, GPUVertexFormat } from "./constants.mjs";
+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";
+class WebGPURenderPipelines {
+  constructor(renderer, properties, device, glslang, sampleCount, nodes) {
+    this.renderer = renderer;
+    this.properties = properties;
+    this.device = device;
+    this.glslang = glslang;
+    this.sampleCount = sampleCount;
+    this.nodes = nodes;
+    this.pipelines = /* @__PURE__ */ new WeakMap();
+    this.shaderAttributes = /* @__PURE__ */ new WeakMap();
+    this.shaderModules = {
+      vertex: /* @__PURE__ */ new Map(),
+      fragment: /* @__PURE__ */ new Map()
+    };
+  }
+  get(object) {
+    let pipeline = this.pipelines.get(object);
+    if (pipeline === void 0) {
+      const device = this.device;
+      const properties = this.properties;
+      const material = object.material;
+      const nodeBuilder = this.nodes.get(material);
+      const glslang = this.glslang;
+      let moduleVertex = this.shaderModules.vertex.get(nodeBuilder.vertexShader);
+      if (moduleVertex === void 0) {
+        const byteCodeVertex = glslang.compileGLSL(nodeBuilder.vertexShader, "vertex");
+        moduleVertex = {
+          module: device.createShaderModule({ code: byteCodeVertex }),
+          entryPoint: "main"
+        };
+        this.shaderModules.vertex.set(nodeBuilder.vertexShader, moduleVertex);
+      }
+      let moduleFragment = this.shaderModules.fragment.get(nodeBuilder.fragmentShader);
+      if (moduleFragment === void 0) {
+        const byteCodeFragment = glslang.compileGLSL(nodeBuilder.fragmentShader, "fragment");
+        moduleFragment = {
+          module: device.createShaderModule({ code: byteCodeFragment }),
+          entryPoint: "main"
+        };
+        this.shaderModules.fragment.set(nodeBuilder.fragmentShader, moduleFragment);
+      }
+      const materialProperties = properties.get(material);
+      if (materialProperties.disposeCallback === void 0) {
+        const disposeCallback = onMaterialDispose.bind(this);
+        materialProperties.disposeCallback = disposeCallback;
+        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 !== void 0 && geometryAttribute.isInstancedBufferAttribute ? GPUInputStepMode.Instance : GPUInputStepMode.Vertex;
+        vertexBuffers.push({
+          arrayStride: attribute.arrayStride,
+          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;
+      }
+      let alphaBlend = {};
+      let colorBlend = {};
+      if (material.transparent === true && material.blending !== NoBlending) {
+        alphaBlend = this._getAlphaBlend(material);
+        colorBlend = this._getColorBlend(material);
+      }
+      let stencilFront = {};
+      if (material.stencilWrite === true) {
+        stencilFront = {
+          compare: this._getStencilCompare(material),
+          failOp: this._getStencilOperation(material.stencilFail),
+          depthFailOp: this._getStencilOperation(material.stencilZFail),
+          passOp: this._getStencilOperation(material.stencilZPass)
+        };
+      }
+      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,
+        rasterizationState,
+        colorStates: [
+          {
+            format: colorFormat,
+            alphaBlend,
+            colorBlend,
+            writeMask: colorWriteMask
+          }
+        ],
+        depthStencilState: {
+          format: depthStencilFormat,
+          depthWriteEnabled: material.depthWrite,
+          depthCompare,
+          stencilFront,
+          stencilBack: {},
+          stencilReadMask: material.stencilFuncMask,
+          stencilWriteMask: material.stencilWriteMask
+        },
+        vertexState: {
+          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 = /* @__PURE__ */ new WeakMap();
+    this.shaderAttributes = /* @__PURE__ */ new WeakMap();
+    this.shaderModules = {
+      vertex: /* @__PURE__ */ new Map(),
+      fragment: /* @__PURE__ */ new Map()
+    };
+  }
+  _getArrayStride(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 = void 0;
+    switch (blending) {
+      case NormalBlending:
+        if (premultipliedAlpha === false) {
+          alphaBlend = {
+            srcFactor: GPUBlendFactor.One,
+            dstFactor: GPUBlendFactor.OneMinusSrcAlpha,
+            operation: GPUBlendOperation.Add
+          };
+        }
+        break;
+      case AdditiveBlending:
+        break;
+      case SubtractiveBlending:
+        if (premultipliedAlpha === true) {
+          alphaBlend = {
+            srcFactor: GPUBlendFactor.OneMinusSrcColor,
+            dstFactor: GPUBlendFactor.OneMinusSrcAlpha,
+            operation: GPUBlendOperation.Add
+          };
+        }
+        break;
+      case MultiplyBlending:
+        if (premultipliedAlpha === true) {
+          alphaBlend = {
+            srcFactor: GPUBlendFactor.Zero,
+            dstFactor: GPUBlendFactor.SrcAlpha,
+            operation: GPUBlendOperation.Add
+          };
+        }
+        break;
+      case 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),
+            dstFactor: this._getBlendFactor(blendDstAlpha),
+            operation: this._getBlendOperation(blendEquationAlpha)
+          };
+        }
+        break;
+      default:
+        console.error("THREE.WebGPURenderer: Blending not supported.", blending);
+    }
+    return alphaBlend;
+  }
+  _getBlendFactor(blend) {
+    let blendFactor;
+    switch (blend) {
+      case ZeroFactor:
+        blendFactor = GPUBlendFactor.Zero;
+        break;
+      case OneFactor:
+        blendFactor = GPUBlendFactor.One;
+        break;
+      case SrcColorFactor:
+        blendFactor = GPUBlendFactor.SrcColor;
+        break;
+      case OneMinusSrcColorFactor:
+        blendFactor = GPUBlendFactor.OneMinusSrcColor;
+        break;
+      case SrcAlphaFactor:
+        blendFactor = GPUBlendFactor.SrcAlpha;
+        break;
+      case OneMinusSrcAlphaFactor:
+        blendFactor = GPUBlendFactor.OneMinusSrcAlpha;
+        break;
+      case DstColorFactor:
+        blendFactor = GPUBlendFactor.DstColor;
+        break;
+      case OneMinusDstColorFactor:
+        blendFactor = GPUBlendFactor.OneMinusDstColor;
+        break;
+      case DstAlphaFactor:
+        blendFactor = GPUBlendFactor.DstAlpha;
+        break;
+      case OneMinusDstAlphaFactor:
+        blendFactor = GPUBlendFactor.OneMinusDstAlpha;
+        break;
+      case SrcAlphaSaturateFactor:
+        blendFactor = GPUBlendFactor.SrcAlphaSaturated;
+        break;
+      case BlendColorFactor:
+        blendFactor = GPUBlendFactor.BlendColor;
+        break;
+      case OneMinusBlendColorFactor:
+        blendFactor = GPUBlendFactor.OneMinusBlendColor;
+        break;
+      default:
+        console.error("THREE.WebGPURenderer: Blend factor not supported.", blend);
+    }
+    return blendFactor;
+  }
+  _getBlendOperation(blendEquation) {
+    let blendOperation;
+    switch (blendEquation) {
+      case AddEquation:
+        blendOperation = GPUBlendOperation.Add;
+        break;
+      case SubtractEquation:
+        blendOperation = GPUBlendOperation.Subtract;
+        break;
+      case ReverseSubtractEquation:
+        blendOperation = GPUBlendOperation.ReverseSubtract;
+        break;
+      case MinEquation:
+        blendOperation = GPUBlendOperation.Min;
+        break;
+      case MaxEquation:
+        blendOperation = GPUBlendOperation.Max;
+        break;
+      default:
+        console.error("THREE.WebGPURenderer: Blend equation not supported.", blendEquation);
+    }
+    return blendOperation;
+  }
+  _getColorBlend(material) {
+    const blending = material.blending;
+    const premultipliedAlpha = material.premultipliedAlpha;
+    const colorBlend = {
+      srcFactor: null,
+      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:
+        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);
+    }
+    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;
+    }
+    return format;
+  }
+  _getColorWriteMask(material) {
+    return material.colorWrite === true ? GPUColorWriteFlags.All : GPUColorWriteFlags.None;
+  }
+  _getDepthCompare(material) {
+    let depthCompare;
+    if (material.depthTest === false) {
+      depthCompare = GPUCompareFunction.Always;
+    } else {
+      const depthFunc = material.depthFunc;
+      switch (depthFunc) {
+        case NeverDepth:
+          depthCompare = GPUCompareFunction.Never;
+          break;
+        case AlwaysDepth:
+          depthCompare = GPUCompareFunction.Always;
+          break;
+        case LessDepth:
+          depthCompare = GPUCompareFunction.Less;
+          break;
+        case LessEqualDepth:
+          depthCompare = GPUCompareFunction.LessEqual;
+          break;
+        case EqualDepth:
+          depthCompare = GPUCompareFunction.Equal;
+          break;
+        case GreaterEqualDepth:
+          depthCompare = GPUCompareFunction.GreaterEqual;
+          break;
+        case GreaterDepth:
+          depthCompare = GPUCompareFunction.Greater;
+          break;
+        case NotEqualDepth:
+          depthCompare = GPUCompareFunction.NotEqual;
+          break;
+        default:
+          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;
+    }
+    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;
+  }
+  _getRasterizationStateDescriptor(material) {
+    const descriptor = {};
+    switch (material.side) {
+      case FrontSide:
+        descriptor.frontFace = GPUFrontFace.CCW;
+        descriptor.cullMode = GPUCullMode.Back;
+        break;
+      case BackSide:
+        descriptor.frontFace = GPUFrontFace.CW;
+        descriptor.cullMode = GPUCullMode.Back;
+        break;
+      case DoubleSide:
+        descriptor.frontFace = GPUFrontFace.CCW;
+        descriptor.cullMode = GPUCullMode.None;
+        break;
+      default:
+        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;
+        break;
+      case AlwaysStencilFunc:
+        stencilCompare = GPUCompareFunction.Always;
+        break;
+      case LessStencilFunc:
+        stencilCompare = GPUCompareFunction.Less;
+        break;
+      case LessEqualStencilFunc:
+        stencilCompare = GPUCompareFunction.LessEqual;
+        break;
+      case EqualStencilFunc:
+        stencilCompare = GPUCompareFunction.Equal;
+        break;
+      case GreaterEqualStencilFunc:
+        stencilCompare = GPUCompareFunction.GreaterEqual;
+        break;
+      case GreaterStencilFunc:
+        stencilCompare = GPUCompareFunction.Greater;
+        break;
+      case NotEqualStencilFunc:
+        stencilCompare = GPUCompareFunction.NotEqual;
+        break;
+      default:
+        console.error("THREE.WebGPURenderer: Invalid stencil function.", stencilFunc);
+    }
+    return stencilCompare;
+  }
+  _getStencilOperation(op) {
+    let stencilOperation;
+    switch (op) {
+      case KeepStencilOp:
+        stencilOperation = GPUStencilOperation.Keep;
+        break;
+      case ZeroStencilOp:
+        stencilOperation = GPUStencilOperation.Zero;
+        break;
+      case ReplaceStencilOp:
+        stencilOperation = GPUStencilOperation.Replace;
+        break;
+      case InvertStencilOp:
+        stencilOperation = GPUStencilOperation.Invert;
+        break;
+      case IncrementStencilOp:
+        stencilOperation = GPUStencilOperation.IncrementClamp;
+        break;
+      case DecrementStencilOp:
+        stencilOperation = GPUStencilOperation.DecrementClamp;
+        break;
+      case IncrementWrapStencilOp:
+        stencilOperation = GPUStencilOperation.IncrementWrap;
+        break;
+      case DecrementWrapStencilOp:
+        stencilOperation = GPUStencilOperation.DecrementWrap;
+        break;
+      default:
+        console.error("THREE.WebGPURenderer: Invalid stencil operation.", stencilOperation);
+    }
+    return stencilOperation;
+  }
+  _getVertexFormat(type) {
+    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);
+  }
+  _parseShaderAttributes(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,
+        slot: shaderLocation,
+        format: vertexFormat
+      });
+    }
+    return attributes.sort(function(a, b) {
+      return a.slot - b.slot;
+    });
+  }
+}
+function onMaterialDispose(event) {
+  const properties = this.properties;
+  const nodes = this.nodes;
+  const shaderModules = this.shaderModules;
+  const material = event.target;
+  const materialProperties = properties.get(material);
+  const nodeBuilder = nodes.get(material);
+  material.removeEventListener("dispose", materialProperties.disposeCallback);
+  properties.remove(material);
+  nodes.remove(material);
+  shaderModules.vertex.delete(nodeBuilder.vertexShader);
+  shaderModules.fragment.delete(nodeBuilder.fragmentShader);
+}
+export {
+  WebGPURenderPipelines as default
+};