three-stdlib 2.15.2 → 2.16.1

package/nodes/accessors/Object3DNode.mjs

@@ -1,76 +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 { Vector3 } from "three";
-import Node from "../core/Node.mjs";
-import UniformNode from "../core/UniformNode.mjs";
-import { NodeUpdateType } from "../core/constants.mjs";
-const _Object3DNode = class extends Node {
-  constructor(scope = _Object3DNode.VIEW_MATRIX, object3d = null) {
-    super();
-    this.scope = scope;
-    this.object3d = object3d;
-    this.updateType = NodeUpdateType.Object;
-    this._uniformNode = new UniformNode(null);
-  }
-  getNodeType() {
-    const scope = this.scope;
-    if (scope === _Object3DNode.WORLD_MATRIX || scope === _Object3DNode.VIEW_MATRIX) {
-      return "mat4";
-    } else if (scope === _Object3DNode.NORMAL_MATRIX) {
-      return "mat3";
-    } else if (scope === _Object3DNode.POSITION || scope === _Object3DNode.VIEW_POSITION) {
-      return "vec3";
-    }
-  }
-  update(frame) {
-    const object = this.object3d !== null ? this.object3d : frame.object;
-    const uniformNode = this._uniformNode;
-    const camera = frame.camera;
-    const scope = this.scope;
-    if (scope === _Object3DNode.VIEW_MATRIX) {
-      uniformNode.value = object.modelViewMatrix;
-    } else if (scope === _Object3DNode.NORMAL_MATRIX) {
-      uniformNode.value = object.normalMatrix;
-    } else if (scope === _Object3DNode.WORLD_MATRIX) {
-      uniformNode.value = object.matrixWorld;
-    } else if (scope === _Object3DNode.POSITION) {
-      uniformNode.value.setFromMatrixPosition(object.matrixWorld);
-    } else if (scope === _Object3DNode.VIEW_POSITION) {
-      uniformNode.value.setFromMatrixPosition(object.matrixWorld);
-      uniformNode.value.applyMatrix4(camera.matrixWorldInverse);
-    }
-  }
-  generate(builder) {
-    const scope = this.scope;
-    if (scope === _Object3DNode.WORLD_MATRIX || scope === _Object3DNode.VIEW_MATRIX) {
-      this._uniformNode.nodeType = "mat4";
-    } else if (scope === _Object3DNode.NORMAL_MATRIX) {
-      this._uniformNode.nodeType = "mat3";
-    } else if (scope === _Object3DNode.POSITION || scope === _Object3DNode.VIEW_POSITION) {
-      this._uniformNode.nodeType = "vec3";
-      this._uniformNode.value = new Vector3();
-    }
-    return this._uniformNode.build(builder);
-  }
-  serialize(data) {
-    super.serialize(data);
-    data.scope = this.scope;
-  }
-  deserialize(data) {
-    super.deserialize(data);
-    this.scope = data.scope;
-  }
-};
-let Object3DNode = _Object3DNode;
-__publicField(Object3DNode, "VIEW_MATRIX", "viewMatrix");
-__publicField(Object3DNode, "NORMAL_MATRIX", "normalMatrix");
-__publicField(Object3DNode, "WORLD_MATRIX", "worldMatrix");
-__publicField(Object3DNode, "POSITION", "position");
-__publicField(Object3DNode, "VIEW_POSITION", "viewPosition");
-export {
-  Object3DNode as default
-};

package/nodes/accessors/PointUVNode.mjs

@@ -1,13 +0,0 @@
-import Node from "../core/Node.mjs";
-class PointUVNode extends Node {
-  constructor() {
-    super("vec2");
-  }
-  generate() {
-    return "vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y )";
-  }
-}
-PointUVNode.prototype.isPointUVNode = true;
-export {
-  PointUVNode as default
-};

package/nodes/accessors/PositionNode.mjs

