three-stdlib 2.22.7 → 2.22.8

package/dist/renderers/webgpu/constants.mjs

@@ -0,0 +1,241 @@
+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

@@ -0,0 +1,41 @@
+"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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,164 @@
+"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

@@ -0,0 +1,165 @@
+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
+};