three-stdlib 2.22.7 → 2.22.8

package/dist/modifiers/TessellateModifier.mjs

@@ -0,0 +1,214 @@
+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, Color, Vector2, BufferGeometry, Float32BufferAttribute } from "three";
+class TessellateModifier {
+  constructor(maxEdgeLength = 0.1, maxIterations = 6) {
+    __publicField(this, "maxEdgeLength");
+    __publicField(this, "maxIterations");
+    __publicField(this, "modify", (geometry) => {
+      if (geometry.index !== null) {
+        geometry = geometry.toNonIndexed();
+      }
+      const maxIterations = this.maxIterations;
+      const maxEdgeLengthSquared = this.maxEdgeLength * this.maxEdgeLength;
+      const va = new Vector3();
+      const vb = new Vector3();
+      const vc = new Vector3();
+      const vm = new Vector3();
+      const vs = [va, vb, vc, vm];
+      const na = new Vector3();
+      const nb = new Vector3();
+      const nc = new Vector3();
+      const nm = new Vector3();
+      const ns = [na, nb, nc, nm];
+      const ca = new Color();
+      const cb = new Color();
+      const cc = new Color();
+      const cm = new Color();
+      const cs = [ca, cb, cc, cm];
+      const ua = new Vector2();
+      const ub = new Vector2();
+      const uc = new Vector2();
+      const um = new Vector2();
+      const us = [ua, ub, uc, um];
+      const u2a = new Vector2();
+      const u2b = new Vector2();
+      const u2c = new Vector2();
+      const u2m = new Vector2();
+      const u2s = [u2a, u2b, u2c, u2m];
+      const attributes = geometry.attributes;
+      const hasNormals = attributes.normal !== void 0;
+      const hasColors = attributes.color !== void 0;
+      const hasUVs = attributes.uv !== void 0;
+      const hasUV2s = attributes.uv2 !== void 0;
+      let positions = attributes.position.array;
+      let normals = hasNormals ? attributes.normal.array : null;
+      let colors = hasColors ? attributes.color.array : null;
+      let uvs = hasUVs ? attributes.uv.array : null;
+      let uv2s = hasUV2s ? attributes.uv2.array : null;
+      let positions2 = positions;
+      let normals2 = normals;
+      let colors2 = colors;
+      let uvs2 = uvs;
+      let uv2s2 = uv2s;
+      let iteration = 0;
+      let tessellating = true;
+      function addTriangle(a, b, c) {
+        const v1 = vs[a];
+        const v2 = vs[b];
+        const v3 = vs[c];
+        positions2.push(v1.x, v1.y, v1.z);
+        positions2.push(v2.x, v2.y, v2.z);
+        positions2.push(v3.x, v3.y, v3.z);
+        if (hasNormals) {
+          const n1 = ns[a];
+          const n2 = ns[b];
+          const n3 = ns[c];
+          normals2.push(n1.x, n1.y, n1.z);
+          normals2.push(n2.x, n2.y, n2.z);
+          normals2.push(n3.x, n3.y, n3.z);
+        }
+        if (hasColors) {
+          const c1 = cs[a];
+          const c2 = cs[b];
+          const c3 = cs[c];
+          colors2.push(c1.r, c1.g, c1.b);
+          colors2.push(c2.r, c2.g, c2.b);
+          colors2.push(c3.r, c3.g, c3.b);
+        }
+        if (hasUVs) {
+          const u1 = us[a];
+          const u2 = us[b];
+          const u3 = us[c];
+          uvs2.push(u1.x, u1.y);
+          uvs2.push(u2.x, u2.y);
+          uvs2.push(u3.x, u3.y);
+        }
+        if (hasUV2s) {
+          const u21 = u2s[a];
+          const u22 = u2s[b];
+          const u23 = u2s[c];
+          uv2s2.push(u21.x, u21.y);
+          uv2s2.push(u22.x, u22.y);
+          uv2s2.push(u23.x, u23.y);
+        }
+      }
+      while (tessellating && iteration < maxIterations) {
+        iteration++;
+        tessellating = false;
+        positions = positions2;
+        positions2 = [];
+        if (hasNormals) {
+          normals = normals2;
+          normals2 = [];
+        }
+        if (hasColors) {
+          colors = colors2;
+          colors2 = [];
+        }
+        if (hasUVs) {
+          uvs = uvs2;
+          uvs2 = [];
+        }
+        if (hasUV2s) {
+          uv2s = uv2s2;
+          uv2s2 = [];
+        }
+        for (let i = 0, i2 = 0, il = positions.length; i < il; i += 9, i2 += 6) {
+          va.fromArray(positions, i + 0);
+          vb.fromArray(positions, i + 3);
+          vc.fromArray(positions, i + 6);
+          if (hasNormals && normals) {
+            na.fromArray(normals, i + 0);
+            nb.fromArray(normals, i + 3);
+            nc.fromArray(normals, i + 6);
+          }
+          if (hasColors && colors) {
+            ca.fromArray(colors, i + 0);
+            cb.fromArray(colors, i + 3);
+            cc.fromArray(colors, i + 6);
+          }
+          if (hasUVs && uvs) {
+            ua.fromArray(uvs, i2 + 0);
+            ub.fromArray(uvs, i2 + 2);
+            uc.fromArray(uvs, i2 + 4);
+          }
+          if (hasUV2s && uv2s) {
+            u2a.fromArray(uv2s, i2 + 0);
+            u2b.fromArray(uv2s, i2 + 2);
+            u2c.fromArray(uv2s, i2 + 4);
+          }
+          const dab = va.distanceToSquared(vb);
+          const dbc = vb.distanceToSquared(vc);
+          const dac = va.distanceToSquared(vc);
+          if (dab > maxEdgeLengthSquared || dbc > maxEdgeLengthSquared || dac > maxEdgeLengthSquared) {
+            tessellating = true;
+            if (dab >= dbc && dab >= dac) {
+              vm.lerpVectors(va, vb, 0.5);
+              if (hasNormals)
+                nm.lerpVectors(na, nb, 0.5);
+              if (hasColors)
+                cm.lerpColors(ca, cb, 0.5);
+              if (hasUVs)
+                um.lerpVectors(ua, ub, 0.5);
+              if (hasUV2s)
+                u2m.lerpVectors(u2a, u2b, 0.5);
+              addTriangle(0, 3, 2);
+              addTriangle(3, 1, 2);
+            } else if (dbc >= dab && dbc >= dac) {
+              vm.lerpVectors(vb, vc, 0.5);
+              if (hasNormals)
+                nm.lerpVectors(nb, nc, 0.5);
+              if (hasColors)
+                cm.lerpColors(cb, cc, 0.5);
+              if (hasUVs)
+                um.lerpVectors(ub, uc, 0.5);
+              if (hasUV2s)
+                u2m.lerpVectors(u2b, u2c, 0.5);
+              addTriangle(0, 1, 3);
+              addTriangle(3, 2, 0);
+            } else {
+              vm.lerpVectors(va, vc, 0.5);
+              if (hasNormals)
+                nm.lerpVectors(na, nc, 0.5);
+              if (hasColors)
+                cm.lerpColors(ca, cc, 0.5);
+              if (hasUVs)
+                um.lerpVectors(ua, uc, 0.5);
+              if (hasUV2s)
+                u2m.lerpVectors(u2a, u2c, 0.5);
+              addTriangle(0, 1, 3);
+              addTriangle(3, 1, 2);
+            }
+          } else {
+            addTriangle(0, 1, 2);
+          }
+        }
+      }
+      const geometry2 = new BufferGeometry();
+      geometry2.setAttribute("position", new Float32BufferAttribute(positions2, 3));
+      if (hasNormals) {
+        geometry2.setAttribute("normal", new Float32BufferAttribute(normals2, 3));
+      }
+      if (hasColors) {
+        geometry2.setAttribute("color", new Float32BufferAttribute(colors2, 3));
+      }
+      if (hasUVs) {
+        geometry2.setAttribute("uv", new Float32BufferAttribute(uvs2, 2));
+      }
+      if (hasUV2s) {
+        geometry2.setAttribute("uv2", new Float32BufferAttribute(uv2s2, 2));
+      }
+      return geometry2;
+    });
+    this.maxEdgeLength = maxEdgeLength;
+    this.maxIterations = maxIterations;
+  }
+}
+export {
+  TessellateModifier
+};

