three-stdlib 2.15.2 → 2.16.1

package/nodes/core/NodeUtils.mjs

@@ -1,57 +0,0 @@
-import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4 } from "three";
-const getNodesKeys = (object) => {
-  const props = [];
-  for (const name in object) {
-    const value = object[name];
-    if (value && value.isNode === true) {
-      props.push(name);
-    }
-  }
-  return props;
-};
-const getValueType = (value) => {
-  if (typeof value === "number") {
-    return "float";
-  } else if (typeof value === "boolean") {
-    return "bool";
-  } else if ((value == null ? void 0 : value.isVector2) === true) {
-    return "vec2";
-  } else if ((value == null ? void 0 : value.isVector3) === true) {
-    return "vec3";
-  } else if ((value == null ? void 0 : value.isVector4) === true) {
-    return "vec4";
-  } else if ((value == null ? void 0 : value.isMatrix3) === true) {
-    return "mat3";
-  } else if ((value == null ? void 0 : value.isMatrix4) === true) {
-    return "mat4";
-  } else if ((value == null ? void 0 : value.isColor) === true) {
-    return "color";
-  }
-  return null;
-};
-const getValueFromType = (type, ...params) => {
-  const last4 = type == null ? void 0 : type.slice(-4);
-  if (type === "color") {
-    return new Color(...params);
-  } else if (last4 === "vec2") {
-    return new Vector2(...params);
-  } else if (last4 === "vec3") {
-    return new Vector3(...params);
-  } else if (last4 === "vec4") {
-    return new Vector4(...params);
-  } else if (last4 === "mat3") {
-    return new Matrix3(...params);
-  } else if (last4 === "mat4") {
-    return new Matrix4(...params);
-  } else if (type === "bool") {
-    return false;
-  } else if (type === "float" || type === "int" || type === "uint") {
-    return 0;
-  }
-  return null;
-};
-export {
-  getNodesKeys,
-  getValueFromType,
-  getValueType
-};

package/nodes/core/NodeVar.mjs

@@ -1,10 +0,0 @@
-class NodeVar {
-  constructor(name, type) {
-    this.name = name;
-    this.type = type;
-  }
-}
-NodeVar.prototype.isNodeVar = true;
-export {
-  NodeVar as default
-};

package/nodes/core/NodeVary.mjs

@@ -1,10 +0,0 @@
-class NodeVary {
-  constructor(name, type) {
-    this.name = name;
-    this.type = type;
-  }
-}
-NodeVary.prototype.isNodeVary = true;
-export {
-  NodeVary as default
-};

package/nodes/core/PropertyNode.mjs

@@ -1,21 +0,0 @@
-import Node from "./Node.mjs";
-class PropertyNode extends Node {
-  constructor(name = null, nodeType = "vec4") {
-    super(nodeType);
-    this.name = name;
-  }
-  getHash(builder) {
-    return this.name || super.getHash(builder);
-  }
-  generate(builder) {
-    const nodeVary = builder.getVarFromNode(this, this.getNodeType(builder));
-    const name = this.name;
-    if (name !== null) {
-      nodeVary.name = name;
-    }
-    return builder.getPropertyName(nodeVary);
-  }
-}
-export {
-  PropertyNode as default
-};

package/nodes/core/TempNode.mjs

@@ -1,25 +0,0 @@
-import Node from "./Node.mjs";
-class TempNode extends Node {
-  constructor(type) {
-    super(type);
-  }
-  build(builder, output) {
-    const type = builder.getVectorType(this.getNodeType(builder, output));
-    const nodeData = builder.getDataFromNode(this);
-    if (builder.context.temp !== false && type !== "void " && output !== "void" && nodeData.dependenciesCount > 1) {
-      if (nodeData.snippet === void 0) {
-        const snippet = super.build(builder, type);
-        const nodeVar = builder.getVarFromNode(this, type);
-        const propertyName = builder.getPropertyName(nodeVar);
-        builder.addFlowCode(`${propertyName} = ${snippet}`);
-        nodeData.snippet = snippet;
-        nodeData.propertyName = propertyName;
-      }
-      return builder.format(nodeData.propertyName, type, output);
-    }
-    return super.build(builder, output);
-  }
-}
-export {
-  TempNode as default
-};

package/nodes/core/UniformNode.mjs