@@ -1,65 +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 AttributeNode from "../core/AttributeNode.mjs";
-import VaryNode from "../core/VaryNode.mjs";
-import ModelNode from "./ModelNode.mjs";
-import MathNode from "../math/MathNode.mjs";
-import OperatorNode from "../math/OperatorNode.mjs";
-const _PositionNode = class extends Node {
-  constructor(scope = _PositionNode.LOCAL) {
-    super("vec3");
-    this.scope = scope;
-  }
-  getHash() {
-    return `position-${this.scope}`;
-  }
-  generate(builder) {
-    const scope = this.scope;
-    let outputNode = null;
-    if (scope === _PositionNode.GEOMETRY) {
-      outputNode = new AttributeNode("position", "vec3");
-    } else if (scope === _PositionNode.LOCAL) {
-      outputNode = new VaryNode(new _PositionNode(_PositionNode.GEOMETRY));
-    } else if (scope === _PositionNode.WORLD) {
-      const vertexPositionNode = new MathNode(
-        MathNode.TRANSFORM_DIRECTION,
-        new ModelNode(ModelNode.WORLD_MATRIX),
-        new _PositionNode(_PositionNode.LOCAL)
-      );
-      outputNode = new VaryNode(vertexPositionNode);
-    } else if (scope === _PositionNode.VIEW) {
-      const vertexPositionNode = new OperatorNode(
-        "*",
-        new ModelNode(ModelNode.VIEW_MATRIX),
-        new _PositionNode(_PositionNode.LOCAL)
-      );
-      outputNode = new VaryNode(vertexPositionNode);
-    } else if (scope === _PositionNode.VIEW_DIRECTION) {
-      const vertexPositionNode = new MathNode(MathNode.NEGATE, new _PositionNode(_PositionNode.VIEW));
-      outputNode = new MathNode(MathNode.NORMALIZE, new VaryNode(vertexPositionNode));
-    }
-    return outputNode.build(builder, this.getNodeType(builder));
-  }
-  serialize(data) {
-    super.serialize(data);
-    data.scope = this.scope;
-  }
-  deserialize(data) {
-    super.deserialize(data);
-    this.scope = data.scope;
-  }
-};
-let PositionNode = _PositionNode;
-__publicField(PositionNode, "GEOMETRY", "geometry");
-__publicField(PositionNode, "LOCAL", "local");
-__publicField(PositionNode, "WORLD", "world");
-__publicField(PositionNode, "VIEW", "view");
-__publicField(PositionNode, "VIEW_DIRECTION", "viewDirection");
-export {
-  PositionNode as default
-};

package/nodes/accessors/ReferenceNode.mjs

@@ -1,37 +0,0 @@
-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/nodes/accessors/ReflectNode.mjs

