three-stdlib 2.15.1 → 2.15.2

package/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/renderers/webgpu/nodes/WebGPUNodeBuilder.js

@@ -1,204 +1,140 @@
-import WebGPUNodeUniformsGroup from './WebGPUNodeUniformsGroup.js';
-import { FloatNodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform, ColorNodeUniform, Matrix3NodeUniform, Matrix4NodeUniform } from './WebGPUNodeUniform.js';
-import WebGPUSampler from '../WebGPUSampler.js';
-import { WebGPUSampledTexture } from '../WebGPUSampledTexture.js';
-import NodeSlot from '../../nodes/core/NodeSlot.js';
-import NodeBuilder from '../../nodes/core/NodeBuilder.js';
-import ModelViewProjectionNode from '../../nodes/accessors/ModelViewProjectionNode.js';
-import ShaderLib from './ShaderLib.js';
-import '../WebGPUUniformsGroup.js';
-import '../WebGPUBinding.js';
-import '../constants.js';
-import '../WebGPUUniform.js';
-import 'three';
-import '../../nodes/core/NodeUniform.js';
-import '../../nodes/core/NodeAttribute.js';
-import '../../nodes/core/NodeVary.js';
-import '../../nodes/core/constants.js';
-import '../../nodes/core/Node.js';
-import '../../nodes/accessors/CameraNode.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import '../../nodes/inputs/Vector3Node.js';
-import '../../nodes/core/InputNode.js';
-import '../../nodes/inputs/Matrix4Node.js';
-import '../../nodes/accessors/ModelNode.js';
-import '../../nodes/inputs/Matrix3Node.js';
-import '../../nodes/math/OperatorNode.js';
-import '../../nodes/accessors/PositionNode.js';
-import '../../nodes/core/AttributeNode.js';
-
+"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.bindings = { vertex: [], fragment: [] };
+    this.bindingsOffset = { vertex: 0, fragment: 0 };
     this.uniformsGroup = {};
     this.nativeShader = null;
-
     this._parseMaterial();
   }
-
   _parseMaterial() {
-    const material = this.material; // get shader
-
-    this.nativeShader = ShaderLib.common; // parse inputs
-
+    const material = this.material;
+    this.nativeShader = ShaderLib.common;
     if (material.isMeshBasicMaterial || material.isPointsMaterial || material.isLineBasicMaterial) {
       const mvpNode = new ModelViewProjectionNode();
-
-      if (material.positionNode !== undefined) {
+      if (material.positionNode !== void 0) {
         mvpNode.position = material.positionNode;
       }
-
-      this.addSlot('vertex', new NodeSlot(mvpNode, 'MVP', 'vec4'));
-
-      if (material.colorNode !== undefined) {
-        this.addSlot('fragment', new NodeSlot(material.colorNode, 'COLOR', 'vec4'));
+      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 !== undefined) {
-        this.addSlot('fragment', new NodeSlot(material.opacityNode, 'OPACITY', 'float'));
+      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') {
+      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 === undefined) {
+    if (nodeData.uniformGPU === void 0) {
       let uniformGPU;
       const bindings = this.bindings[shaderStage];
-
-      if (type === 'texture') {
+      if (type === "texture") {
         const sampler = new WebGPUSampler(`${uniformNode.name}_sampler`, uniformNode.value);
-        const texture = new WebGPUSampledTexture(uniformNode.name, uniformNode.value); // add first textures in sequence and group for last
-
+        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
-        };
+        uniformGPU = { sampler, texture };
       } else {
         let uniformsGroup = this.uniformsGroup[shaderStage];
-
-        if (uniformsGroup === undefined) {
+        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);
+        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;
+      if (shaderStage === "vertex") {
+        this.bindingsOffset["fragment"] = bindings.length;
       }
     }
-
     return uniformNode;
   }
-
   getAttributesHeaderSnippet(shaderStage) {
-    let snippet = '';
-
-    if (shaderStage === 'vertex') {
+    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 = '';
+    let snippet = "";
     const varys = this.varys;
-    const ioStage = shaderStage === 'vertex' ? 'out' : 'in';
-
+    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') {
+    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 snippet = "";
+    let groupSnippet = "";
     let index = this.bindingsOffset[shaderStage];
-
     for (let uniform of uniforms) {
-      if (uniform.type === 'texture') {
+      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 {
@@ -206,30 +142,23 @@ class WebGPUNodeBuilder extends NodeBuilder {
         groupSnippet += `uniform ${vectorType} ${uniform.name};`;
       }
     }
-
     if (groupSnippet) {
       snippet += `layout(set = 0, binding = ${index++}) uniform NodeUniforms { ${groupSnippet} } nodeUniforms;`;
     }
-
     return snippet;
   }
-
   composeShaderCode(code, snippet) {
-    // use regex maybe for security?
-    const versionStrIndex = code.indexOf('\n');
-    let finalCode = code.substr(0, versionStrIndex) + '\n\n';
+    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 default WebGPUNodeBuilder;
+module.exports = WebGPUNodeBuilder;

package/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
+};

package/renderers/webgpu/nodes/WebGPUNodeUniform.js

@@ -1,87 +1,73 @@
-import { FloatUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform, ColorUniform, Matrix3Uniform, Matrix4Uniform } from '../WebGPUUniform.js';
-
-class FloatNodeUniform extends FloatUniform {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const WebGPUUniform = require("../WebGPUUniform.js");
+class FloatNodeUniform extends WebGPUUniform.FloatUniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
-
   getValue() {
     return this.nodeUniform.value;
   }
-
 }
-
-class Vector2NodeUniform extends Vector2Uniform {
+class Vector2NodeUniform extends WebGPUUniform.Vector2Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
-
   getValue() {
     return this.nodeUniform.value;
   }
-
 }
-
-class Vector3NodeUniform extends Vector3Uniform {
+class Vector3NodeUniform extends WebGPUUniform.Vector3Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
-
   getValue() {
     return this.nodeUniform.value;
   }
-
 }
-
-class Vector4NodeUniform extends Vector4Uniform {
+class Vector4NodeUniform extends WebGPUUniform.Vector4Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
-
   getValue() {
     return this.nodeUniform.value;
   }
-
 }
-
-class ColorNodeUniform extends ColorUniform {
+class ColorNodeUniform extends WebGPUUniform.ColorUniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
-
   getValue() {
     return this.nodeUniform.value;
   }
-
 }
-
-class Matrix3NodeUniform extends Matrix3Uniform {
+class Matrix3NodeUniform extends WebGPUUniform.Matrix3Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
-
   getValue() {
     return this.nodeUniform.value;
   }
-
 }
-
-class Matrix4NodeUniform extends Matrix4Uniform {
+class Matrix4NodeUniform extends WebGPUUniform.Matrix4Uniform {
   constructor(nodeUniform) {
     super(nodeUniform.name, nodeUniform.value);
     this.nodeUniform = nodeUniform;
   }
-
   getValue() {
     return this.nodeUniform.value;
   }
-
 }
-
-export { ColorNodeUniform, FloatNodeUniform, Matrix3NodeUniform, Matrix4NodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform };
+exports.ColorNodeUniform = ColorNodeUniform;
+exports.FloatNodeUniform = FloatNodeUniform;
+exports.Matrix3NodeUniform = Matrix3NodeUniform;
+exports.Matrix4NodeUniform = Matrix4NodeUniform;
+exports.Vector2NodeUniform = Vector2NodeUniform;
+exports.Vector3NodeUniform = Vector3NodeUniform;
+exports.Vector4NodeUniform = Vector4NodeUniform;

package/renderers/webgpu/nodes/WebGPUNodeUniform.mjs

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