@@ -1,23 +0,0 @@
-import InputNode from "./InputNode.mjs";
-class UniformNode extends InputNode {
-  getUniformHash(builder) {
-    return this.getHash(builder);
-  }
-  generate(builder, output) {
-    const type = this.getNodeType(builder);
-    const hash = this.getUniformHash(builder);
-    let sharedNode = builder.getNodeFromHash(hash);
-    if (sharedNode === void 0) {
-      builder.setHashNode(this, hash);
-      sharedNode = this;
-    }
-    const sharedNodeType = sharedNode.getInputType(builder);
-    const nodeUniform = builder.getUniformFromNode(sharedNode, builder.shaderStage, sharedNodeType);
-    const propertyName = builder.getPropertyName(nodeUniform);
-    return builder.format(propertyName, type, output);
-  }
-}
-UniformNode.prototype.isUniformNode = true;
-export {
-  UniformNode as default
-};

package/nodes/core/VarNode.mjs

@@ -1,31 +0,0 @@
-import Node from "./Node.mjs";
-class VarNode extends Node {
-  constructor(node, name = null, nodeType = null) {
-    super(nodeType);
-    this.node = node;
-    this.name = name;
-  }
-  getHash(builder) {
-    return this.name || super.getHash(builder);
-  }
-  getNodeType(builder) {
-    return super.getNodeType(builder) || this.node.getNodeType(builder);
-  }
-  generate(builder) {
-    const type = builder.getVectorType(this.getNodeType(builder));
-    const node = this.node;
-    const name = this.name;
-    const snippet = node.build(builder, type);
-    const nodeVar = builder.getVarFromNode(this, type);
-    if (name !== null) {
-      nodeVar.name = name;
-    }
-    const propertyName = builder.getPropertyName(nodeVar);
-    builder.addFlowCode(`${propertyName} = ${snippet}`);
-    return propertyName;
-  }
-}
-VarNode.prototype.isVarNode = true;
-export {
-  VarNode as default
-};

package/nodes/core/VaryNode.mjs

@@ -1,30 +0,0 @@
-import Node from "./Node.mjs";
-import { NodeShaderStage } from "./constants.mjs";
-class VaryNode extends Node {
-  constructor(node, name = null) {
-    super();
-    this.node = node;
-    this.name = name;
-  }
-  getHash(builder) {
-    return this.name || super.getHash(builder);
-  }
-  getNodeType(builder) {
-    return this.node.getNodeType(builder);
-  }
-  generate(builder) {
-    const type = this.getNodeType(builder);
-    const node = this.node;
-    const name = this.name;
-    const nodeVary = builder.getVaryFromNode(this, type);
-    if (name !== null) {
-      nodeVary.name = name;
-    }
-    const propertyName = builder.getPropertyName(nodeVary, NodeShaderStage.Vertex);
-    builder.flowNodeFromShaderStage(NodeShaderStage.Vertex, node, type, propertyName);
-    return builder.getPropertyName(nodeVary);
-  }
-}
-export {
-  VaryNode as default
-};

package/nodes/core/constants.mjs

@@ -1,24 +0,0 @@
-const NodeShaderStage = {
-  Vertex: "vertex",
-  Fragment: "fragment"
-};
-const NodeUpdateType = {
-  None: "none",
-  Frame: "frame",
-  Object: "object"
-};
-const NodeType = {
-  Boolean: "bool",
-  Integer: "int",
-  Float: "float",
-  Vector2: "vec2",
-  Vector3: "vec3",
-  Vector4: "vec4",
-  Matrix3: "mat3",
-  Matrix4: "mat4"
-};
-export {
-  NodeShaderStage,
-  NodeType,
-  NodeUpdateType
-};

package/nodes/display/ColorSpaceNode.mjs

