three-stdlib 2.22.9 → 2.23.0

package/dist/renderers/webgpu/constants.mjs

@@ -1,241 +0,0 @@
-const GPUPrimitiveTopology = {
-  PointList: "point-list",
-  LineList: "line-list",
-  LineStrip: "line-strip",
-  TriangleList: "triangle-list",
-  TriangleStrip: "triangle-strip"
-};
-const GPUCompareFunction = {
-  Never: "never",
-  Less: "less",
-  Equal: "equal",
-  LessEqual: "less-equal",
-  Greater: "greater",
-  NotEqual: "not-equal",
-  GreaterEqual: "greater-equal",
-  Always: "always"
-};
-const GPUStoreOp = {
-  Store: "store",
-  Clear: "clear"
-};
-const GPULoadOp = {
-  Load: "load"
-};
-const GPUFrontFace = {
-  CCW: "ccw",
-  CW: "cw"
-};
-const GPUCullMode = {
-  None: "none",
-  Front: "front",
-  Back: "back"
-};
-const GPUIndexFormat = {
-  Uint16: "uint16",
-  Uint32: "uint32"
-};
-const GPUVertexFormat = {
-  Uchar2: "uchar2",
-  Uchar4: "uchar4",
-  Char2: "char2",
-  Char4: "char4",
-  Uchar2Norm: "uchar2norm",
-  Uchar4Norm: "uchar4norm",
-  Char2Norm: "char2norm",
-  Char4Norm: "char4norm",
-  Ushort2: "ushort2",
-  Ushort4: "ushort4",
-  Short2: "short2",
-  Short4: "short4",
-  Ushort2Norm: "ushort2norm",
-  Ushort4Norm: "ushort4norm",
-  Short2Norm: "short2norm",
-  Short4Norm: "short4norm",
-  Half2: "half2",
-  Half4: "half4",
-  Float: "float",
-  Float2: "float2",
-  Float3: "float3",
-  Float4: "float4",
-  Uint: "uint",
-  Uint2: "uint2",
-  Uint3: "uint3",
-  Uint4: "uint4",
-  Int: "int",
-  Int2: "int2",
-  Int3: "int3",
-  Int4: "int4"
-};
-const GPUTextureFormat = {
-  // 8-bit formats
-  R8Unorm: "r8unorm",
-  R8Snorm: "r8snorm",
-  R8Uint: "r8uint",
-  R8Sint: "r8sint",
-  // 16-bit formats
-  R16Uint: "r16uint",
-  R16Sint: "r16sint",
-  R16Float: "r16float",
-  RG8Unorm: "rg8unorm",
-  RG8Snorm: "rg8snorm",
-  RG8Uint: "rg8uint",
-  RG8Sint: "rg8sint",
-  // 32-bit formats
-  R32Uint: "r32uint",
-  R32Sint: "r32sint",
-  R32Float: "r32float",
-  RG16Uint: "rg16uint",
-  RG16Sint: "rg16sint",
-  RG16Float: "rg16float",
-  RGBA8Unorm: "rgba8unorm",
-  RGBA8UnormSRGB: "rgba8unorm-srgb",
-  RGBA8Snorm: "rgba8snorm",
-  RGBA8Uint: "rgba8uint",
-  RGBA8Sint: "rgba8sint",
-  BRGA8Unorm: "bgra8unorm",
-  BRGA8UnormSRGB: "bgra8unorm-srgb",
-  // Packed 32-bit formats
-  RGB9E5UFloat: "rgb9e5ufloat",
-  RGB10A2Unorm: "rgb10a2unorm",
-  RG11B10uFloat: "rgb10a2unorm",
-  // 64-bit formats
-  RG32Uint: "rg32uint",
-  RG32Sint: "rg32sint",
-  RG32Float: "rg32float",
-  RGBA16Uint: "rgba16uint",
-  RGBA16Sint: "rgba16sint",
-  RGBA16Float: "rgba16float",
-  // 128-bit formats
-  RGBA32Uint: "rgba32uint",
-  RGBA32Sint: "rgba32sint",
-  RGBA32Float: "rgba32float",
-  // Depth and stencil formats
-  Stencil8: "stencil8",
-  Depth16Unorm: "depth16unorm",
-  Depth24Plus: "depth24plus",
-  Depth24PlusStencil8: "depth24plus-stencil8",
-  Depth32Float: "depth32float",
-  // BC compressed formats usable if 'texture-compression-bc' is both
-  // supported by the device/user agent and enabled in requestDevice.
-  BC1RGBAUnorm: "bc1-rgba-unorm",
-  BC1RGBAUnormSRGB: "bc1-rgba-unorm-srgb",
-  BC2RGBAUnorm: "bc2-rgba-unorm",
-  BC2RGBAUnormSRGB: "bc2-rgba-unorm-srgb",
-  BC3RGBAUnorm: "bc3-rgba-unorm",
-  BC3RGBAUnormSRGB: "bc3-rgba-unorm-srgb",
-  BC4RUnorm: "bc4-r-unorm",
-  BC4RSNorm: "bc4-r-snorm",
-  BC5RGUnorm: "bc5-rg-unorm",
-  BC5RGSnorm: "bc5-rg-snorm",
-  BC6HRGBUFloat: "bc6h-rgb-ufloat",
-  BC6HRGBFloat: "bc6h-rgb-float",
-  BC7RGBAUnorm: "bc7-rgba-unorm",
-  BC7RGBAUnormSRGB: "bc7-rgba-srgb",
-  // 'depth24unorm-stencil8' extension
-  Depth24UnormStencil8: "depth24unorm-stencil8",
-  // 'depth32float-stencil8' extension
-  Depth32FloatStencil8: "depth32float-stencil8"
-};
-const GPUAddressMode = {
-  ClampToEdge: "clamp-to-edge",
-  Repeat: "repeat",
-  MirrorRepeat: "mirror-repeat"
-};
-const GPUFilterMode = {
-  Linear: "linear",
-  Nearest: "nearest"
-};
-const GPUBlendFactor = {
-  Zero: "zero",
-  One: "one",
-  SrcColor: "src-color",
-  OneMinusSrcColor: "one-minus-src-color",
-  SrcAlpha: "src-alpha",
-  OneMinusSrcAlpha: "one-minus-src-alpha",
-  DstColor: "dst-color",
-  OneMinusDstColor: "one-minus-dst-color",
-  DstAlpha: "dst-alpha",
-  OneMinusDstAlpha: "one-minus-dst-alpha",
-  SrcAlphaSaturated: "src-alpha-saturated",
-  BlendColor: "blend-color",
-  OneMinusBlendColor: "one-minus-blend-color"
-};
-const GPUBlendOperation = {
-  Add: "add",
-  Subtract: "subtract",
-  ReverseSubtract: "reverse-subtract",
-  Min: "min",
-  Max: "max"
-};
-const GPUColorWriteFlags = {
-  None: 0,
-  Red: 1,
-  Green: 2,
-  Blue: 4,
-  Alpha: 8,
-  All: 15
-};
-const GPUStencilOperation = {
-  Keep: "keep",
-  Zero: "zero",
-  Replace: "replace",
-  Invert: "invert",
-  IncrementClamp: "increment-clamp",
-  DecrementClamp: "decrement-clamp",
-  IncrementWrap: "increment-wrap",
-  DecrementWrap: "decrement-wrap"
-};
-const GPUBindingType = {
-  UniformBuffer: "uniform-buffer",
-  StorageBuffer: "storage-buffer",
-  ReadonlyStorageBuffer: "readonly-storage-buffer",
-  Sampler: "sampler",
-  ComparisonSampler: "comparison-sampler",
-  SampledTexture: "sampled-texture",
-  MultisampledTexture: "multisampled-texture",
-  ReadonlyStorageTexture: "readonly-storage-texture",
-  WriteonlyStorageTexture: "writeonly-storage-texture"
-};
-const GPUTextureDimension = {
-  OneD: "1d",
-  TwoD: "2d",
-  ThreeD: "3d"
-};
-const GPUTextureViewDimension = {
-  OneD: "1d",
-  TwoD: "2d",
-  TwoDArray: "2d-array",
-  Cube: "cube",
-  CubeArray: "cube-array",
-  ThreeD: "3d"
-};
-const GPUInputStepMode = {
-  Vertex: "vertex",
-  Instance: "instance"
-};
-const BlendColorFactor = 211;
-const OneMinusBlendColorFactor = 212;
-export {
-  BlendColorFactor,
-  GPUAddressMode,
-  GPUBindingType,
-  GPUBlendFactor,
-  GPUBlendOperation,
-  GPUColorWriteFlags,
-  GPUCompareFunction,
-  GPUCullMode,
-  GPUFilterMode,
-  GPUFrontFace,
-  GPUIndexFormat,
-  GPUInputStepMode,
-  GPULoadOp,
-  GPUPrimitiveTopology,
-  GPUStencilOperation,
-  GPUStoreOp,
-  GPUTextureDimension,
-  GPUTextureFormat,
-  GPUTextureViewDimension,
-  GPUVertexFormat,
-  OneMinusBlendColorFactor
-};

