three-stdlib 2.16.0 → 2.16.1

package/renderers/webgpu/WebGPUUniformsGroup.mjs

@@ -1,176 +0,0 @@
-import WebGPUBinding from "./WebGPUBinding.mjs";
-import { GPUBindingType } from "./constants.mjs";
-class WebGPUUniformsGroup extends WebGPUBinding {
-  constructor(name) {
-    super(name);
-    this.uniforms = [];
-    this.onBeforeUpdate = function() {
-    };
-    this.bytesPerElement = Float32Array.BYTES_PER_ELEMENT;
-    this.type = GPUBindingType.UniformBuffer;
-    this.visibility = GPUShaderStage.VERTEX;
-    this.usage = GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST;
-    this.array = null;
-    this.bufferGPU = null;
-    Object.defineProperty(this, "isUniformsGroup", { value: true });
-  }
-  addUniform(uniform) {
-    this.uniforms.push(uniform);
-    return this;
-  }
-  removeUniform(uniform) {
-    const index = this.uniforms.indexOf(uniform);
-    if (index !== -1) {
-      this.uniforms.splice(index, 1);
-    }
-    return this;
-  }
-  setOnBeforeUpdate(callback) {
-    this.onBeforeUpdate = callback;
-    return this;
-  }
-  getByteLength() {
-    let offset = 0;
-    const chunkSize = 16;
-    for (let i = 0, l = this.uniforms.length; i < l; i++) {
-      const uniform = this.uniforms[i];
-      const chunkOffset = offset % chunkSize;
-      const remainingSizeInChunk = chunkSize - chunkOffset;
-      if (chunkOffset !== 0 && remainingSizeInChunk - uniform.boundary < 0) {
-        offset += chunkSize - chunkOffset;
-      }
-      uniform.offset = offset / this.bytesPerElement;
-      offset += uniform.itemSize * this.bytesPerElement;
-    }
-    return offset;
-  }
-  update() {
-    let updated = false;
-    for (let uniform of this.uniforms) {
-      if (this.updateByType(uniform) === true) {
-        updated = true;
-      }
-    }
-    return updated;
-  }
-  updateByType(uniform) {
-    if (uniform.isFloatUniform)
-      return this.updateNumber(uniform);
-    if (uniform.isVector2Uniform)
-      return this.updateVector2(uniform);
-    if (uniform.isVector3Uniform)
-      return this.updateVector3(uniform);
-    if (uniform.isVector4Uniform)
-      return this.updateVector4(uniform);
-    if (uniform.isColorUniform)
-      return this.updateColor(uniform);
-    if (uniform.isMatrix3Uniform)
-      return this.updateMatrix3(uniform);
-    if (uniform.isMatrix4Uniform)
-      return this.updateMatrix4(uniform);
-    console.error("THREE.WebGPUUniformsGroup: Unsupported uniform type.", uniform);
-  }
-  updateNumber(uniform) {
-    let updated = false;
-    const a = this.array;
-    const v = uniform.getValue();
-    const offset = uniform.offset;
-    if (a[offset] !== v) {
-      a[offset] = v;
-      updated = true;
-    }
-    return updated;
-  }
-  updateVector2(uniform) {
-    let updated = false;
-    const a = this.array;
-    const v = uniform.getValue();
-    const offset = uniform.offset;
-    if (a[offset + 0] !== v.x || a[offset + 1] !== v.y) {
-      a[offset + 0] = v.x;
-      a[offset + 1] = v.y;
-      updated = true;
-    }
-    return updated;
-  }
-  updateVector3(uniform) {
-    let updated = false;
-    const a = this.array;
-    const v = uniform.getValue();
-    const offset = uniform.offset;
-    if (a[offset + 0] !== v.x || a[offset + 1] !== v.y || a[offset + 2] !== v.z) {
-      a[offset + 0] = v.x;
-      a[offset + 1] = v.y;
-      a[offset + 2] = v.z;
-      updated = true;
-    }
-    return updated;
-  }
-  updateVector4(uniform) {
-    let updated = false;
-    const a = this.array;
-    const v = uniform.getValue();
-    const offset = uniform.offset;
-    if (a[offset + 0] !== v.x || a[offset + 1] !== v.y || a[offset + 2] !== v.z || a[offset + 4] !== v.w) {
-      a[offset + 0] = v.x;
-      a[offset + 1] = v.y;
-      a[offset + 2] = v.z;
-      a[offset + 3] = v.w;
-      updated = true;
-    }
-    return updated;
-  }
-  updateColor(uniform) {
-    let updated = false;
-    const a = this.array;
-    const c = uniform.getValue();
-    const offset = uniform.offset;
-    if (a[offset + 0] !== c.r || a[offset + 1] !== c.g || a[offset + 2] !== c.b) {
-      a[offset + 0] = c.r;
-      a[offset + 1] = c.g;
-      a[offset + 2] = c.b;
-      updated = true;
-    }
-    return updated;
-  }
-  updateMatrix3(uniform) {
-    let updated = false;
-    const a = this.array;
-    const e = uniform.getValue().elements;
-    const offset = uniform.offset;
-    if (a[offset + 0] !== e[0] || a[offset + 1] !== e[1] || a[offset + 2] !== e[2] || a[offset + 4] !== e[3] || a[offset + 5] !== e[4] || a[offset + 6] !== e[5] || a[offset + 8] !== e[6] || a[offset + 9] !== e[7] || a[offset + 10] !== e[8]) {
-      a[offset + 0] = e[0];
-      a[offset + 1] = e[1];
-      a[offset + 2] = e[2];
-      a[offset + 4] = e[3];
-      a[offset + 5] = e[4];
-      a[offset + 6] = e[5];
-      a[offset + 8] = e[6];
-      a[offset + 9] = e[7];
-      a[offset + 10] = e[8];
-      updated = true;
-    }
-    return updated;
-  }
-  updateMatrix4(uniform) {
-    let updated = false;
-    const a = this.array;
-    const e = uniform.getValue().elements;
-    const offset = uniform.offset;
-    if (arraysEqual(a, e, offset) === false) {
-      a.set(e, offset);
-      updated = true;
-    }
-    return updated;
-  }
-}
-function arraysEqual(a, b, offset) {
-  for (let i = 0, l = b.length; i < l; i++) {
-    if (a[offset + i] !== b[i])
-      return false;
-  }
-  return true;
-}
-export {
-  WebGPUUniformsGroup as default
-};