@@ -1,63 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-import Node from "../core/Node.mjs";
-import { ShaderNode, sub, mul, pow, vec3, lessThanEqual, mix, join } from "../ShaderNode.mjs";
-import { LinearEncoding, sRGBEncoding } from "three";
-const LinearToLinear = new ShaderNode((inputs) => {
-  return inputs.value;
-});
-const LinearTosRGB = new ShaderNode((inputs) => {
-  const { value } = inputs;
-  const rgb = value.rgb;
-  const a = sub(mul(pow(value.rgb, vec3(0.41666)), 1.055), vec3(0.055));
-  const b = mul(rgb, 12.92);
-  const factor = vec3(lessThanEqual(rgb, vec3(31308e-7)));
-  const rgbResult = mix(a, b, factor);
-  return join(rgbResult.r, rgbResult.g, rgbResult.b, value.a);
-});
-const EncodingLib = {
-  LinearToLinear,
-  LinearTosRGB
-};
-const _ColorSpaceNode = class extends Node {
-  constructor(method, node) {
-    super("vec4");
-    this.method = method;
-    this.node = node;
-  }
-  fromEncoding(encoding) {
-    let method = null;
-    if (encoding === LinearEncoding) {
-      method = "Linear";
-    } else if (encoding === sRGBEncoding) {
-      method = "sRGB";
-    }
-    this.method = "LinearTo" + method;
-    return this;
-  }
-  generate(builder) {
-    const type = this.getNodeType(builder);
-    const method = this.method;
-    const node = this.node;
-    if (method !== _ColorSpaceNode.LINEAR_TO_LINEAR) {
-      const encodingFunctionNode = EncodingLib[method];
-      return encodingFunctionNode({
-        value: node
-      }).build(builder, type);
-    } else {
-      return node.build(builder, type);
-    }
-  }
-};
-let ColorSpaceNode = _ColorSpaceNode;
-__publicField(ColorSpaceNode, "LINEAR_TO_LINEAR", "LinearToLinear");
-__publicField(ColorSpaceNode, "LINEAR_TO_SRGB", "LinearTosRGB");
-export {
-  LinearToLinear,
-  LinearTosRGB,
-  ColorSpaceNode as default
-};

package/nodes/display/NormalMapNode.mjs

@@ -1,54 +0,0 @@
-import TempNode from "../core/TempNode.mjs";
-import ModelNode from "../accessors/ModelNode.mjs";
-import { ShaderNode, dFdx, dFdy, cross, add, mul, max, dot, cond, equal, inversesqrt, normalize, sub, join, positionView, normalView, uv } from "../ShaderNode.mjs";
-import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from "three";
-const perturbNormal2ArbNode = new ShaderNode((inputs) => {
-  const { eye_pos, surf_norm, mapN, faceDirection, uv: uv2 } = inputs;
-  const q0 = dFdx(eye_pos.xyz);
-  const q1 = dFdy(eye_pos.xyz);
-  const st0 = dFdx(uv2.st);
-  const st1 = dFdy(uv2.st);
-  const N = surf_norm;
-  const q1perp = cross(q1, N);
-  const q0perp = cross(N, q0);
-  const T = add(mul(q1perp, st0.x), mul(q0perp, st1.x));
-  const B = add(mul(q1perp, st0.y), mul(q0perp, st1.y));
-  const det = max(dot(T, T), dot(B, B));
-  const scale = cond(equal(det, 0), 0, mul(faceDirection, inversesqrt(det)));
-  return normalize(add(mul(T, mul(mapN.x, scale)), mul(B, mul(mapN.y, scale)), mul(N, mapN.z)));
-});
-class NormalMapNode extends TempNode {
-  constructor(node, scaleNode = null) {
-    super("vec3");
-    this.node = node;
-    this.scaleNode = scaleNode;
-    this.normalMapType = TangentSpaceNormalMap;
-  }
-  generate(builder) {
-    const type = this.getNodeType(builder);
-    const { normalMapType, scaleNode } = this;
-    const normalOP = mul(this.node, 2);
-    let normalMap = sub(normalOP, 1);
-    if (scaleNode !== null) {
-      const normalMapScale = mul(normalMap.xy, scaleNode);
-      normalMap = join(normalMapScale, normalMap.z);
-    }
-    if (normalMapType === ObjectSpaceNormalMap) {
-      const vertexNormalNode = mul(new ModelNode(ModelNode.NORMAL_MATRIX), normalMap);
-      const normal = normalize(vertexNormalNode);
-      return normal.build(builder, type);
-    } else if (normalMapType === TangentSpaceNormalMap) {
-      const perturbNormal2ArbCall = perturbNormal2ArbNode({
-        eye_pos: positionView,
-        surf_norm: normalView,
-        mapN: normalMap,
-        faceDirection: 1,
-        uv: uv()
-      });
-      return perturbNormal2ArbCall.build(builder, type);
-    }
-  }
-}
-export {
-  NormalMapNode as default
-};