package/dist/renderers/webgpu/nodes/ShaderLib.js

@@ -1,41 +0,0 @@
-"use strict";
-const ShaderLib = {
-  common: {
-    vertexShader: `#version 450
-
-NODE_HEADER_ATTRIBUTES
-NODE_HEADER_UNIFORMS
-NODE_HEADER_VARYS
-
-void main(){
-	NODE_BODY_VARYS
-	gl_Position = NODE_MVP;
-}`,
-    fragmentShader: `#version 450
-
-NODE_HEADER_ATTRIBUTES
-NODE_HEADER_UNIFORMS
-NODE_HEADER_VARYS
-
-layout(location = 0) out vec4 outColor;
-
-void main() {
-
-	outColor = vec4( 1.0, 1.0, 1.0, 1.0 );
-
-	#ifdef NODE_COLOR
-
-		outColor = NODE_COLOR;
-
-	#endif
-
-	#ifdef NODE_OPACITY
-
-		outColor.a *= NODE_OPACITY;
-
-	#endif
-
-}`
-  }
-};
-module.exports = ShaderLib;

package/dist/renderers/webgpu/nodes/ShaderLib.mjs

@@ -1,42 +0,0 @@
-const ShaderLib = {
-  common: {
-    vertexShader: `#version 450
-
-NODE_HEADER_ATTRIBUTES
-NODE_HEADER_UNIFORMS
-NODE_HEADER_VARYS
-
-void main(){
-	NODE_BODY_VARYS
-	gl_Position = NODE_MVP;
-}`,
-    fragmentShader: `#version 450
-
-NODE_HEADER_ATTRIBUTES
-NODE_HEADER_UNIFORMS
-NODE_HEADER_VARYS
-
-layout(location = 0) out vec4 outColor;
-
-void main() {
-
-	outColor = vec4( 1.0, 1.0, 1.0, 1.0 );
-
-	#ifdef NODE_COLOR
-
-		outColor = NODE_COLOR;
-
-	#endif
-
-	#ifdef NODE_OPACITY
-
-		outColor.a *= NODE_OPACITY;
-
-	#endif
-
-}`
-  }
-};
-export {
-  ShaderLib as default
-};

