three-stdlib 2.22.7 → 2.22.8

package/dist/nodes/accessors/ReferenceNode.mjs

@@ -0,0 +1,37 @@
+import Node from "../core/Node.mjs";
+import UniformNode from "../core/UniformNode.mjs";
+import { NodeUpdateType } from "../core/constants.mjs";
+class ReferenceNode extends Node {
+  constructor(property, uniformType, object = null) {
+    super();
+    this.property = property;
+    this.uniformType = uniformType;
+    this.object = object;
+    this.node = null;
+    this.updateType = NodeUpdateType.Object;
+    this.setNodeType(uniformType);
+  }
+  setNodeType(uniformType) {
+    this.node = new UniformNode(null, uniformType);
+    this.nodeType = uniformType;
+    if (uniformType === "color") {
+      this.nodeType = "vec3";
+    } else if (uniformType === "texture") {
+      this.nodeType = "vec4";
+    }
+  }
+  getNodeType() {
+    return this.uniformType;
+  }
+  update(frame) {
+    const object = this.object !== null ? this.object : frame.object;
+    const value = object[this.property];
+    this.node.value = value;
+  }
+  generate(builder) {
+    return this.node.build(builder, this.getNodeType(builder));
+  }
+}
+export {
+  ReferenceNode as default
+};

package/dist/nodes/accessors/ReflectNode.js