package/nodes/fog/FogNode.mjs

@@ -1,15 +0,0 @@
-import Node from "../core/Node.mjs";
-class FogNode extends Node {
-  constructor(colorNode, factorNode) {
-    super("float");
-    this.colorNode = colorNode;
-    this.factorNode = factorNode;
-  }
-  generate(builder) {
-    return this.factorNode.build(builder, "float");
-  }
-}
-FogNode.prototype.isFogNode = true;
-export {
-  FogNode as default
-};

package/nodes/fog/FogRangeNode.mjs

@@ -1,17 +0,0 @@
-import FogNode from "./FogNode.mjs";
-import { smoothstep, negate, positionView } from "../ShaderNode.mjs";
-class FogRangeNode extends FogNode {
-  constructor(colorNode, nearNode, farNode) {
-    super(colorNode);
-    this.nearNode = nearNode;
-    this.farNode = farNode;
-  }
-  generate(builder) {
-    this.factorNode = smoothstep(this.nearNode, this.farNode, negate(positionView.z));
-    return super.generate(builder);
-  }
-}
-FogRangeNode.prototype.isFogRangeNode = true;
-export {
-  FogRangeNode as default
-};

package/nodes/functions/BSDFs.mjs

@@ -1,64 +0,0 @@
-import { ShaderNode, exp2, mul, sub, add, cond, and, greaterThan, pow, saturate, div, negate, pow2, sqrt, max, EPSILON, normalize, positionViewDirection, dot, transformedNormalView, addTo, diffuseColor, specularColor, roughness } from "../ShaderNode.mjs";
-const F_Schlick = new ShaderNode((inputs) => {
-  const { f0, f90, dotVH } = inputs;
-  const fresnel = exp2(mul(sub(mul(-5.55473, dotVH), 6.98316), dotVH));
-  return add(mul(f0, sub(1, fresnel)), mul(f90, fresnel));
-});
-const BRDF_Lambert = new ShaderNode((inputs) => {
-  return mul(1 / Math.PI, inputs.diffuseColor);
-});
-const getDistanceAttenuation = new ShaderNode((inputs) => {
-  const { lightDistance, cutoffDistance, decayExponent } = inputs;
-  return cond(
-    and(greaterThan(cutoffDistance, 0), greaterThan(decayExponent, 0)),
-    pow(saturate(add(div(negate(lightDistance), cutoffDistance), 1)), decayExponent),
-    1
-  );
-});
-const V_GGX_SmithCorrelated = new ShaderNode((inputs) => {
-  const { alpha, dotNL, dotNV } = inputs;
-  const a2 = pow2(alpha);
-  const gv = mul(dotNL, sqrt(add(a2, mul(sub(1, a2), pow2(dotNV)))));
-  const gl = mul(dotNV, sqrt(add(a2, mul(sub(1, a2), pow2(dotNL)))));
-  return div(0.5, max(add(gv, gl), EPSILON));
-});
-const D_GGX = new ShaderNode((inputs) => {
-  const { alpha, dotNH } = inputs;
-  const a2 = pow2(alpha);
-  const denom = add(mul(pow2(dotNH), sub(a2, 1)), 1);
-  return mul(1 / Math.PI, div(a2, pow2(denom)));
-});
-const BRDF_GGX = new ShaderNode((inputs) => {
-  const { lightDirection, f0, f90, roughness: roughness2 } = inputs;
-  const alpha = pow2(roughness2);
-  const halfDir = normalize(add(lightDirection, positionViewDirection));
-  const dotNL = saturate(dot(transformedNormalView, lightDirection));
-  const dotNV = saturate(dot(transformedNormalView, positionViewDirection));
-  const dotNH = saturate(dot(transformedNormalView, halfDir));
-  const dotVH = saturate(dot(positionViewDirection, halfDir));
-  const F = F_Schlick({ f0, f90, dotVH });
-  const V = V_GGX_SmithCorrelated({ alpha, dotNL, dotNV });
-  const D = D_GGX({ alpha, dotNH });
-  return mul(F, mul(V, D));
-});
-const RE_Direct_Physical = new ShaderNode((inputs) => {
-  const { lightDirection, lightColor, directDiffuse, directSpecular } = inputs;
-  const dotNL = saturate(dot(transformedNormalView, lightDirection));
-  let irradiance = mul(dotNL, lightColor);
-  irradiance = mul(irradiance, Math.PI);
-  addTo(directDiffuse, mul(irradiance, BRDF_Lambert({ diffuseColor: diffuseColor.rgb })));
-  addTo(directSpecular, mul(irradiance, BRDF_GGX({ lightDirection, f0: specularColor, f90: 1, roughness })));
-});
-const PhysicalLightingModel = new ShaderNode((inputs) => {
-  RE_Direct_Physical(inputs);
-});
-export {
-  BRDF_GGX,
-  BRDF_Lambert,
-  D_GGX,
-  F_Schlick,
-  PhysicalLightingModel,
-  RE_Direct_Physical,
-  V_GGX_SmithCorrelated,
-  getDistanceAttenuation
-};