package/renderers/webgpu/constants.mjs

@@ -1,230 +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 = {
-  R8Unorm: "r8unorm",
-  R8Snorm: "r8snorm",
-  R8Uint: "r8uint",
-  R8Sint: "r8sint",
-  R16Uint: "r16uint",
-  R16Sint: "r16sint",
-  R16Float: "r16float",
-  RG8Unorm: "rg8unorm",
-  RG8Snorm: "rg8snorm",
-  RG8Uint: "rg8uint",
-  RG8Sint: "rg8sint",
-  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",
-  RGB9E5UFloat: "rgb9e5ufloat",
-  RGB10A2Unorm: "rgb10a2unorm",
-  RG11B10uFloat: "rgb10a2unorm",
-  RG32Uint: "rg32uint",
-  RG32Sint: "rg32sint",
-  RG32Float: "rg32float",
-  RGBA16Uint: "rgba16uint",
-  RGBA16Sint: "rgba16sint",
-  RGBA16Float: "rgba16float",
-  RGBA32Uint: "rgba32uint",
-  RGBA32Sint: "rgba32sint",
-  RGBA32Float: "rgba32float",
-  Stencil8: "stencil8",
-  Depth16Unorm: "depth16unorm",
-  Depth24Plus: "depth24plus",
-  Depth24PlusStencil8: "depth24plus-stencil8",
-  Depth32Float: "depth32float",
-  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",
-  Depth24UnormStencil8: "depth24unorm-stencil8",
-  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/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/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
-};

package/renderers/webgpu/nodes/WebGPUNodeUniform.mjs

@@ -1,73 +0,0 @@
-import { FloatUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform, ColorUniform, Matrix3Uniform, Matrix4Uniform } from "../WebGPUUniform.mjs";
-class FloatNodeUniform extends FloatUniform {
-  constructor(nodeUniform) {
-    super(nodeUniform.name, nodeUniform.value);
-    this.nodeUniform = nodeUniform;
-  }
-  getValue() {
-    return this.nodeUniform.value;
-  }
-}
-class Vector2NodeUniform extends Vector2Uniform {
-  constructor(nodeUniform) {
-    super(nodeUniform.name, nodeUniform.value);
-    this.nodeUniform = nodeUniform;
-  }
-  getValue() {
-    return this.nodeUniform.value;
-  }
-}
-class Vector3NodeUniform extends Vector3Uniform {
-  constructor(nodeUniform) {
-    super(nodeUniform.name, nodeUniform.value);
-    this.nodeUniform = nodeUniform;
-  }
-  getValue() {
-    return this.nodeUniform.value;
-  }
-}
-class Vector4NodeUniform extends Vector4Uniform {
-  constructor(nodeUniform) {
-    super(nodeUniform.name, nodeUniform.value);
-    this.nodeUniform = nodeUniform;
-  }
-  getValue() {
-    return this.nodeUniform.value;
-  }
-}
-class ColorNodeUniform extends ColorUniform {
-  constructor(nodeUniform) {
-    super(nodeUniform.name, nodeUniform.value);
-    this.nodeUniform = nodeUniform;
-  }
-  getValue() {
-    return this.nodeUniform.value;
-  }
-}
-class Matrix3NodeUniform extends Matrix3Uniform {
-  constructor(nodeUniform) {
-    super(nodeUniform.name, nodeUniform.value);
-    this.nodeUniform = nodeUniform;
-  }
-  getValue() {
-    return this.nodeUniform.value;
-  }
-}
-class Matrix4NodeUniform extends Matrix4Uniform {
-  constructor(nodeUniform) {
-    super(nodeUniform.name, nodeUniform.value);
-    this.nodeUniform = nodeUniform;
-  }
-  getValue() {
-    return this.nodeUniform.value;
-  }
-}
-export {
-  ColorNodeUniform,
-  FloatNodeUniform,
-  Matrix3NodeUniform,
-  Matrix4NodeUniform,
-  Vector2NodeUniform,
-  Vector3NodeUniform,
-  Vector4NodeUniform
-};

package/renderers/webgpu/nodes/WebGPUNodeUniformsGroup.mjs

@@ -1,15 +0,0 @@
-import WebGPUUniformsGroup from "../WebGPUUniformsGroup.mjs";
-class WebGPUNodeUniformsGroup extends WebGPUUniformsGroup {
-  constructor(shaderStage) {
-    super("nodeUniforms");
-    let shaderStageVisibility;
-    if (shaderStage === "vertex")
-      shaderStageVisibility = GPUShaderStage.VERTEX;
-    else if (shaderStage === "fragment")
-      shaderStageVisibility = GPUShaderStage.FRAGMENT;
-    this.setVisibility(shaderStageVisibility);
-  }
-}
-export {
-  WebGPUNodeUniformsGroup as default
-};