@@ -0,0 +1,42 @@
+"use strict";
+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;
+};
+const Node = require("../core/Node.js");
+const ShaderNode = require("../ShaderNode.js");
+const _ReflectNode = class extends Node {
+  constructor(scope = _ReflectNode.CUBE) {
+    super("vec3");
+    this.scope = scope;
+  }
+  getHash() {
+    return `reflect-${this.scope}`;
+  }
+  generate(builder) {
+    const scope = this.scope;
+    if (scope === _ReflectNode.VECTOR) {
+      const cameraToFrag = ShaderNode.normalize(ShaderNode.sub(ShaderNode.positionWorld, ShaderNode.cameraPosition));
+      const reflectVec = ShaderNode.reflect(cameraToFrag, ShaderNode.normalWorld);
+      return reflectVec.build(builder);
+    } else if (scope === _ReflectNode.CUBE) {
+      const reflectVec = ShaderNode.nodeObject(new _ReflectNode(_ReflectNode.VECTOR));
+      const cubeUV = ShaderNode.join(ShaderNode.negate(reflectVec.x), reflectVec.yz);
+      return cubeUV.build(builder);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.scope = this.scope;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.scope = data.scope;
+  }
+};
+let ReflectNode = _ReflectNode;
+__publicField(ReflectNode, "VECTOR", "vector");
+__publicField(ReflectNode, "CUBE", "cube");
+module.exports = ReflectNode;

package/dist/nodes/accessors/ReflectNode.mjs

@@ -0,0 +1,43 @@
+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 { normalize, sub, positionWorld, cameraPosition, reflect, normalWorld, nodeObject, join, negate } from "../ShaderNode.mjs";
+const _ReflectNode = class extends Node {
+  constructor(scope = _ReflectNode.CUBE) {
+    super("vec3");
+    this.scope = scope;
+  }
+  getHash() {
+    return `reflect-${this.scope}`;
+  }
+  generate(builder) {
+    const scope = this.scope;
+    if (scope === _ReflectNode.VECTOR) {
+      const cameraToFrag = normalize(sub(positionWorld, cameraPosition));
+      const reflectVec = reflect(cameraToFrag, normalWorld);
+      return reflectVec.build(builder);
+    } else if (scope === _ReflectNode.CUBE) {
+      const reflectVec = nodeObject(new _ReflectNode(_ReflectNode.VECTOR));
+      const cubeUV = join(negate(reflectVec.x), reflectVec.yz);
+      return cubeUV.build(builder);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.scope = this.scope;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.scope = data.scope;
+  }
+};
+let ReflectNode = _ReflectNode;
+__publicField(ReflectNode, "VECTOR", "vector");
+__publicField(ReflectNode, "CUBE", "cube");
+export {
+  ReflectNode as default
+};

package/dist/nodes/accessors/SkinningNode.js

@@ -0,0 +1,57 @@
+"use strict";
+const Node = require("../core/Node.js");
+const ShaderNode = require("../ShaderNode.js");
+const constants = require("../core/constants.js");
+const Skinning = new ShaderNode.ShaderNode((inputs, builder) => {
+  const { index, weight, bindMatrix, bindMatrixInverse, boneMatrices } = inputs;
+  const boneMatX = ShaderNode.element(boneMatrices, index.x);
+  const boneMatY = ShaderNode.element(boneMatrices, index.y);
+  const boneMatZ = ShaderNode.element(boneMatrices, index.z);
+  const boneMatW = ShaderNode.element(boneMatrices, index.w);
+  const skinVertex = ShaderNode.mul(bindMatrix, ShaderNode.positionLocal);
+  const skinned = ShaderNode.add(
+    ShaderNode.mul(ShaderNode.mul(boneMatX, skinVertex), weight.x),
+    ShaderNode.mul(ShaderNode.mul(boneMatY, skinVertex), weight.y),
+    ShaderNode.mul(ShaderNode.mul(boneMatZ, skinVertex), weight.z),
+    ShaderNode.mul(ShaderNode.mul(boneMatW, skinVertex), weight.w)
+  );
+  const skinPosition = ShaderNode.mul(bindMatrixInverse, skinned).xyz;
+  let skinMatrix = ShaderNode.add(
+    ShaderNode.mul(weight.x, boneMatX),
+    ShaderNode.mul(weight.y, boneMatY),
+    ShaderNode.mul(weight.z, boneMatZ),
+    ShaderNode.mul(weight.w, boneMatW)
+  );
+  skinMatrix = ShaderNode.mul(ShaderNode.mul(bindMatrixInverse, skinMatrix), bindMatrix);
+  const skinNormal = ShaderNode.transformDirection(skinMatrix, ShaderNode.normalLocal).xyz;
+  ShaderNode.assign(ShaderNode.positionLocal, skinPosition).build(builder);
+  ShaderNode.assign(ShaderNode.normalLocal, skinNormal).build(builder);
+});
+class SkinningNode extends Node {
+  constructor(skinnedMesh) {
+    super("void");
+    this.skinnedMesh = skinnedMesh;
+    this.updateType = constants.NodeUpdateType.Object;
+    this.skinIndexNode = ShaderNode.attribute("skinIndex", "uvec4");
+    this.skinWeightNode = ShaderNode.attribute("skinWeight", "vec4");
+    this.bindMatrixNode = ShaderNode.uniform(ShaderNode.mat4(skinnedMesh.bindMatrix));
+    this.bindMatrixInverseNode = ShaderNode.uniform(ShaderNode.mat4(skinnedMesh.bindMatrixInverse));
+    this.boneMatricesNode = ShaderNode.buffer(skinnedMesh.skeleton.boneMatrices, "mat4", skinnedMesh.skeleton.bones.length);
+  }
+  generate(builder) {
+    Skinning(
+      {
+        index: this.skinIndexNode,
+        weight: this.skinWeightNode,
+        bindMatrix: this.bindMatrixNode,
+        bindMatrixInverse: this.bindMatrixInverseNode,
+        boneMatrices: this.boneMatricesNode
+      },
+      builder
+    );
+  }
+  update() {
+    this.skinnedMesh.skeleton.update();
+  }
+}
+module.exports = SkinningNode;

package/dist/nodes/accessors/SkinningNode.mjs

@@ -0,0 +1,58 @@
+import Node from "../core/Node.mjs";
+import { ShaderNode, element, mul, positionLocal, add, transformDirection, normalLocal, assign, attribute, uniform, mat4, buffer } from "../ShaderNode.mjs";
+import { NodeUpdateType } from "../core/constants.mjs";
+const Skinning = new ShaderNode((inputs, builder) => {
+  const { index, weight, bindMatrix, bindMatrixInverse, boneMatrices } = inputs;
+  const boneMatX = element(boneMatrices, index.x);
+  const boneMatY = element(boneMatrices, index.y);
+  const boneMatZ = element(boneMatrices, index.z);
+  const boneMatW = element(boneMatrices, index.w);
+  const skinVertex = mul(bindMatrix, positionLocal);
+  const skinned = add(
+    mul(mul(boneMatX, skinVertex), weight.x),
+    mul(mul(boneMatY, skinVertex), weight.y),
+    mul(mul(boneMatZ, skinVertex), weight.z),
+    mul(mul(boneMatW, skinVertex), weight.w)
+  );
+  const skinPosition = mul(bindMatrixInverse, skinned).xyz;
+  let skinMatrix = add(
+    mul(weight.x, boneMatX),
+    mul(weight.y, boneMatY),
+    mul(weight.z, boneMatZ),
+    mul(weight.w, boneMatW)
+  );
+  skinMatrix = mul(mul(bindMatrixInverse, skinMatrix), bindMatrix);
+  const skinNormal = transformDirection(skinMatrix, normalLocal).xyz;
+  assign(positionLocal, skinPosition).build(builder);
+  assign(normalLocal, skinNormal).build(builder);
+});
+class SkinningNode extends Node {
+  constructor(skinnedMesh) {
+    super("void");
+    this.skinnedMesh = skinnedMesh;
+    this.updateType = NodeUpdateType.Object;
+    this.skinIndexNode = attribute("skinIndex", "uvec4");
+    this.skinWeightNode = attribute("skinWeight", "vec4");
+    this.bindMatrixNode = uniform(mat4(skinnedMesh.bindMatrix));
+    this.bindMatrixInverseNode = uniform(mat4(skinnedMesh.bindMatrixInverse));
+    this.boneMatricesNode = buffer(skinnedMesh.skeleton.boneMatrices, "mat4", skinnedMesh.skeleton.bones.length);
+  }
+  generate(builder) {
+    Skinning(
+      {
+        index: this.skinIndexNode,
+        weight: this.skinWeightNode,
+        bindMatrix: this.bindMatrixNode,
+        bindMatrixInverse: this.bindMatrixInverseNode,
+        boneMatrices: this.boneMatricesNode
+      },
+      builder
+    );
+  }
+  update() {
+    this.skinnedMesh.skeleton.update();
+  }
+}
+export {
+  SkinningNode as default
+};

package/dist/nodes/accessors/TextureNode.js

@@ -0,0 +1,53 @@
+"use strict";
+const UniformNode = require("../core/UniformNode.js");
+const UVNode = require("./UVNode.js");
+class TextureNode extends UniformNode {
+  constructor(value, uvNode = new UVNode(), biasNode = null) {
+    super(value, "vec4");
+    this.uvNode = uvNode;
+    this.biasNode = biasNode;
+  }
+  getUniformHash() {
+    return this.value.uuid;
+  }
+  getInputType() {
+    return "texture";
+  }
+  generate(builder, output) {
+    const texture = this.value;
+    if (!texture || texture.isTexture !== true) {
+      throw new Error("TextureNode: Need a three.js texture.");
+    }
+    const textureProperty = super.generate(builder, "texture");
+    if (output === "sampler") {
+      return textureProperty + "_sampler";
+    } else if (builder.isReference(output)) {
+      return textureProperty;
+    } else {
+      const nodeData = builder.getDataFromNode(this);
+      let snippet = nodeData.snippet;
+      if (snippet === void 0) {
+        const uvSnippet = this.uvNode.build(builder, "vec2");
+        const biasNode = this.biasNode;
+        if (biasNode !== null) {
+          const biasSnippet = biasNode.build(builder, "float");
+          snippet = builder.getTextureBias(textureProperty, uvSnippet, biasSnippet);
+        } else {
+          snippet = builder.getTexture(textureProperty, uvSnippet);
+        }
+        nodeData.snippet = snippet;
+      }
+      return builder.format(snippet, "vec4", output);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.value = this.value.toJSON(data.meta).uuid;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.value = data.meta.textures[data.value];
+  }
+}
+TextureNode.prototype.isTextureNode = true;
+module.exports = TextureNode;

package/dist/nodes/accessors/TextureNode.mjs

@@ -0,0 +1,54 @@
+import UniformNode from "../core/UniformNode.mjs";
+import UVNode from "./UVNode.mjs";
+class TextureNode extends UniformNode {
+  constructor(value, uvNode = new UVNode(), biasNode = null) {
+    super(value, "vec4");
+    this.uvNode = uvNode;
+    this.biasNode = biasNode;
+  }
+  getUniformHash() {
+    return this.value.uuid;
+  }
+  getInputType() {
+    return "texture";
+  }
+  generate(builder, output) {
+    const texture = this.value;
+    if (!texture || texture.isTexture !== true) {
+      throw new Error("TextureNode: Need a three.js texture.");
+    }
+    const textureProperty = super.generate(builder, "texture");
+    if (output === "sampler") {
+      return textureProperty + "_sampler";
+    } else if (builder.isReference(output)) {
+      return textureProperty;
+    } else {
+      const nodeData = builder.getDataFromNode(this);
+      let snippet = nodeData.snippet;
+      if (snippet === void 0) {
+        const uvSnippet = this.uvNode.build(builder, "vec2");
+        const biasNode = this.biasNode;
+        if (biasNode !== null) {
+          const biasSnippet = biasNode.build(builder, "float");
+          snippet = builder.getTextureBias(textureProperty, uvSnippet, biasSnippet);
+        } else {
+          snippet = builder.getTexture(textureProperty, uvSnippet);
+        }
+        nodeData.snippet = snippet;
+      }
+      return builder.format(snippet, "vec4", output);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.value = this.value.toJSON(data.meta).uuid;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.value = data.meta.textures[data.value];
+  }
+}
+TextureNode.prototype.isTextureNode = true;
+export {
+  TextureNode as default
+};

package/dist/nodes/accessors/UVNode.js

@@ -0,0 +1,22 @@
+"use strict";
+const AttributeNode = require("../core/AttributeNode.js");
+class UVNode extends AttributeNode {
+  constructor(index = 0) {
+    super(null, "vec2");
+    this.index = index;
+  }
+  getAttributeName() {
+    const index = this.index;
+    return "uv" + (index > 0 ? index + 1 : "");
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.index = this.index;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.index = data.index;
+  }
+}
+UVNode.prototype.isUVNode = true;
+module.exports = UVNode;

package/dist/nodes/accessors/UVNode.mjs

@@ -0,0 +1,23 @@
+import AttributeNode from "../core/AttributeNode.mjs";
+class UVNode extends AttributeNode {
+  constructor(index = 0) {
+    super(null, "vec2");
+    this.index = index;
+  }
+  getAttributeName() {
+    const index = this.index;
+    return "uv" + (index > 0 ? index + 1 : "");
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.index = this.index;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.index = data.index;
+  }
+}
+UVNode.prototype.isUVNode = true;
+export {
+  UVNode as default
+};

package/dist/nodes/core/ArrayUniformNode.js

@@ -0,0 +1,13 @@
+"use strict";
+const UniformNode = require("./UniformNode.js");
+class ArrayUniformNode extends UniformNode {
+  constructor(nodes = []) {
+    super();
+    this.nodes = nodes;
+  }
+  getNodeType(builder) {
+    return this.nodes[0].getNodeType(builder);
+  }
+}
+ArrayUniformNode.prototype.isArrayUniformNode = true;
+module.exports = ArrayUniformNode;

package/dist/nodes/core/ArrayUniformNode.mjs

@@ -0,0 +1,14 @@
+import UniformNode from "./UniformNode.mjs";
+class ArrayUniformNode extends UniformNode {
+  constructor(nodes = []) {
+    super();
+    this.nodes = nodes;
+  }
+  getNodeType(builder) {
+    return this.nodes[0].getNodeType(builder);
+  }
+}
+ArrayUniformNode.prototype.isArrayUniformNode = true;
+export {
+  ArrayUniformNode as default
+};

package/dist/nodes/core/AttributeNode.js

@@ -0,0 +1,29 @@
+"use strict";
+const Node = require("./Node.js");
+const VaryNode = require("./VaryNode.js");
+class AttributeNode extends Node {
+  constructor(attributeName, nodeType) {
+    super(nodeType);
+    this._attributeName = attributeName;
+  }
+  getHash(builder) {
+    return this.getAttributeName(builder);
+  }
+  setAttributeName(attributeName) {
+    this._attributeName = attributeName;
+    return this;
+  }
+  getAttributeName() {
+    return this._attributeName;
+  }
+  generate(builder) {
+    const attribute = builder.getAttribute(this.getAttributeName(builder), this.getNodeType(builder));
+    if (builder.isShaderStage("vertex")) {
+      return attribute.name;
+    } else {
+      const nodeVary = new VaryNode(this);
+      return nodeVary.build(builder, attribute.type);
+    }
+  }
+}
+module.exports = AttributeNode;

package/dist/nodes/core/AttributeNode.mjs

@@ -0,0 +1,30 @@
+import Node from "./Node.mjs";
+import VaryNode from "./VaryNode.mjs";
+class AttributeNode extends Node {
+  constructor(attributeName, nodeType) {
+    super(nodeType);
+    this._attributeName = attributeName;
+  }
+  getHash(builder) {
+    return this.getAttributeName(builder);
+  }
+  setAttributeName(attributeName) {
+    this._attributeName = attributeName;
+    return this;
+  }
+  getAttributeName() {
+    return this._attributeName;
+  }
+  generate(builder) {
+    const attribute = builder.getAttribute(this.getAttributeName(builder), this.getNodeType(builder));
+    if (builder.isShaderStage("vertex")) {
+      return attribute.name;
+    } else {
+      const nodeVary = new VaryNode(this);
+      return nodeVary.build(builder, attribute.type);
+    }
+  }
+}
+export {
+  AttributeNode as default
+};

package/dist/nodes/core/BypassNode.js

@@ -0,0 +1,21 @@
+"use strict";
+const Node = require("./Node.js");
+class BypassNode extends Node {
+  constructor(returnNode, callNode) {
+    super();
+    this.outputNode = returnNode;
+    this.callNode = callNode;
+  }
+  getNodeType(builder) {
+    return this.outputNode.getNodeType(builder);
+  }
+  generate(builder, output) {
+    const snippet = this.callNode.build(builder, "void");
+    if (snippet !== "") {
+      builder.addFlowCode(snippet);
+    }
+    return this.outputNode.build(builder, output);
+  }
+}
+BypassNode.prototype.isBypassNode = true;
+module.exports = BypassNode;

package/dist/nodes/core/BypassNode.mjs

@@ -0,0 +1,22 @@
+import Node from "./Node.mjs";
+class BypassNode extends Node {
+  constructor(returnNode, callNode) {
+    super();
+    this.outputNode = returnNode;
+    this.callNode = callNode;
+  }
+  getNodeType(builder) {
+    return this.outputNode.getNodeType(builder);
+  }
+  generate(builder, output) {
+    const snippet = this.callNode.build(builder, "void");
+    if (snippet !== "") {
+      builder.addFlowCode(snippet);
+    }
+    return this.outputNode.build(builder, output);
+  }
+}
+BypassNode.prototype.isBypassNode = true;
+export {
+  BypassNode as default
+};

package/dist/nodes/core/CodeNode.js

@@ -0,0 +1,27 @@
+"use strict";
+const Node = require("./Node.js");
+class CodeNode extends Node {
+  constructor(code = "", nodeType = "code") {
+    super(nodeType);
+    this.code = code;
+    this._includes = [];
+  }
+  setIncludes(includes) {
+    this._includes = includes;
+    return this;
+  }
+  getIncludes() {
+    return this._includes;
+  }
+  generate(builder) {
+    const includes = this.getIncludes(builder);
+    for (const include of includes) {
+      include.build(builder);
+    }
+    const nodeCode = builder.getCodeFromNode(this, this.getNodeType(builder));
+    nodeCode.code = this.code;
+    return nodeCode.code;
+  }
+}
+CodeNode.prototype.isCodeNode = true;
+module.exports = CodeNode;

package/dist/nodes/core/CodeNode.mjs

@@ -0,0 +1,28 @@
+import Node from "./Node.mjs";
+class CodeNode extends Node {
+  constructor(code = "", nodeType = "code") {
+    super(nodeType);
+    this.code = code;
+    this._includes = [];
+  }
+  setIncludes(includes) {
+    this._includes = includes;
+    return this;
+  }
+  getIncludes() {
+    return this._includes;
+  }
+  generate(builder) {
+    const includes = this.getIncludes(builder);
+    for (const include of includes) {
+      include.build(builder);
+    }
+    const nodeCode = builder.getCodeFromNode(this, this.getNodeType(builder));
+    nodeCode.code = this.code;
+    return nodeCode.code;
+  }
+}
+CodeNode.prototype.isCodeNode = true;
+export {
+  CodeNode as default
+};

package/dist/nodes/core/ConstNode.js

@@ -0,0 +1,13 @@
+"use strict";
+const InputNode = require("./InputNode.js");
+class ConstNode extends InputNode {
+  generateConst(builder) {
+    return builder.getConst(this.getNodeType(builder), this.value);
+  }
+  generate(builder, output) {
+    const type = this.getNodeType(builder);
+    return builder.format(this.generateConst(builder), type, output);
+  }
+}
+ConstNode.prototype.isConstNode = true;
+module.exports = ConstNode;

package/dist/nodes/core/ConstNode.mjs

@@ -0,0 +1,14 @@
+import InputNode from "./InputNode.mjs";
+class ConstNode extends InputNode {
+  generateConst(builder) {
+    return builder.getConst(this.getNodeType(builder), this.value);
+  }
+  generate(builder, output) {
+    const type = this.getNodeType(builder);
+    return builder.format(this.generateConst(builder), type, output);
+  }
+}
+ConstNode.prototype.isConstNode = true;
+export {
+  ConstNode as default
+};

package/dist/nodes/core/ContextNode.js

@@ -0,0 +1,21 @@
+"use strict";
+const Node = require("./Node.js");
+class ContextNode extends Node {
+  constructor(node, context = {}) {
+    super();
+    this.node = node;
+    this.context = context;
+  }
+  getNodeType(builder) {
+    return this.node.getNodeType(builder);
+  }
+  generate(builder, output) {
+    const previousContext = builder.getContext();
+    builder.setContext(Object.assign({}, builder.context, this.context));
+    const snippet = this.node.build(builder, output);
+    builder.setContext(previousContext);
+    return snippet;
+  }
+}
+ContextNode.prototype.isContextNode = true;
+module.exports = ContextNode;

package/dist/nodes/core/ContextNode.mjs

@@ -0,0 +1,22 @@
+import Node from "./Node.mjs";
+class ContextNode extends Node {
+  constructor(node, context = {}) {
+    super();
+    this.node = node;
+    this.context = context;
+  }
+  getNodeType(builder) {
+    return this.node.getNodeType(builder);
+  }
+  generate(builder, output) {
+    const previousContext = builder.getContext();
+    builder.setContext(Object.assign({}, builder.context, this.context));
+    const snippet = this.node.build(builder, output);
+    builder.setContext(previousContext);
+    return snippet;
+  }
+}
+ContextNode.prototype.isContextNode = true;
+export {
+  ContextNode as default
+};