package/nodes/lights/LightContextNode.mjs

@@ -1,35 +0,0 @@
-import ContextNode from "../core/ContextNode.mjs";
-import VarNode from "../core/VarNode.mjs";
-import UniformNode from "../core/UniformNode.mjs";
-import OperatorNode from "../math/OperatorNode.mjs";
-import { PhysicalLightingModel } from "../functions/BSDFs.mjs";
-import { Vector3 } from "three";
-class LightContextNode extends ContextNode {
-  constructor(node) {
-    super(node);
-  }
-  getNodeType() {
-    return "vec3";
-  }
-  generate(builder) {
-    const material = builder.material;
-    let lightingModel = null;
-    if (material.isMeshStandardMaterial === true) {
-      lightingModel = PhysicalLightingModel;
-    }
-    const directDiffuse = new VarNode(new UniformNode(new Vector3()), "DirectDiffuse", "vec3");
-    const directSpecular = new VarNode(new UniformNode(new Vector3()), "DirectSpecular", "vec3");
-    this.context.directDiffuse = directDiffuse;
-    this.context.directSpecular = directSpecular;
-    if (lightingModel !== null) {
-      this.context.lightingModel = lightingModel;
-    }
-    const type = this.getNodeType(builder);
-    super.generate(builder, type);
-    const totalLight = new OperatorNode("+", directDiffuse, directSpecular);
-    return totalLight.build(builder, type);
-  }
-}
-export {
-  LightContextNode as default
-};

package/nodes/lights/LightNode.mjs

@@ -1,58 +0,0 @@
-import Node from "../core/Node.mjs";
-import Object3DNode from "../accessors/Object3DNode.mjs";
-import PositionNode from "../accessors/PositionNode.mjs";
-import UniformNode from "../core/UniformNode.mjs";
-import OperatorNode from "../math/OperatorNode.mjs";
-import MathNode from "../math/MathNode.mjs";
-import { NodeUpdateType } from "../core/constants.mjs";
-import { getDistanceAttenuation } from "../functions/BSDFs.mjs";
-import { Color } from "three";
-class LightNode extends Node {
-  constructor(light = null) {
-    super("vec3");
-    this.updateType = NodeUpdateType.Object;
-    this.light = light;
-    this._colorNode = new UniformNode(new Color());
-    this._lightCutoffDistanceNode = new UniformNode(0);
-    this._lightDecayExponentNode = new UniformNode(0);
-  }
-  getHash() {
-    return this.light.uuid;
-  }
-  update() {
-    this._colorNode.value.copy(this.light.color).multiplyScalar(this.light.intensity);
-    this._lightCutoffDistanceNode.value = this.light.distance;
-    this._lightDecayExponentNode.value = this.light.decay;
-  }
-  generate(builder) {
-    const lightPositionView = new Object3DNode(Object3DNode.VIEW_POSITION);
-    const positionView = new PositionNode(PositionNode.VIEW);
-    const lVector = new OperatorNode("-", lightPositionView, positionView);
-    const lightDirection = new MathNode(MathNode.NORMALIZE, lVector);
-    const lightDistance = new MathNode(MathNode.LENGTH, lVector);
-    const lightAttenuation = getDistanceAttenuation({
-      lightDistance,
-      cutoffDistance: this._lightCutoffDistanceNode,
-      decayExponent: this._lightDecayExponentNode
-    });
-    const lightColor = new OperatorNode("*", this._colorNode, lightAttenuation);
-    lightPositionView.object3d = this.light;
-    const lightingModelFunction = builder.context.lightingModel;
-    if (lightingModelFunction !== void 0) {
-      const directDiffuse = builder.context.directDiffuse;
-      const directSpecular = builder.context.directSpecular;
-      lightingModelFunction(
-        {
-          lightDirection,
-          lightColor,
-          directDiffuse,
-          directSpecular
-        },
-        builder
-      );
-    }
-  }
-}
-export {
-  LightNode as default
-};