package/dist/renderers/webgpu/nodes/WebGPUNodeBuilder.js

@@ -1,164 +0,0 @@
-"use strict";
-const WebGPUNodeUniformsGroup = require("./WebGPUNodeUniformsGroup.js");
-const WebGPUNodeUniform = require("./WebGPUNodeUniform.js");
-const WebGPUSampler = require("../WebGPUSampler.js");
-const WebGPUSampledTexture = require("../WebGPUSampledTexture.js");
-const NodeSlot = require("../../nodes/core/NodeSlot.js");
-const NodeBuilder = require("../../nodes/core/NodeBuilder.js");
-const ModelViewProjectionNode = require("../../nodes/accessors/ModelViewProjectionNode.js");
-const ShaderLib = require("./ShaderLib.js");
-class WebGPUNodeBuilder extends NodeBuilder {
-  constructor(material, renderer) {
-    super(material, renderer);
-    this.bindings = { vertex: [], fragment: [] };
-    this.bindingsOffset = { vertex: 0, fragment: 0 };
-    this.uniformsGroup = {};
-    this.nativeShader = null;
-    this._parseMaterial();
-  }
-  _parseMaterial() {
-    const material = this.material;
-    this.nativeShader = ShaderLib.common;
-    if (material.isMeshBasicMaterial || material.isPointsMaterial || material.isLineBasicMaterial) {
-      const mvpNode = new ModelViewProjectionNode();
-      if (material.positionNode !== void 0) {
-        mvpNode.position = material.positionNode;
-      }
-      this.addSlot("vertex", new NodeSlot(mvpNode, "MVP", "vec4"));
-      if (material.colorNode !== void 0) {
-        this.addSlot("fragment", new NodeSlot(material.colorNode, "COLOR", "vec4"));
-      }
-      if (material.opacityNode !== void 0) {
-        this.addSlot("fragment", new NodeSlot(material.opacityNode, "OPACITY", "float"));
-      }
-    }
-  }
-  getTexture(textureProperty, uvSnippet) {
-    return `texture( sampler2D( ${textureProperty}, ${textureProperty}_sampler ), ${uvSnippet} )`;
-  }
-  getPropertyName(node) {
-    if (node.isNodeUniform) {
-      const name = node.name;
-      const type = node.type;
-      if (type === "texture") {
-        return name;
-      } else {
-        return `nodeUniforms.${name}`;
-      }
-    }
-    return super.getPropertyName(node);
-  }
-  getBindings() {
-    const bindings = this.bindings;
-    return [...bindings.vertex, ...bindings.fragment];
-  }
-  getUniformFromNode(node, shaderStage, type) {
-    const uniformNode = super.getUniformFromNode(node, shaderStage, type);
-    const nodeData = this.getDataFromNode(node, shaderStage);
-    if (nodeData.uniformGPU === void 0) {
-      let uniformGPU;
-      const bindings = this.bindings[shaderStage];
-      if (type === "texture") {
-        const sampler = new WebGPUSampler(`${uniformNode.name}_sampler`, uniformNode.value);
-        const texture = new WebGPUSampledTexture.WebGPUSampledTexture(uniformNode.name, uniformNode.value);
-        const lastBinding = bindings[bindings.length - 1];
-        const index = lastBinding && lastBinding.isUniformsGroup ? bindings.length - 1 : bindings.length;
-        bindings.splice(index, 0, sampler, texture);
-        uniformGPU = { sampler, texture };
-      } else {
-        let uniformsGroup = this.uniformsGroup[shaderStage];
-        if (uniformsGroup === void 0) {
-          uniformsGroup = new WebGPUNodeUniformsGroup(shaderStage);
-          this.uniformsGroup[shaderStage] = uniformsGroup;
-          bindings.push(uniformsGroup);
-        }
-        if (type === "float") {
-          uniformGPU = new WebGPUNodeUniform.FloatNodeUniform(uniformNode);
-        } else if (type === "vec2") {
-          uniformGPU = new WebGPUNodeUniform.Vector2NodeUniform(uniformNode);
-        } else if (type === "vec3") {
-          uniformGPU = new WebGPUNodeUniform.Vector3NodeUniform(uniformNode);
-        } else if (type === "vec4") {
-          uniformGPU = new WebGPUNodeUniform.Vector4NodeUniform(uniformNode);
-        } else if (type === "color") {
-          uniformGPU = new WebGPUNodeUniform.ColorNodeUniform(uniformNode);
-        } else if (type === "mat3") {
-          uniformGPU = new WebGPUNodeUniform.Matrix3NodeUniform(uniformNode);
-        } else if (type === "mat4") {
-          uniformGPU = new WebGPUNodeUniform.Matrix4NodeUniform(uniformNode);
-        } else {
-          throw new Error(`Uniform "${type}" not declared.`);
-        }
-        uniformsGroup.addUniform(uniformGPU);
-      }
-      nodeData.uniformGPU = uniformGPU;
-      if (shaderStage === "vertex") {
-        this.bindingsOffset["fragment"] = bindings.length;
-      }
-    }
-    return uniformNode;
-  }
-  getAttributesHeaderSnippet(shaderStage) {
-    let snippet = "";
-    if (shaderStage === "vertex") {
-      const attributes = this.attributes;
-      for (let index = 0; index < attributes.length; index++) {
-        const attribute = attributes[index];
-        snippet += `layout(location = ${index}) in ${attribute.type} ${attribute.name};`;
-      }
-    }
-    return snippet;
-  }
-  getVarysHeaderSnippet(shaderStage) {
-    let snippet = "";
-    const varys = this.varys;
-    const ioStage = shaderStage === "vertex" ? "out" : "in";
-    for (let index = 0; index < varys.length; index++) {
-      const vary = varys[index];
-      snippet += `layout(location = ${index}) ${ioStage} ${vary.type} ${vary.name};`;
-    }
-    return snippet;
-  }
-  getVarysBodySnippet(shaderStage) {
-    let snippet = "";
-    if (shaderStage === "vertex") {
-      for (let vary of this.varys) {
-        snippet += `${vary.name} = ${vary.snippet};`;
-      }
-    }
-    return snippet;
-  }
-  getUniformsHeaderSnippet(shaderStage) {
-    const uniforms = this.uniforms[shaderStage];
-    let snippet = "";
-    let groupSnippet = "";
-    let index = this.bindingsOffset[shaderStage];
-    for (let uniform of uniforms) {
-      if (uniform.type === "texture") {
-        snippet += `layout(set = 0, binding = ${index++}) uniform sampler ${uniform.name}_sampler;`;
-        snippet += `layout(set = 0, binding = ${index++}) uniform texture2D ${uniform.name};`;
-      } else {
-        const vectorType = this.getVectorType(uniform.type);
-        groupSnippet += `uniform ${vectorType} ${uniform.name};`;
-      }
-    }
-    if (groupSnippet) {
-      snippet += `layout(set = 0, binding = ${index++}) uniform NodeUniforms { ${groupSnippet} } nodeUniforms;`;
-    }
-    return snippet;
-  }
-  composeShaderCode(code, snippet) {
-    const versionStrIndex = code.indexOf("\n");
-    let finalCode = code.substr(0, versionStrIndex) + "\n\n";
-    finalCode += snippet;
-    finalCode += code.substr(versionStrIndex);
-    return finalCode;
-  }
-  build() {
-    super.build();
-    this.vertexShader = this.composeShaderCode(this.nativeShader.vertexShader, this.vertexShader);
-    this.fragmentShader = this.composeShaderCode(this.nativeShader.fragmentShader, this.fragmentShader);
-    return this;
-  }
-}
-module.exports = WebGPUNodeBuilder;

