three-stdlib 2.22.7 → 2.22.8

package/dist/nodes/display/NormalMapNode.mjs

@@ -0,0 +1,54 @@
+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/dist/nodes/fog/FogNode.js

@@ -0,0 +1,14 @@
+"use strict";
+const Node = require("../core/Node.js");
+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;
+module.exports = FogNode;

package/dist/nodes/fog/FogNode.mjs

@@ -0,0 +1,15 @@
+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/dist/nodes/fog/FogRangeNode.js

@@ -0,0 +1,16 @@
+"use strict";
+const FogNode = require("./FogNode.js");
+const ShaderNode = require("../ShaderNode.js");
+class FogRangeNode extends FogNode {
+  constructor(colorNode, nearNode, farNode) {
+    super(colorNode);
+    this.nearNode = nearNode;
+    this.farNode = farNode;
+  }
+  generate(builder) {
+    this.factorNode = ShaderNode.smoothstep(this.nearNode, this.farNode, ShaderNode.negate(ShaderNode.positionView.z));
+    return super.generate(builder);
+  }
+}
+FogRangeNode.prototype.isFogRangeNode = true;
+module.exports = FogRangeNode;

package/dist/nodes/fog/FogRangeNode.mjs

@@ -0,0 +1,17 @@
+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/dist/nodes/functions/BSDFs.js

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

package/dist/nodes/functions/BSDFs.mjs

@@ -0,0 +1,64 @@
+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/dist/nodes/lights/LightContextNode.js

@@ -0,0 +1,34 @@
+"use strict";
+const ContextNode = require("../core/ContextNode.js");
+const VarNode = require("../core/VarNode.js");
+const UniformNode = require("../core/UniformNode.js");
+const OperatorNode = require("../math/OperatorNode.js");
+const BSDFs = require("../functions/BSDFs.js");
+const THREE = require("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 = BSDFs.PhysicalLightingModel;
+    }
+    const directDiffuse = new VarNode(new UniformNode(new THREE.Vector3()), "DirectDiffuse", "vec3");
+    const directSpecular = new VarNode(new UniformNode(new THREE.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);
+  }
+}
+module.exports = LightContextNode;

package/dist/nodes/lights/LightContextNode.mjs

@@ -0,0 +1,35 @@
+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/dist/nodes/lights/LightNode.js

@@ -0,0 +1,57 @@
+"use strict";
+const Node = require("../core/Node.js");
+const Object3DNode = require("../accessors/Object3DNode.js");
+const PositionNode = require("../accessors/PositionNode.js");
+const UniformNode = require("../core/UniformNode.js");
+const OperatorNode = require("../math/OperatorNode.js");
+const MathNode = require("../math/MathNode.js");
+const constants = require("../core/constants.js");
+const BSDFs = require("../functions/BSDFs.js");
+const THREE = require("three");
+class LightNode extends Node {
+  constructor(light = null) {
+    super("vec3");
+    this.updateType = constants.NodeUpdateType.Object;
+    this.light = light;
+    this._colorNode = new UniformNode(new THREE.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 = BSDFs.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
+      );
+    }
+  }
+}
+module.exports = LightNode;

package/dist/nodes/lights/LightNode.mjs

@@ -0,0 +1,58 @@
+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/dist/nodes/lights/LightsNode.js

@@ -0,0 +1,58 @@
+"use strict";
+const Node = require("../core/Node.js");
+const LightNode = require("./LightNode.js");
+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;
+  }
+}
+module.exports = LightsNode;

package/dist/nodes/lights/LightsNode.mjs

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