package/nodes/lights/LightsNode.mjs

@@ -1,59 +0,0 @@
-import Node from "../core/Node.mjs";
-import LightNode from "./LightNode.mjs";
-const sortLights = (lights) => {
-  return lights.sort((a, b) => a.id - b.id);
-};
-class LightsNode extends Node {
-  constructor(lightNodes = []) {
-    super("vec3");
-    this.lightNodes = lightNodes;
-    this._hash = null;
-  }
-  get hasLight() {
-    return this.lightNodes.length > 0;
-  }
-  generate(builder) {
-    const lightNodes = this.lightNodes;
-    for (const lightNode of lightNodes) {
-      lightNode.build(builder);
-    }
-    return "vec3( 0.0 )";
-  }
-  getHash() {
-    if (this._hash === null) {
-      let hash = "";
-      const lightNodes = this.lightNodes;
-      for (const lightNode of lightNodes) {
-        hash += lightNode.light.uuid + " ";
-      }
-      this._hash = hash;
-    }
-    return this._hash;
-  }
-  getLightNodeByHash(hash) {
-    const lightNodes = this.lightNodes;
-    for (const lightNode of lightNodes) {
-      if (lightNode.light.uuid === hash) {
-        return lightNode;
-      }
-    }
-    return null;
-  }
-  fromLights(lights) {
-    const lightNodes = [];
-    lights = sortLights(lights);
-    for (const light of lights) {
-      let lightNode = this.getLightNodeByHash(light.uuid);
-      if (lightNode === null) {
-        lightNode = new LightNode(light);
-      }
-      lightNodes.push(lightNode);
-    }
-    this.lightNodes = lightNodes;
-    this._hash = null;
-    return this;
-  }
-}
-export {
-  LightsNode as default
-};

package/nodes/loaders/NodeLoader.mjs

@@ -1,66 +0,0 @@
-import { fromType } from "../Nodes.mjs";
-import { Loader } from "three";
-class NodeLoader extends Loader {
-  constructor(manager) {
-    super(manager);
-    this.textures = {};
-  }
-  load(url, onLoad, onProgress, onError) {
-    const loader = new FileLoader(this.manager);
-    loader.setPath(this.path);
-    loader.setRequestHeader(this.requestHeader);
-    loader.setWithCredentials(this.withCredentials);
-    loader.load(
-      url,
-      (text) => {
-        try {
-          onLoad(this.parse(JSON.parse(text)));
-        } catch (e) {
-          if (onError) {
-            onError(e);
-          } else {
-            console.error(e);
-          }
-          this.manager.itemError(url);
-        }
-      },
-      onProgress,
-      onError
-    );
-  }
-  parseNodes(json) {
-    const nodes = {};
-    if (json !== void 0) {
-      for (const nodeJSON of json) {
-        const { uuid, type: type2 } = nodeJSON;
-        nodes[uuid] = fromType(type2);
-        nodes[uuid].uuid = uuid;
-      }
-      const meta = { nodes, textures: this.textures };
-      for (const nodeJSON of json) {
-        nodeJSON.meta = meta;
-        const node = nodes[nodeJSON.uuid];
-        node.deserialize(nodeJSON);
-        delete nodeJSON.meta;
-      }
-    }
-    return nodes;
-  }
-  parse(json) {
-    const node = fromType(type);
-    node.uuid = json.uuid;
-    const nodes = this.parseNodes(json.inputNodes);
-    const meta = { nodes, textures: this.textures };
-    json.meta = meta;
-    node.deserialize(json);
-    delete json.meta;
-    return node;
-  }
-  setTextures(value) {
-    this.textures = value;
-    return this;
-  }
-}
-export {
-  NodeLoader as default
-};