package/dist/renderers/webgpu/nodes/WebGPUNodeBuilder.mjs

@@ -1,165 +0,0 @@
-import WebGPUNodeUniformsGroup from "./WebGPUNodeUniformsGroup.mjs";
-import { FloatNodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform, ColorNodeUniform, Matrix3NodeUniform, Matrix4NodeUniform } from "./WebGPUNodeUniform.mjs";
-import WebGPUSampler from "../WebGPUSampler.mjs";
-import { WebGPUSampledTexture } from "../WebGPUSampledTexture.mjs";
-import NodeSlot from "../../nodes/core/NodeSlot.mjs";
-import NodeBuilder from "../../nodes/core/NodeBuilder.mjs";
-import ModelViewProjectionNode from "../../nodes/accessors/ModelViewProjectionNode.mjs";
-import ShaderLib from "./ShaderLib.mjs";
-class WebGPUNodeBuilder extends NodeBuilder {
-  constructor(material, renderer) {
-    super(material, renderer);
-    this.bindings = { vertex: [], fragment: [] };
-    this.bindingsOffset = { vertex: 0, fragment: 0 };
-    this.uniformsGroup = {};
-    this.nativeShader = null;
-    this._parseMaterial();
-  }
-  _parseMaterial() {
-    const material = this.material;
-    this.nativeShader = ShaderLib.common;
-    if (material.isMeshBasicMaterial || material.isPointsMaterial || material.isLineBasicMaterial) {
-      const mvpNode = new ModelViewProjectionNode();
-      if (material.positionNode !== void 0) {
-        mvpNode.position = material.positionNode;
-      }
-      this.addSlot("vertex", new NodeSlot(mvpNode, "MVP", "vec4"));
-      if (material.colorNode !== void 0) {
-        this.addSlot("fragment", new NodeSlot(material.colorNode, "COLOR", "vec4"));
-      }
-      if (material.opacityNode !== void 0) {
-        this.addSlot("fragment", new NodeSlot(material.opacityNode, "OPACITY", "float"));
-      }
-    }
-  }
-  getTexture(textureProperty, uvSnippet) {
-    return `texture( sampler2D( ${textureProperty}, ${textureProperty}_sampler ), ${uvSnippet} )`;
-  }
-  getPropertyName(node) {
-    if (node.isNodeUniform) {
-      const name = node.name;
-      const type = node.type;
-      if (type === "texture") {
-        return name;
-      } else {
-        return `nodeUniforms.${name}`;
-      }
-    }
-    return super.getPropertyName(node);
-  }
-  getBindings() {
-    const bindings = this.bindings;
-    return [...bindings.vertex, ...bindings.fragment];
-  }
-  getUniformFromNode(node, shaderStage, type) {
-    const uniformNode = super.getUniformFromNode(node, shaderStage, type);
-    const nodeData = this.getDataFromNode(node, shaderStage);
-    if (nodeData.uniformGPU === void 0) {
-      let uniformGPU;
-      const bindings = this.bindings[shaderStage];
-      if (type === "texture") {
-        const sampler = new WebGPUSampler(`${uniformNode.name}_sampler`, uniformNode.value);
-        const texture = new WebGPUSampledTexture(uniformNode.name, uniformNode.value);
-        const lastBinding = bindings[bindings.length - 1];
-        const index = lastBinding && lastBinding.isUniformsGroup ? bindings.length - 1 : bindings.length;
-        bindings.splice(index, 0, sampler, texture);
-        uniformGPU = { sampler, texture };
-      } else {
-        let uniformsGroup = this.uniformsGroup[shaderStage];
-        if (uniformsGroup === void 0) {
-          uniformsGroup = new WebGPUNodeUniformsGroup(shaderStage);
-          this.uniformsGroup[shaderStage] = uniformsGroup;
-          bindings.push(uniformsGroup);
-        }
-        if (type === "float") {
-          uniformGPU = new FloatNodeUniform(uniformNode);
-        } else if (type === "vec2") {
-          uniformGPU = new Vector2NodeUniform(uniformNode);
-        } else if (type === "vec3") {
-          uniformGPU = new Vector3NodeUniform(uniformNode);
-        } else if (type === "vec4") {
-          uniformGPU = new Vector4NodeUniform(uniformNode);
-        } else if (type === "color") {
-          uniformGPU = new ColorNodeUniform(uniformNode);
-        } else if (type === "mat3") {
-          uniformGPU = new Matrix3NodeUniform(uniformNode);
-        } else if (type === "mat4") {
-          uniformGPU = new Matrix4NodeUniform(uniformNode);
-        } else {
-          throw new Error(`Uniform "${type}" not declared.`);
-        }
-        uniformsGroup.addUniform(uniformGPU);
-      }
-      nodeData.uniformGPU = uniformGPU;
-      if (shaderStage === "vertex") {
-        this.bindingsOffset["fragment"] = bindings.length;
-      }
-    }
-    return uniformNode;
-  }
-  getAttributesHeaderSnippet(shaderStage) {
-    let snippet = "";
-    if (shaderStage === "vertex") {
-      const attributes = this.attributes;
-      for (let index = 0; index < attributes.length; index++) {
-        const attribute = attributes[index];
-        snippet += `layout(location = ${index}) in ${attribute.type} ${attribute.name};`;
-      }
-    }
-    return snippet;
-  }
-  getVarysHeaderSnippet(shaderStage) {
-    let snippet = "";
-    const varys = this.varys;
-    const ioStage = shaderStage === "vertex" ? "out" : "in";
-    for (let index = 0; index < varys.length; index++) {
-      const vary = varys[index];
-      snippet += `layout(location = ${index}) ${ioStage} ${vary.type} ${vary.name};`;
-    }
-    return snippet;
-  }
-  getVarysBodySnippet(shaderStage) {
-    let snippet = "";
-    if (shaderStage === "vertex") {
-      for (let vary of this.varys) {
-        snippet += `${vary.name} = ${vary.snippet};`;
-      }
-    }
-    return snippet;
-  }
-  getUniformsHeaderSnippet(shaderStage) {
-    const uniforms = this.uniforms[shaderStage];
-    let snippet = "";
-    let groupSnippet = "";
-    let index = this.bindingsOffset[shaderStage];
-    for (let uniform of uniforms) {
-      if (uniform.type === "texture") {
-        snippet += `layout(set = 0, binding = ${index++}) uniform sampler ${uniform.name}_sampler;`;
-        snippet += `layout(set = 0, binding = ${index++}) uniform texture2D ${uniform.name};`;
-      } else {
-        const vectorType = this.getVectorType(uniform.type);
-        groupSnippet += `uniform ${vectorType} ${uniform.name};`;
-      }
-    }
-    if (groupSnippet) {
-      snippet += `layout(set = 0, binding = ${index++}) uniform NodeUniforms { ${groupSnippet} } nodeUniforms;`;
-    }
-    return snippet;
-  }
-  composeShaderCode(code, snippet) {
-    const versionStrIndex = code.indexOf("\n");
-    let finalCode = code.substr(0, versionStrIndex) + "\n\n";
-    finalCode += snippet;
-    finalCode += code.substr(versionStrIndex);
-    return finalCode;
-  }
-  build() {
-    super.build();
-    this.vertexShader = this.composeShaderCode(this.nativeShader.vertexShader, this.vertexShader);
-    this.fragmentShader = this.composeShaderCode(this.nativeShader.fragmentShader, this.fragmentShader);
-    return this;
-  }
-}
-export {
-  WebGPUNodeBuilder as default
-};