package/dist/nodes/Nodes.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ArrayUniformNode = require("./core/ArrayUniformNode.js");
+const AttributeNode = require("./core/AttributeNode.js");
+const BypassNode = require("./core/BypassNode.js");
+const CodeNode = require("./core/CodeNode.js");
+const ConstNode = require("./core/ConstNode.js");
+const ContextNode = require("./core/ContextNode.js");
+const ExpressionNode = require("./core/ExpressionNode.js");
+const FunctionCallNode = require("./core/FunctionCallNode.js");
+const FunctionNode = require("./core/FunctionNode.js");
+const Node = require("./core/Node.js");
+const NodeAttribute = require("./core/NodeAttribute.js");
+const NodeBuilder = require("./core/NodeBuilder.js");
+const NodeCode = require("./core/NodeCode.js");
+const NodeFrame = require("./core/NodeFrame.js");
+const NodeFunctionInput = require("./core/NodeFunctionInput.js");
+const NodeKeywords = require("./core/NodeKeywords.js");
+const NodeUniform = require("./core/NodeUniform.js");
+const NodeVar = require("./core/NodeVar.js");
+const NodeVary = require("./core/NodeVary.js");
+const PropertyNode = require("./core/PropertyNode.js");
+const TempNode = require("./core/TempNode.js");
+const UniformNode = require("./core/UniformNode.js");
+const VarNode = require("./core/VarNode.js");
+const VaryNode = require("./core/VaryNode.js");
+const BufferNode = require("./accessors/BufferNode.js");
+const CameraNode = require("./accessors/CameraNode.js");
+const CubeTextureNode = require("./accessors/CubeTextureNode.js");
+const MaterialNode = require("./accessors/MaterialNode.js");
+const MaterialReferenceNode = require("./accessors/MaterialReferenceNode.js");
+const ModelNode = require("./accessors/ModelNode.js");
+const ModelViewProjectionNode = require("./accessors/ModelViewProjectionNode.js");
+const NormalNode = require("./accessors/NormalNode.js");
+const Object3DNode = require("./accessors/Object3DNode.js");
+const PointUVNode = require("./accessors/PointUVNode.js");
+const PositionNode = require("./accessors/PositionNode.js");
+const ReferenceNode = require("./accessors/ReferenceNode.js");
+const ReflectNode = require("./accessors/ReflectNode.js");
+const SkinningNode = require("./accessors/SkinningNode.js");
+const TextureNode = require("./accessors/TextureNode.js");
+const UVNode = require("./accessors/UVNode.js");
+const ColorSpaceNode = require("./display/ColorSpaceNode.js");
+const NormalMapNode = require("./display/NormalMapNode.js");
+const MathNode = require("./math/MathNode.js");
+const OperatorNode = require("./math/OperatorNode.js");
+const CondNode = require("./math/CondNode.js");
+const LightContextNode = require("./lights/LightContextNode.js");
+const LightNode = require("./lights/LightNode.js");
+const LightsNode = require("./lights/LightsNode.js");
+const ArrayElementNode = require("./utils/ArrayElementNode.js");
+const ConvertNode = require("./utils/ConvertNode.js");
+const JoinNode = require("./utils/JoinNode.js");
+const SplitNode = require("./utils/SplitNode.js");
+const SpriteSheetUVNode = require("./utils/SpriteSheetUVNode.js");
+const MatcapUVNode = require("./utils/MatcapUVNode.js");
+const OscNode = require("./utils/OscNode.js");
+const TimerNode = require("./utils/TimerNode.js");
+const NodeLoader = require("./loaders/NodeLoader.js");
+const NodeObjectLoader = require("./loaders/NodeObjectLoader.js");
+const NodeMaterialLoader = require("./loaders/NodeMaterialLoader.js");
+const CheckerNode = require("./procedural/CheckerNode.js");
+const FogNode = require("./fog/FogNode.js");
+const FogRangeNode = require("./fog/FogRangeNode.js");
+const constants = require("./core/constants.js");
+const BSDFs = require("./functions/BSDFs.js");
+require("./materials/Materials.js");
+const ShaderNode = require("./ShaderNode.js");
+const LineBasicNodeMaterial = require("./materials/LineBasicNodeMaterial.js");
+const MeshBasicNodeMaterial = require("./materials/MeshBasicNodeMaterial.js");
+const MeshStandardNodeMaterial = require("./materials/MeshStandardNodeMaterial.js");
+const PointsNodeMaterial = require("./materials/PointsNodeMaterial.js");
+const nodeLib = {
+  // core
+  ArrayUniformNode,
+  AttributeNode,
+  BypassNode,
+  CodeNode,
+  ContextNode,
+  ConstNode,
+  ExpressionNode,
+  FunctionCallNode,
+  FunctionNode,
+  Node,
+  NodeAttribute,
+  NodeBuilder: NodeBuilder.default,
+  NodeCode,
+  NodeFrame,
+  NodeFunctionInput,
+  NodeKeywords,
+  NodeUniform,
+  NodeVar,
+  NodeVary,
+  PropertyNode,
+  TempNode,
+  UniformNode,
+  VarNode,
+  VaryNode,
+  // accessors
+  BufferNode,
+  CameraNode,
+  CubeTextureNode,
+  MaterialNode,
+  MaterialReferenceNode,
+  ModelNode,
+  ModelViewProjectionNode,
+  NormalNode,
+  Object3DNode,
+  PointUVNode,
+  PositionNode,
+  ReferenceNode,
+  ReflectNode,
+  SkinningNode,
+  TextureNode,
+  UVNode,
+  // display
+  ColorSpaceNode: ColorSpaceNode.default,
+  NormalMapNode,
+  // math
+  MathNode,
+  OperatorNode,
+  CondNode,
+  // lights
+  LightContextNode,
+  LightNode,
+  LightsNode,
+  // utils
+  ArrayElementNode,
+  ConvertNode,
+  JoinNode,
+  SplitNode,
+  SpriteSheetUVNode,
+  MatcapUVNode,
+  OscNode,
+  TimerNode,
+  // procedural
+  CheckerNode,
+  // fog
+  FogNode,
+  FogRangeNode,
+  // loaders
+  NodeLoader,
+  NodeObjectLoader,
+  NodeMaterialLoader
+};
+const fromType = (type) => {
+  return new nodeLib[type]();
+};
+exports.ArrayUniformNode = ArrayUniformNode;
+exports.AttributeNode = AttributeNode;
+exports.BypassNode = BypassNode;
+exports.CodeNode = CodeNode;
+exports.ConstNode = ConstNode;
+exports.ContextNode = ContextNode;
+exports.ExpressionNode = ExpressionNode;
+exports.FunctionCallNode = FunctionCallNode;
+exports.FunctionNode = FunctionNode;
+exports.Node = Node;
+exports.NodeAttribute = NodeAttribute;
+exports.NodeBuilder = NodeBuilder.default;
+exports.NodeCode = NodeCode;
+exports.NodeFrame = NodeFrame;
+exports.NodeFunctionInput = NodeFunctionInput;
+exports.NodeKeywords = NodeKeywords;
+exports.NodeUniform = NodeUniform;
+exports.NodeVar = NodeVar;
+exports.NodeVary = NodeVary;
+exports.PropertyNode = PropertyNode;
+exports.TempNode = TempNode;
+exports.UniformNode = UniformNode;
+exports.VarNode = VarNode;
+exports.VaryNode = VaryNode;
+exports.BufferNode = BufferNode;
+exports.CameraNode = CameraNode;
+exports.CubeTextureNode = CubeTextureNode;
+exports.MaterialNode = MaterialNode;
+exports.MaterialReferenceNode = MaterialReferenceNode;
+exports.ModelNode = ModelNode;
+exports.ModelViewProjectionNode = ModelViewProjectionNode;
+exports.NormalNode = NormalNode;
+exports.Object3DNode = Object3DNode;
+exports.PointUVNode = PointUVNode;
+exports.PositionNode = PositionNode;
+exports.ReferenceNode = ReferenceNode;
+exports.ReflectNode = ReflectNode;
+exports.SkinningNode = SkinningNode;
+exports.TextureNode = TextureNode;
+exports.UVNode = UVNode;
+exports.ColorSpaceNode = ColorSpaceNode.default;
+exports.NormalMapNode = NormalMapNode;
+exports.MathNode = MathNode;
+exports.OperatorNode = OperatorNode;
+exports.CondNode = CondNode;
+exports.LightContextNode = LightContextNode;
+exports.LightNode = LightNode;
+exports.LightsNode = LightsNode;
+exports.ArrayElementNode = ArrayElementNode;
+exports.ConvertNode = ConvertNode;
+exports.JoinNode = JoinNode;
+exports.SplitNode = SplitNode;
+exports.SpriteSheetUVNode = SpriteSheetUVNode;
+exports.MatcapUVNode = MatcapUVNode;
+exports.OscNode = OscNode;
+exports.TimerNode = TimerNode;
+exports.NodeLoader = NodeLoader;
+exports.NodeObjectLoader = NodeObjectLoader;
+exports.NodeMaterialLoader = NodeMaterialLoader;
+exports.CheckerNode = CheckerNode;
+exports.FogNode = FogNode;
+exports.FogRangeNode = FogRangeNode;
+exports.NodeShaderStage = constants.NodeShaderStage;
+exports.NodeType = constants.NodeType;
+exports.NodeUpdateType = constants.NodeUpdateType;
+exports.BRDF_GGX = BSDFs.BRDF_GGX;
+exports.BRDF_Lambert = BSDFs.BRDF_Lambert;
+exports.D_GGX = BSDFs.D_GGX;
+exports.F_Schlick = BSDFs.F_Schlick;
+exports.PhysicalLightingModel = BSDFs.PhysicalLightingModel;
+exports.RE_Direct_Physical = BSDFs.RE_Direct_Physical;
+exports.V_GGX_SmithCorrelated = BSDFs.V_GGX_SmithCorrelated;
+exports.getDistanceAttenuation = BSDFs.getDistanceAttenuation;
+exports.EPSILON = ShaderNode.EPSILON;
+exports.INFINITY = ShaderNode.INFINITY;
+exports.ShaderNode = ShaderNode.ShaderNode;
+exports.abs = ShaderNode.abs;
+exports.acos = ShaderNode.acos;
+exports.add = ShaderNode.add;
+exports.addTo = ShaderNode.addTo;
+exports.alphaTest = ShaderNode.alphaTest;
+exports.and = ShaderNode.and;
+exports.asin = ShaderNode.asin;
+exports.assign = ShaderNode.assign;
+exports.atan = ShaderNode.atan;
+exports.attribute = ShaderNode.attribute;
+exports.bitAnd = ShaderNode.bitAnd;
+exports.bitOr = ShaderNode.bitOr;
+exports.bitXor = ShaderNode.bitXor;
+exports.bmat3 = ShaderNode.bmat3;
+exports.bmat4 = ShaderNode.bmat4;
+exports.bool = ShaderNode.bool;
+exports.buffer = ShaderNode.buffer;
+exports.bvec2 = ShaderNode.bvec2;
+exports.bvec3 = ShaderNode.bvec3;
+exports.bvec4 = ShaderNode.bvec4;
+exports.cameraPosition = ShaderNode.cameraPosition;
+exports.ceil = ShaderNode.ceil;
+exports.clamp = ShaderNode.clamp;
+exports.color = ShaderNode.color;
+exports.cond = ShaderNode.cond;
+exports.cos = ShaderNode.cos;
+exports.cross = ShaderNode.cross;
+exports.dFdx = ShaderNode.dFdx;
+exports.dFdy = ShaderNode.dFdy;
+exports.degrees = ShaderNode.degrees;
+exports.diffuseColor = ShaderNode.diffuseColor;
+exports.distance = ShaderNode.distance;
+exports.div = ShaderNode.div;
+exports.dot = ShaderNode.dot;
+exports.element = ShaderNode.element;
+exports.equal = ShaderNode.equal;
+exports.exp = ShaderNode.exp;
+exports.exp2 = ShaderNode.exp2;
+exports.faceforward = ShaderNode.faceforward;
+exports.float = ShaderNode.float;
+exports.floor = ShaderNode.floor;
+exports.fract = ShaderNode.fract;
+exports.greaterThan = ShaderNode.greaterThan;
+exports.greaterThanEqual = ShaderNode.greaterThanEqual;
+exports.imat3 = ShaderNode.imat3;
+exports.imat4 = ShaderNode.imat4;
+exports.int = ShaderNode.int;
+exports.inversesqrt = ShaderNode.inversesqrt;
+exports.invert = ShaderNode.invert;
+exports.ivec2 = ShaderNode.ivec2;
+exports.ivec3 = ShaderNode.ivec3;
+exports.ivec4 = ShaderNode.ivec4;
+exports.join = ShaderNode.join;
+exports.label = ShaderNode.label;
+exports.length = ShaderNode.length;
+exports.lessThan = ShaderNode.lessThan;
+exports.lessThanEqual = ShaderNode.lessThanEqual;
+exports.log = ShaderNode.log;
+exports.log2 = ShaderNode.log2;
+exports.mat3 = ShaderNode.mat3;
+exports.mat4 = ShaderNode.mat4;
+exports.max = ShaderNode.max;
+exports.metalness = ShaderNode.metalness;
+exports.min = ShaderNode.min;
+exports.mix = ShaderNode.mix;
+exports.mod = ShaderNode.mod;
+exports.mul = ShaderNode.mul;
+exports.negate = ShaderNode.negate;
+exports.nodeObject = ShaderNode.nodeObject;
+exports.normalGeometry = ShaderNode.normalGeometry;
+exports.normalLocal = ShaderNode.normalLocal;
+exports.normalView = ShaderNode.normalView;
+exports.normalWorld = ShaderNode.normalWorld;
+exports.normalize = ShaderNode.normalize;
+exports.or = ShaderNode.or;
+exports.positionLocal = ShaderNode.positionLocal;
+exports.positionView = ShaderNode.positionView;
+exports.positionViewDirection = ShaderNode.positionViewDirection;
+exports.positionWorld = ShaderNode.positionWorld;
+exports.pow = ShaderNode.pow;
+exports.pow2 = ShaderNode.pow2;
+exports.pow3 = ShaderNode.pow3;
+exports.pow4 = ShaderNode.pow4;
+exports.radians = ShaderNode.radians;
+exports.reflect = ShaderNode.reflect;
+exports.refract = ShaderNode.refract;
+exports.remainder = ShaderNode.remainder;
+exports.roughness = ShaderNode.roughness;
+exports.round = ShaderNode.round;
+exports.sampler = ShaderNode.sampler;
+exports.saturate = ShaderNode.saturate;
+exports.shiftLeft = ShaderNode.shiftLeft;
+exports.shiftRight = ShaderNode.shiftRight;
+exports.sign = ShaderNode.sign;
+exports.sin = ShaderNode.sin;
+exports.smoothstep = ShaderNode.smoothstep;
+exports.specularColor = ShaderNode.specularColor;
+exports.sqrt = ShaderNode.sqrt;
+exports.step = ShaderNode.step;
+exports.sub = ShaderNode.sub;
+exports.tan = ShaderNode.tan;
+exports.temp = ShaderNode.temp;
+exports.texture = ShaderNode.texture;
+exports.transformDirection = ShaderNode.transformDirection;
+exports.transformedNormalView = ShaderNode.transformedNormalView;
+exports.uint = ShaderNode.uint;
+exports.umat3 = ShaderNode.umat3;
+exports.umat4 = ShaderNode.umat4;
+exports.uniform = ShaderNode.uniform;
+exports.uv = ShaderNode.uv;
+exports.uvec2 = ShaderNode.uvec2;
+exports.uvec3 = ShaderNode.uvec3;
+exports.uvec4 = ShaderNode.uvec4;
+exports.vec2 = ShaderNode.vec2;
+exports.vec3 = ShaderNode.vec3;
+exports.vec4 = ShaderNode.vec4;
+exports.viewMatrix = ShaderNode.viewMatrix;
+exports.xor = ShaderNode.xor;
+exports.LineBasicNodeMaterial = LineBasicNodeMaterial;
+exports.MeshBasicNodeMaterial = MeshBasicNodeMaterial;
+exports.MeshStandardNodeMaterial = MeshStandardNodeMaterial;
+exports.PointsNodeMaterial = PointsNodeMaterial;
+exports.fromType = fromType;