@@ -1,43 +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 { 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/nodes/accessors/SkinningNode.mjs

@@ -1,58 +0,0 @@
-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/nodes/accessors/TextureNode.mjs

@@ -1,54 +0,0 @@
-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/nodes/accessors/UVNode.mjs

@@ -1,23 +0,0 @@
-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/nodes/core/ArrayUniformNode.mjs

@@ -1,14 +0,0 @@
-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/nodes/core/AttributeNode.mjs

@@ -1,30 +0,0 @@
-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/nodes/core/BypassNode.mjs

@@ -1,22 +0,0 @@
-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/nodes/core/CodeNode.mjs

@@ -1,28 +0,0 @@
-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/nodes/core/ConstNode.mjs

@@ -1,14 +0,0 @@
-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/nodes/core/ContextNode.mjs

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

package/nodes/core/ExpressionNode.mjs

@@ -1,19 +0,0 @@
-import TempNode from "./TempNode.mjs";
-class ExpressionNode extends TempNode {
-  constructor(snipped = "", nodeType = "void") {
-    super(nodeType);
-    this.snipped = snipped;
-  }
-  generate(builder) {
-    const type = this.getNodeType(builder);
-    const snipped = this.snipped;
-    if (type === "void") {
-      builder.addFlowCode(snipped);
-    } else {
-      return `( ${snipped} )`;
-    }
-  }
-}
-export {
-  ExpressionNode as default
-};

package/nodes/core/FunctionCallNode.mjs

@@ -1,37 +0,0 @@
-import TempNode from "./TempNode.mjs";
-class FunctionCallNode extends TempNode {
-  constructor(functionNode = null, parameters = {}) {
-    super();
-    this.functionNode = functionNode;
-    this.parameters = parameters;
-  }
-  setParameters(parameters) {
-    this.parameters = parameters;
-    return this;
-  }
-  getParameters() {
-    return this.parameters;
-  }
-  getNodeType(builder) {
-    return this.functionNode.getNodeType(builder);
-  }
-  generate(builder) {
-    const params = [];
-    const functionNode = this.functionNode;
-    const inputs = functionNode.getInputs(builder);
-    const parameters = this.parameters;
-    for (const inputNode of inputs) {
-      const node = parameters[inputNode.name];
-      if (node !== void 0) {
-        params.push(node.build(builder, inputNode.type));
-      } else {
-        throw new Error(`FunctionCallNode: Input '${inputNode.name}' not found in FunctionNode.`);
-      }
-    }
-    const functionName = functionNode.build(builder, "property");
-    return `${functionName}( ${params.join(", ")} )`;
-  }
-}
-export {
-  FunctionCallNode as default
-};

package/nodes/core/FunctionNode.mjs

@@ -1,56 +0,0 @@
-import CodeNode from "./CodeNode.mjs";
-import FunctionCallNode from "./FunctionCallNode.mjs";
-class FunctionNode extends CodeNode {
-  constructor(code = "") {
-    super(code);
-    this.keywords = {};
-  }
-  getNodeType(builder) {
-    return this.getNodeFunction(builder).type;
-  }
-  getInputs(builder) {
-    return this.getNodeFunction(builder).inputs;
-  }
-  getNodeFunction(builder) {
-    const nodeData = builder.getDataFromNode(this);
-    let nodeFunction = nodeData.nodeFunction;
-    if (nodeFunction === void 0) {
-      nodeFunction = builder.parser.parseFunction(this.code);
-      nodeData.nodeFunction = nodeFunction;
-    }
-    return nodeFunction;
-  }
-  call(parameters = {}) {
-    return new FunctionCallNode(this, parameters);
-  }
-  generate(builder, output) {
-    super.generate(builder);
-    const nodeFunction = this.getNodeFunction(builder);
-    const name = nodeFunction.name;
-    const type = nodeFunction.type;
-    const nodeCode = builder.getCodeFromNode(this, type);
-    if (name !== "") {
-      nodeCode.name = name;
-    }
-    const propertyName = builder.getPropertyName(nodeCode);
-    let code = this.getNodeFunction(builder).getCode(propertyName);
-    const keywords = this.keywords;
-    const keywordsProperties = Object.keys(keywords);
-    if (keywordsProperties.length > 0) {
-      for (const property of keywordsProperties) {
-        const propertyRegExp = new RegExp(`\\b${property}\\b`, "g");
-        const nodeProperty = keywords[property].build(builder, "property");
-        code = code.replace(propertyRegExp, nodeProperty);
-      }
-    }
-    nodeCode.code = code;
-    if (output === "property") {
-      return propertyName;
-    } else {
-      return builder.format(`${propertyName}()`, type, output);
-    }
-  }
-}
-export {
-  FunctionNode as default
-};

package/nodes/core/InputNode.mjs

@@ -1,38 +0,0 @@
-import Node from "./Node.mjs";
-import { getValueType, getValueFromType } from "./NodeUtils.mjs";
-class InputNode extends Node {
-  constructor(value, nodeType = null) {
-    super(nodeType);
-    this.value = value;
-  }
-  getNodeType() {
-    if (this.nodeType === null) {
-      return getValueType(this.value);
-    }
-    return this.nodeType;
-  }
-  getInputType(builder) {
-    return this.getNodeType(builder);
-  }
-  serialize(data) {
-    var _a, _b;
-    super.serialize(data);
-    data.value = ((_b = (_a = this.value) == null ? void 0 : _a.toArray) == null ? void 0 : _b.call(_a)) || this.value;
-    data.valueType = getValueType(this.value);
-    data.nodeType = this.nodeType;
-  }
-  deserialize(data) {
-    var _a, _b;
-    super.deserialize(data);
-    this.nodeType = data.nodeType;
-    this.value = getValueFromType(data.valueType);
-    this.value = ((_b = (_a = this.value) == null ? void 0 : _a.fromArray) == null ? void 0 : _b.call(_a, data.value)) || data.value;
-  }
-  generate() {
-    console.warn("Abstract function.");
-  }
-}
-InputNode.prototype.isInputNode = true;
-export {
-  InputNode as default
-};