three-stdlib 2.16.0 → 2.16.2

package/Nodes-4f766d71.js

@@ -0,0 +1,471 @@
+import ArrayUniformNode from './nodes/core/ArrayUniformNode.js';
+import AttributeNode from './nodes/core/AttributeNode.js';
+import BypassNode from './nodes/core/BypassNode.js';
+import CodeNode from './nodes/core/CodeNode.js';
+import ConstNode from './nodes/core/ConstNode.js';
+import ContextNode from './nodes/core/ContextNode.js';
+import ExpressionNode from './nodes/core/ExpressionNode.js';
+import FunctionCallNode from './nodes/core/FunctionCallNode.js';
+import FunctionNode from './nodes/core/FunctionNode.js';
+import Node from './nodes/core/Node.js';
+import NodeAttribute from './nodes/core/NodeAttribute.js';
+import NodeBuilder from './nodes/core/NodeBuilder.js';
+import NodeCode from './nodes/core/NodeCode.js';
+import NodeFrame from './nodes/core/NodeFrame.js';
+import NodeFunctionInput from './nodes/core/NodeFunctionInput.js';
+import NodeKeywords from './nodes/core/NodeKeywords.js';
+import NodeUniform from './nodes/core/NodeUniform.js';
+import NodeVar from './nodes/core/NodeVar.js';
+import NodeVary from './nodes/core/NodeVary.js';
+import PropertyNode from './nodes/core/PropertyNode.js';
+import TempNode from './nodes/core/TempNode.js';
+import UniformNode from './nodes/core/UniformNode.js';
+import VarNode from './nodes/core/VarNode.js';
+import VaryNode from './nodes/core/VaryNode.js';
+import BufferNode from './nodes/accessors/BufferNode.js';
+import CameraNode from './nodes/accessors/CameraNode.js';
+import CubeTextureNode from './nodes/accessors/CubeTextureNode.js';
+import MaterialNode from './nodes/accessors/MaterialNode.js';
+import MaterialReferenceNode from './nodes/accessors/MaterialReferenceNode.js';
+import ModelNode from './nodes/accessors/ModelNode.js';
+import ModelViewProjectionNode from './nodes/accessors/ModelViewProjectionNode.js';
+import NormalNode from './nodes/accessors/NormalNode.js';
+import Object3DNode from './nodes/accessors/Object3DNode.js';
+import PointUVNode from './nodes/accessors/PointUVNode.js';
+import PositionNode from './nodes/accessors/PositionNode.js';
+import ReferenceNode from './nodes/accessors/ReferenceNode.js';
+import ReflectNode from './nodes/accessors/ReflectNode.js';
+import SkinningNode from './nodes/accessors/SkinningNode.js';
+import TextureNode from './nodes/accessors/TextureNode.js';
+import UVNode from './nodes/accessors/UVNode.js';
+import ColorSpaceNode from './nodes/display/ColorSpaceNode.js';
+import NormalMapNode from './nodes/display/NormalMapNode.js';
+import MathNode from './nodes/math/MathNode.js';
+import OperatorNode from './nodes/math/OperatorNode.js';
+import CondNode from './nodes/math/CondNode.js';
+import LightContextNode from './nodes/lights/LightContextNode.js';
+import LightNode from './nodes/lights/LightNode.js';
+import LightsNode from './nodes/lights/LightsNode.js';
+import ArrayElementNode from './nodes/utils/ArrayElementNode.js';
+import ConvertNode from './nodes/utils/ConvertNode.js';
+import JoinNode from './nodes/utils/JoinNode.js';
+import SplitNode from './nodes/utils/SplitNode.js';
+import SpriteSheetUVNode from './nodes/utils/SpriteSheetUVNode.js';
+import MatcapUVNode from './nodes/utils/MatcapUVNode.js';
+import OscNode from './nodes/utils/OscNode.js';
+import TimerNode from './nodes/utils/TimerNode.js';
+import NodeMaterialLoader from './nodes/loaders/NodeMaterialLoader.js';
+import { Loader, ObjectLoader } from 'three';
+import CheckerNode from './nodes/procedural/CheckerNode.js';
+import FogNode from './nodes/fog/FogNode.js';
+import FogRangeNode from './nodes/fog/FogRangeNode.js';
+import { NodeShaderStage, NodeUpdateType, NodeType } from './nodes/core/constants.js';
+import { F_Schlick, BRDF_Lambert, getDistanceAttenuation, V_GGX_SmithCorrelated, D_GGX, BRDF_GGX, RE_Direct_Physical, PhysicalLightingModel } from './nodes/functions/BSDFs.js';
+import { ShaderNode, nodeObject, uniform, label, temp, color, float, int, uint, bool, vec2, ivec2, uvec2, bvec2, vec3, ivec3, uvec3, bvec3, vec4, ivec4, uvec4, bvec4, mat3, imat3, umat3, bmat3, mat4, imat4, umat4, bmat4, join, uv, attribute, buffer, texture, sampler, cond, addTo, add, sub, mul, div, remainder, equal, assign, lessThan, greaterThan, lessThanEqual, greaterThanEqual, and, or, xor, bitAnd, bitOr, bitXor, shiftLeft, shiftRight, element, normalGeometry, normalLocal, normalWorld, normalView, transformedNormalView, positionLocal, positionWorld, positionView, positionViewDirection, viewMatrix, cameraPosition, diffuseColor, roughness, metalness, alphaTest, specularColor, abs, acos, asin, atan, ceil, clamp, cos, cross, degrees, dFdx, dFdy, distance, dot, exp, exp2, faceforward, floor, fract, invert, inversesqrt, length, log, log2, max, min, mix, mod, negate, normalize, pow, pow2, pow3, pow4, radians, reflect, refract, round, saturate, sign, sin, smoothstep, sqrt, step, tan, transformDirection, EPSILON, INFINITY } from './nodes/ShaderNode.js';
+import LineBasicNodeMaterial from './nodes/materials/LineBasicNodeMaterial.js';
+import MeshBasicNodeMaterial from './nodes/materials/MeshBasicNodeMaterial.js';
+import MeshStandardNodeMaterial from './nodes/materials/MeshStandardNodeMaterial.js';
+import PointsNodeMaterial from './nodes/materials/PointsNodeMaterial.js';
+
+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 !== undefined) {
+      for (const nodeJSON of json) {
+        const {
+          uuid,
+          type
+        } = nodeJSON;
+        nodes[uuid] = fromType(type);
+        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;
+  }
+
+}
+
+class NodeObjectLoader extends ObjectLoader {
+  constructor(manager) {
+    super(manager);
+    this._nodesJSON = null;
+  }
+
+  parse(json, onLoad) {
+    this._nodesJSON = json.nodes;
+    const data = super.parse(json, onLoad);
+    this._nodesJSON = null; // dispose
+
+    return data;
+  }
+
+  parseNodes(json, textures) {
+    if (json !== undefined) {
+      const loader = new NodeLoader();
+      loader.setTextures(textures);
+      return loader.parseNodes(json);
+    }
+
+    return {};
+  }
+
+  parseMaterials(json, textures) {
+    const materials = {};
+
+    if (json !== undefined) {
+      const nodes = this.parseNodes(this._nodesJSON, textures);
+      const loader = new NodeMaterialLoader();
+      loader.setTextures(textures);
+      loader.setNodes(nodes);
+
+      for (let i = 0, l = json.length; i < l; i++) {
+        const data = json[i];
+        materials[data.uuid] = loader.parse(data);
+      }
+    }
+
+    return materials;
+  }
+
+}
+
+// core
+const nodeLib = {
+  // core
+  ArrayUniformNode,
+  AttributeNode,
+  BypassNode,
+  CodeNode,
+  ContextNode,
+  ConstNode,
+  ExpressionNode,
+  FunctionCallNode,
+  FunctionNode,
+  Node,
+  NodeAttribute,
+  NodeBuilder,
+  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,
+  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]();
+};
+
+var Nodes = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  fromType: fromType,
+  ArrayUniformNode: ArrayUniformNode,
+  AttributeNode: AttributeNode,
+  BypassNode: BypassNode,
+  CodeNode: CodeNode,
+  ContextNode: ContextNode,
+  ConstNode: ConstNode,
+  ExpressionNode: ExpressionNode,
+  FunctionCallNode: FunctionCallNode,
+  FunctionNode: FunctionNode,
+  Node: Node,
+  NodeAttribute: NodeAttribute,
+  NodeBuilder: NodeBuilder,
+  NodeCode: NodeCode,
+  NodeFrame: NodeFrame,
+  NodeFunctionInput: NodeFunctionInput,
+  NodeKeywords: NodeKeywords,
+  NodeUniform: NodeUniform,
+  NodeVar: NodeVar,
+  NodeVary: NodeVary,
+  PropertyNode: PropertyNode,
+  TempNode: TempNode,
+  UniformNode: UniformNode,
+  VarNode: VarNode,
+  VaryNode: VaryNode,
+  BufferNode: BufferNode,
+  CameraNode: CameraNode,
+  CubeTextureNode: CubeTextureNode,
+  MaterialNode: MaterialNode,
+  MaterialReferenceNode: MaterialReferenceNode,
+  ModelNode: ModelNode,
+  ModelViewProjectionNode: ModelViewProjectionNode,
+  NormalNode: NormalNode,
+  Object3DNode: Object3DNode,
+  PointUVNode: PointUVNode,
+  PositionNode: PositionNode,
+  ReferenceNode: ReferenceNode,
+  ReflectNode: ReflectNode,
+  SkinningNode: SkinningNode,
+  TextureNode: TextureNode,
+  UVNode: UVNode,
+  ColorSpaceNode: ColorSpaceNode,
+  NormalMapNode: NormalMapNode,
+  MathNode: MathNode,
+  OperatorNode: OperatorNode,
+  CondNode: CondNode,
+  LightContextNode: LightContextNode,
+  LightNode: LightNode,
+  LightsNode: LightsNode,
+  ArrayElementNode: ArrayElementNode,
+  ConvertNode: ConvertNode,
+  JoinNode: JoinNode,
+  SplitNode: SplitNode,
+  SpriteSheetUVNode: SpriteSheetUVNode,
+  MatcapUVNode: MatcapUVNode,
+  OscNode: OscNode,
+  TimerNode: TimerNode,
+  CheckerNode: CheckerNode,
+  FogNode: FogNode,
+  FogRangeNode: FogRangeNode,
+  NodeLoader: NodeLoader,
+  NodeObjectLoader: NodeObjectLoader,
+  NodeMaterialLoader: NodeMaterialLoader,
+  NodeShaderStage: NodeShaderStage,
+  NodeUpdateType: NodeUpdateType,
+  NodeType: NodeType,
+  F_Schlick: F_Schlick,
+  BRDF_Lambert: BRDF_Lambert,
+  getDistanceAttenuation: getDistanceAttenuation,
+  V_GGX_SmithCorrelated: V_GGX_SmithCorrelated,
+  D_GGX: D_GGX,
+  BRDF_GGX: BRDF_GGX,
+  RE_Direct_Physical: RE_Direct_Physical,
+  PhysicalLightingModel: PhysicalLightingModel,
+  LineBasicNodeMaterial: LineBasicNodeMaterial,
+  MeshBasicNodeMaterial: MeshBasicNodeMaterial,
+  MeshStandardNodeMaterial: MeshStandardNodeMaterial,
+  PointsNodeMaterial: PointsNodeMaterial,
+  ShaderNode: ShaderNode,
+  nodeObject: nodeObject,
+  uniform: uniform,
+  label: label,
+  temp: temp,
+  color: color,
+  float: float,
+  int: int,
+  uint: uint,
+  bool: bool,
+  vec2: vec2,
+  ivec2: ivec2,
+  uvec2: uvec2,
+  bvec2: bvec2,
+  vec3: vec3,
+  ivec3: ivec3,
+  uvec3: uvec3,
+  bvec3: bvec3,
+  vec4: vec4,
+  ivec4: ivec4,
+  uvec4: uvec4,
+  bvec4: bvec4,
+  mat3: mat3,
+  imat3: imat3,
+  umat3: umat3,
+  bmat3: bmat3,
+  mat4: mat4,
+  imat4: imat4,
+  umat4: umat4,
+  bmat4: bmat4,
+  join: join,
+  uv: uv,
+  attribute: attribute,
+  buffer: buffer,
+  texture: texture,
+  sampler: sampler,
+  cond: cond,
+  addTo: addTo,
+  add: add,
+  sub: sub,
+  mul: mul,
+  div: div,
+  remainder: remainder,
+  equal: equal,
+  assign: assign,
+  lessThan: lessThan,
+  greaterThan: greaterThan,
+  lessThanEqual: lessThanEqual,
+  greaterThanEqual: greaterThanEqual,
+  and: and,
+  or: or,
+  xor: xor,
+  bitAnd: bitAnd,
+  bitOr: bitOr,
+  bitXor: bitXor,
+  shiftLeft: shiftLeft,
+  shiftRight: shiftRight,
+  element: element,
+  normalGeometry: normalGeometry,
+  normalLocal: normalLocal,
+  normalWorld: normalWorld,
+  normalView: normalView,
+  transformedNormalView: transformedNormalView,
+  positionLocal: positionLocal,
+  positionWorld: positionWorld,
+  positionView: positionView,
+  positionViewDirection: positionViewDirection,
+  viewMatrix: viewMatrix,
+  cameraPosition: cameraPosition,
+  diffuseColor: diffuseColor,
+  roughness: roughness,
+  metalness: metalness,
+  alphaTest: alphaTest,
+  specularColor: specularColor,
+  abs: abs,
+  acos: acos,
+  asin: asin,
+  atan: atan,
+  ceil: ceil,
+  clamp: clamp,
+  cos: cos,
+  cross: cross,
+  degrees: degrees,
+  dFdx: dFdx,
+  dFdy: dFdy,
+  distance: distance,
+  dot: dot,
+  exp: exp,
+  exp2: exp2,
+  faceforward: faceforward,
+  floor: floor,
+  fract: fract,
+  invert: invert,
+  inversesqrt: inversesqrt,
+  length: length,
+  log: log,
+  log2: log2,
+  max: max,
+  min: min,
+  mix: mix,
+  mod: mod,
+  negate: negate,
+  normalize: normalize,
+  pow: pow,
+  pow2: pow2,
+  pow3: pow3,
+  pow4: pow4,
+  radians: radians,
+  reflect: reflect,
+  refract: refract,
+  round: round,
+  saturate: saturate,
+  sign: sign,
+  sin: sin,
+  smoothstep: smoothstep,
+  sqrt: sqrt,
+  step: step,
+  tan: tan,
+  transformDirection: transformDirection,
+  EPSILON: EPSILON,
+  INFINITY: INFINITY
+});
+
+export { NodeLoader as N, NodeObjectLoader as a, Nodes as b, fromType as f };

package/Nodes-9aa16d74.js

@@ -0,0 +1 @@
+"use strict";var e=require("./nodes/core/ArrayUniformNode.cjs.js"),o=require("./nodes/core/AttributeNode.cjs.js"),r=require("./nodes/core/BypassNode.cjs.js"),s=require("./nodes/core/CodeNode.cjs.js"),d=require("./nodes/core/ConstNode.cjs.js"),t=require("./nodes/core/ContextNode.cjs.js"),i=require("./nodes/core/ExpressionNode.cjs.js"),a=require("./nodes/core/FunctionCallNode.cjs.js"),n=require("./nodes/core/FunctionNode.cjs.js"),c=require("./nodes/core/Node.cjs.js"),N=require("./nodes/core/NodeAttribute.cjs.js"),u=require("./nodes/core/NodeBuilder.cjs.js"),l=require("./nodes/core/NodeCode.cjs.js"),j=require("./nodes/core/NodeFrame.cjs.js"),m=require("./nodes/core/NodeFunctionInput.cjs.js"),p=require("./nodes/core/NodeKeywords.cjs.js"),h=require("./nodes/core/NodeUniform.cjs.js"),q=require("./nodes/core/NodeVar.cjs.js"),f=require("./nodes/core/NodeVary.cjs.js"),g=require("./nodes/core/PropertyNode.cjs.js"),b=require("./nodes/core/TempNode.cjs.js"),x=require("./nodes/core/UniformNode.cjs.js"),C=require("./nodes/core/VarNode.cjs.js"),v=require("./nodes/core/VaryNode.cjs.js"),M=require("./nodes/accessors/BufferNode.cjs.js"),y=require("./nodes/accessors/CameraNode.cjs.js"),V=require("./nodes/accessors/CubeTextureNode.cjs.js"),S=require("./nodes/accessors/MaterialNode.cjs.js"),L=require("./nodes/accessors/MaterialReferenceNode.cjs.js"),T=require("./nodes/accessors/ModelNode.cjs.js"),F=require("./nodes/accessors/ModelViewProjectionNode.cjs.js"),w=require("./nodes/accessors/NormalNode.cjs.js"),O=require("./nodes/accessors/Object3DNode.cjs.js"),_=require("./nodes/accessors/PointUVNode.cjs.js"),P=require("./nodes/accessors/PositionNode.cjs.js"),U=require("./nodes/accessors/ReferenceNode.cjs.js"),R=require("./nodes/accessors/ReflectNode.cjs.js"),B=require("./nodes/accessors/SkinningNode.cjs.js"),D=require("./nodes/accessors/TextureNode.cjs.js"),A=require("./nodes/accessors/UVNode.cjs.js"),E=require("./nodes/display/ColorSpaceNode.cjs.js"),G=require("./nodes/display/NormalMapNode.cjs.js"),I=require("./nodes/math/MathNode.cjs.js"),k=require("./nodes/math/OperatorNode.cjs.js"),J=require("./nodes/math/CondNode.cjs.js"),X=require("./nodes/lights/LightContextNode.cjs.js"),z=require("./nodes/lights/LightNode.cjs.js"),W=require("./nodes/lights/LightsNode.cjs.js"),K=require("./nodes/utils/ArrayElementNode.cjs.js"),H=require("./nodes/utils/ConvertNode.cjs.js"),Y=require("./nodes/utils/JoinNode.cjs.js"),Q=require("./nodes/utils/SplitNode.cjs.js"),Z=require("./nodes/utils/SpriteSheetUVNode.cjs.js"),$=require("./nodes/utils/MatcapUVNode.cjs.js"),ee=require("./nodes/utils/OscNode.cjs.js"),oe=require("./nodes/utils/TimerNode.cjs.js"),re=require("./nodes/loaders/NodeMaterialLoader.cjs.js"),se=require("three"),de=require("./nodes/procedural/CheckerNode.cjs.js"),te=require("./nodes/fog/FogNode.cjs.js"),ie=require("./nodes/fog/FogRangeNode.cjs.js"),ae=require("./nodes/core/constants.cjs.js"),ne=require("./nodes/functions/BSDFs.cjs.js"),ce=require("./nodes/ShaderNode.cjs.js"),Ne=require("./nodes/materials/LineBasicNodeMaterial.cjs.js"),ue=require("./nodes/materials/MeshBasicNodeMaterial.cjs.js"),le=require("./nodes/materials/MeshStandardNodeMaterial.cjs.js"),je=require("./nodes/materials/PointsNodeMaterial.cjs.js");class me extends se.Loader{constructor(e){super(e),this.textures={}}load(e,o,r,s){const d=new FileLoader(this.manager);d.setPath(this.path),d.setRequestHeader(this.requestHeader),d.setWithCredentials(this.withCredentials),d.load(e,(r=>{try{o(this.parse(JSON.parse(r)))}catch(o){s?s(o):console.error(o),this.manager.itemError(e)}}),r,s)}parseNodes(e){const o={};if(void 0!==e){for(const r of e){const{uuid:e,type:s}=r;o[e]=qe(s),o[e].uuid=e}const r={nodes:o,textures:this.textures};for(const s of e){s.meta=r;o[s.uuid].deserialize(s),delete s.meta}}return o}parse(e){const o=qe(type);o.uuid=e.uuid;const r={nodes:this.parseNodes(e.inputNodes),textures:this.textures};return e.meta=r,o.deserialize(e),delete e.meta,o}setTextures(e){return this.textures=e,this}}class pe extends se.ObjectLoader{constructor(e){super(e),this._nodesJSON=null}parse(e,o){this._nodesJSON=e.nodes;const r=super.parse(e,o);return this._nodesJSON=null,r}parseNodes(e,o){if(void 0!==e){const r=new me;return r.setTextures(o),r.parseNodes(e)}return{}}parseMaterials(e,o){const r={};if(void 0!==e){const s=this.parseNodes(this._nodesJSON,o),d=new re;d.setTextures(o),d.setNodes(s);for(let o=0,s=e.length;o<s;o++){const s=e[o];r[s.uuid]=d.parse(s)}}return r}}const he={ArrayUniformNode:e,AttributeNode:o,BypassNode:r,CodeNode:s,ContextNode:t,ConstNode:d,ExpressionNode:i,FunctionCallNode:a,FunctionNode:n,Node:c,NodeAttribute:N,NodeBuilder:u.default,NodeCode:l,NodeFrame:j,NodeFunctionInput:m,NodeKeywords:p,NodeUniform:h,NodeVar:q,NodeVary:f,PropertyNode:g,TempNode:b,UniformNode:x,VarNode:C,VaryNode:v,BufferNode:M,CameraNode:y,CubeTextureNode:V,MaterialNode:S,MaterialReferenceNode:L,ModelNode:T,ModelViewProjectionNode:F,NormalNode:w,Object3DNode:O,PointUVNode:_,PositionNode:P,ReferenceNode:U,ReflectNode:R,SkinningNode:B,TextureNode:D,UVNode:A,ColorSpaceNode:E.default,NormalMapNode:G,MathNode:I,OperatorNode:k,CondNode:J,LightContextNode:X,LightNode:z,LightsNode:W,ArrayElementNode:K,ConvertNode:H,JoinNode:Y,SplitNode:Q,SpriteSheetUVNode:Z,MatcapUVNode:$,OscNode:ee,TimerNode:oe,CheckerNode:de,FogNode:te,FogRangeNode:ie,NodeLoader:me,NodeObjectLoader:pe,NodeMaterialLoader:re},qe=e=>new he[e];var fe=Object.freeze({__proto__:null,fromType:qe,ArrayUniformNode:e,AttributeNode:o,BypassNode:r,CodeNode:s,ContextNode:t,ConstNode:d,ExpressionNode:i,FunctionCallNode:a,FunctionNode:n,Node:c,NodeAttribute:N,NodeBuilder:u.default,NodeCode:l,NodeFrame:j,NodeFunctionInput:m,NodeKeywords:p,NodeUniform:h,NodeVar:q,NodeVary:f,PropertyNode:g,TempNode:b,UniformNode:x,VarNode:C,VaryNode:v,BufferNode:M,CameraNode:y,CubeTextureNode:V,MaterialNode:S,MaterialReferenceNode:L,ModelNode:T,ModelViewProjectionNode:F,NormalNode:w,Object3DNode:O,PointUVNode:_,PositionNode:P,ReferenceNode:U,ReflectNode:R,SkinningNode:B,TextureNode:D,UVNode:A,ColorSpaceNode:E.default,NormalMapNode:G,MathNode:I,OperatorNode:k,CondNode:J,LightContextNode:X,LightNode:z,LightsNode:W,ArrayElementNode:K,ConvertNode:H,JoinNode:Y,SplitNode:Q,SpriteSheetUVNode:Z,MatcapUVNode:$,OscNode:ee,TimerNode:oe,CheckerNode:de,FogNode:te,FogRangeNode:ie,NodeLoader:me,NodeObjectLoader:pe,NodeMaterialLoader:re,NodeShaderStage:ae.NodeShaderStage,NodeUpdateType:ae.NodeUpdateType,NodeType:ae.NodeType,F_Schlick:ne.F_Schlick,BRDF_Lambert:ne.BRDF_Lambert,getDistanceAttenuation:ne.getDistanceAttenuation,V_GGX_SmithCorrelated:ne.V_GGX_SmithCorrelated,D_GGX:ne.D_GGX,BRDF_GGX:ne.BRDF_GGX,RE_Direct_Physical:ne.RE_Direct_Physical,PhysicalLightingModel:ne.PhysicalLightingModel,LineBasicNodeMaterial:Ne,MeshBasicNodeMaterial:ue,MeshStandardNodeMaterial:le,PointsNodeMaterial:je,ShaderNode:ce.ShaderNode,nodeObject:ce.nodeObject,uniform:ce.uniform,label:ce.label,temp:ce.temp,color:ce.color,float:ce.float,int:ce.int,uint:ce.uint,bool:ce.bool,vec2:ce.vec2,ivec2:ce.ivec2,uvec2:ce.uvec2,bvec2:ce.bvec2,vec3:ce.vec3,ivec3:ce.ivec3,uvec3:ce.uvec3,bvec3:ce.bvec3,vec4:ce.vec4,ivec4:ce.ivec4,uvec4:ce.uvec4,bvec4:ce.bvec4,mat3:ce.mat3,imat3:ce.imat3,umat3:ce.umat3,bmat3:ce.bmat3,mat4:ce.mat4,imat4:ce.imat4,umat4:ce.umat4,bmat4:ce.bmat4,join:ce.join,uv:ce.uv,attribute:ce.attribute,buffer:ce.buffer,texture:ce.texture,sampler:ce.sampler,cond:ce.cond,addTo:ce.addTo,add:ce.add,sub:ce.sub,mul:ce.mul,div:ce.div,remainder:ce.remainder,equal:ce.equal,assign:ce.assign,lessThan:ce.lessThan,greaterThan:ce.greaterThan,lessThanEqual:ce.lessThanEqual,greaterThanEqual:ce.greaterThanEqual,and:ce.and,or:ce.or,xor:ce.xor,bitAnd:ce.bitAnd,bitOr:ce.bitOr,bitXor:ce.bitXor,shiftLeft:ce.shiftLeft,shiftRight:ce.shiftRight,element:ce.element,normalGeometry:ce.normalGeometry,normalLocal:ce.normalLocal,normalWorld:ce.normalWorld,normalView:ce.normalView,transformedNormalView:ce.transformedNormalView,positionLocal:ce.positionLocal,positionWorld:ce.positionWorld,positionView:ce.positionView,positionViewDirection:ce.positionViewDirection,viewMatrix:ce.viewMatrix,cameraPosition:ce.cameraPosition,diffuseColor:ce.diffuseColor,roughness:ce.roughness,metalness:ce.metalness,alphaTest:ce.alphaTest,specularColor:ce.specularColor,abs:ce.abs,acos:ce.acos,asin:ce.asin,atan:ce.atan,ceil:ce.ceil,clamp:ce.clamp,cos:ce.cos,cross:ce.cross,degrees:ce.degrees,dFdx:ce.dFdx,dFdy:ce.dFdy,distance:ce.distance,dot:ce.dot,exp:ce.exp,exp2:ce.exp2,faceforward:ce.faceforward,floor:ce.floor,fract:ce.fract,invert:ce.invert,inversesqrt:ce.inversesqrt,length:ce.length,log:ce.log,log2:ce.log2,max:ce.max,min:ce.min,mix:ce.mix,mod:ce.mod,negate:ce.negate,normalize:ce.normalize,pow:ce.pow,pow2:ce.pow2,pow3:ce.pow3,pow4:ce.pow4,radians:ce.radians,reflect:ce.reflect,refract:ce.refract,round:ce.round,saturate:ce.saturate,sign:ce.sign,sin:ce.sin,smoothstep:ce.smoothstep,sqrt:ce.sqrt,step:ce.step,tan:ce.tan,transformDirection:ce.transformDirection,EPSILON:ce.EPSILON,INFINITY:ce.INFINITY});exports.NodeLoader=me,exports.NodeObjectLoader=pe,exports.Nodes=fe,exports.fromType=qe;

package/animation/AnimationClipCreator.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");const n=()=>{};n.CreateRotationAnimation=(n,t)=>{const r=[0,n],o=`.rotation[${t=t||"x"}]`,a=new e.NumberKeyframeTrack(o,r,[0,360]);return new e.AnimationClip(null,n,[a])},n.CreateScaleAxisAnimation=(n,t)=>{const r=[0,n],o=`.scale[${t=t||"x"}]`,a=new e.NumberKeyframeTrack(o,r,[0,1]);return new e.AnimationClip(null,n,[a])},n.CreateShakeAnimation=(n,t)=>{const r=[],o=[],a=new e.Vector3;for(let e=0;e<10*n;e++)r.push(e/10),a.set(2*Math.random()-1,2*Math.random()-1,2*Math.random()-1).multiply(t).toArray(o,o.length);const i=new e.VectorKeyframeTrack(".position",r,o);return new e.AnimationClip(null,n,[i])},n.CreatePulsationAnimation=(n,t)=>{const r=[],o=[],a=new e.Vector3;for(let e=0;e<10*n;e++){r.push(e/10);const n=Math.random()*t;a.set(n,n,n).toArray(o,o.length)}const i=new e.VectorKeyframeTrack(".scale",r,o);return new e.AnimationClip(null,n,[i])},n.CreateVisibilityAnimation=n=>{const t=[0,n/2,n],r=new e.BooleanKeyframeTrack(".visible",t,[!0,!1,!0]);return new e.AnimationClip(null,n,[r])},n.CreateMaterialColorAnimation=(n,t)=>{const r=[],o=[],a=n/t.length;for(let e=0;e<=t.length;e++)r.push(e*a),o.push(t[e%t.length]);const i=new e.ColorKeyframeTrack(".material[0].color",r,o);return new e.AnimationClip(null,n,[i])},exports.AnimationClipCreator=n;

package/animation/AnimationClipCreator.js

@@ -1,57 +1,77 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const AnimationClipCreator = () => {
-};
+import { NumberKeyframeTrack, AnimationClip, Vector3, VectorKeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack } from 'three';
+
+const AnimationClipCreator = () => {};
+
 AnimationClipCreator.CreateRotationAnimation = (period, axis) => {
-  const times = [0, period], values = [0, 360];
-  axis = axis || "x";
+  const times = [0, period],
+        values = [0, 360];
+  axis = axis || 'x';
   const trackName = `.rotation[${axis}]`;
-  const track = new THREE.NumberKeyframeTrack(trackName, times, values);
-  return new THREE.AnimationClip(null, period, [track]);
+  const track = new NumberKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, period, [track]);
 };
+
 AnimationClipCreator.CreateScaleAxisAnimation = (period, axis) => {
-  const times = [0, period], values = [0, 1];
-  axis = axis || "x";
+  const times = [0, period],
+        values = [0, 1];
+  axis = axis || 'x';
   const trackName = `.scale[${axis}]`;
-  const track = new THREE.NumberKeyframeTrack(trackName, times, values);
-  return new THREE.AnimationClip(null, period, [track]);
+  const track = new NumberKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, period, [track]);
 };
+
 AnimationClipCreator.CreateShakeAnimation = (duration, shakeScale) => {
-  const times = [], values = [], tmp = new THREE.Vector3();
+  const times = [],
+        values = [],
+        tmp = new Vector3();
+
   for (let i = 0; i < duration * 10; i++) {
     times.push(i / 10);
-    tmp.set(Math.random() * 2 - 1, Math.random() * 2 - 1, Math.random() * 2 - 1).multiply(shakeScale).toArray(values, values.length);
+    tmp.set(Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0).multiply(shakeScale).toArray(values, values.length);
   }
-  const trackName = ".position";
-  const track = new THREE.VectorKeyframeTrack(trackName, times, values);
-  return new THREE.AnimationClip(null, duration, [track]);
+
+  const trackName = '.position';
+  const track = new VectorKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, duration, [track]);
 };
+
 AnimationClipCreator.CreatePulsationAnimation = (duration, pulseScale) => {
-  const times = [], values = [], tmp = new THREE.Vector3();
+  const times = [],
+        values = [],
+        tmp = new Vector3();
+
   for (let i = 0; i < duration * 10; i++) {
     times.push(i / 10);
     const scaleFactor = Math.random() * pulseScale;
     tmp.set(scaleFactor, scaleFactor, scaleFactor).toArray(values, values.length);
   }
-  const trackName = ".scale";
-  const track = new THREE.VectorKeyframeTrack(trackName, times, values);
-  return new THREE.AnimationClip(null, duration, [track]);
+
+  const trackName = '.scale';
+  const track = new VectorKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, duration, [track]);
 };
-AnimationClipCreator.CreateVisibilityAnimation = (duration) => {
-  const times = [0, duration / 2, duration], values = [true, false, true];
-  const trackName = ".visible";
-  const track = new THREE.BooleanKeyframeTrack(trackName, times, values);
-  return new THREE.AnimationClip(null, duration, [track]);
+
+AnimationClipCreator.CreateVisibilityAnimation = duration => {
+  const times = [0, duration / 2, duration],
+        values = [true, false, true];
+  const trackName = '.visible';
+  const track = new BooleanKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, duration, [track]);
 };
+
 AnimationClipCreator.CreateMaterialColorAnimation = (duration, colors) => {
-  const times = [], values = [], timeStep = duration / colors.length;
+  const times = [],
+        values = [],
+        timeStep = duration / colors.length;
+
   for (let i = 0; i <= colors.length; i++) {
     times.push(i * timeStep);
     values.push(colors[i % colors.length]);
   }
-  const trackName = ".material[0].color";
-  const track = new THREE.ColorKeyframeTrack(trackName, times, values);
-  return new THREE.AnimationClip(null, duration, [track]);
+
+  const trackName = '.material[0].color';
+  const track = new ColorKeyframeTrack(trackName, times, values);
+  return new AnimationClip(null, duration, [track]);
 };
-exports.AnimationClipCreator = AnimationClipCreator;
+
+export { AnimationClipCreator };

package/animation/CCDIKSolver.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("@babel/runtime/helpers/defineProperty"),e=require("three");function i(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}var o=i(t);class r extends e.Object3D{constructor(t,i=[]){function r(t){return new e.Line(function(t){const i=new e.BufferGeometry,o=new Float32Array(3*(2+t.links.length));return i.setAttribute("position",new e.BufferAttribute(o,3)),i}(t),scope.lineMaterial)}super(),o.default(this,"_m",new e.Matrix4),o.default(this,"_v",new e.Vector3),this.root=t,this.iks=i,this.matrix.copy(t.matrixWorld),this.matrixAutoUpdate=!1,this.sphereGeometry=new e.SphereGeometry(.25,16,8),this.targetSphereMaterial=new e.MeshBasicMaterial({color:new e.Color(16746632),depthTest:!1,depthWrite:!1,transparent:!0}),this.effectorSphereMaterial=new e.MeshBasicMaterial({color:new e.Color(8978312),depthTest:!1,depthWrite:!1,transparent:!0}),this.linkSphereMaterial=new e.MeshBasicMaterial({color:new e.Color(8947967),depthTest:!1,depthWrite:!1,transparent:!0}),this.lineMaterial=new e.LineBasicMaterial({color:new e.Color(16711680),depthTest:!1,depthWrite:!1,transparent:!0});for(let t=0,o=i.length;t<o;t++){const o=i[t];this.add(new e.Mesh(scope.sphereGeometry,scope.targetSphereMaterial)),this.add(new e.Mesh(scope.sphereGeometry,scope.effectorSphereMaterial));for(let t=0,i=o.links.length;t<i;t++)this.add(new e.Mesh(scope.sphereGeometry,scope.linkSphereMaterial));this.add(r(o))}}_getPosition(t,e){return this._v.setFromMatrixPosition(t.matrixWorld).applyMatrix4(e)}_setPositionOfBoneToAttributeArray(t,e,i,o){const r=this._getPosition(i,o);t[3*e+0]=r.x,t[3*e+1]=r.y,t[3*e+2]=r.z}updateMatrixWorld(t){const e=this.root;if(this.visible){let t=0;const i=this.iks,o=e.skeleton.bones;this._m.copy(e.matrixWorld).invert();for(let e=0,r=i.length;e<r;e++){const r=i[e],s=o[r.target],n=o[r.effector],a=this.children[t++],h=this.children[t++];a.position.copy(this._getPosition(s,this._m)),h.position.copy(this._getPosition(n,this._m));for(let e=0,i=r.links.length;e<i;e++){const i=o[r.links[e].index];this.children[t++].position.copy(this._getPosition(i,this._m))}const l=this.children[t++],c=l.geometry.attributes.position.array;this._setPositionOfBoneToAttributeArray(c,0,s,this._m),this._setPositionOfBoneToAttributeArray(c,1,n,this._m);for(let t=0,e=r.links.length;t<e;t++){const e=o[r.links[t].index];this._setPositionOfBoneToAttributeArray(c,t+2,e,this._m)}l.geometry.attributes.position.needsUpdate=!0}}this.matrix.copy(e.matrixWorld),super.updateMatrixWorld(t)}}exports.CCDIKHelper=r,exports.CCDIKSolver=class{constructor(t,i){o.default(this,"q",new e.Quaternion),o.default(this,"targetPos",new e.Vector3),o.default(this,"targetVec",new e.Vector3),o.default(this,"effectorPos",new e.Vector3),o.default(this,"effectorVec",new e.Vector3),o.default(this,"linkPos",new e.Vector3),o.default(this,"invLinkQ",new e.Quaternion),o.default(this,"linkScale",new e.Vector3),o.default(this,"axis",new e.Vector3),o.default(this,"vector",new e.Vector3),this.mesh=t,this.iks=i;const r=this.mesh.skeleton.bones;for(let t=0,e=this.iks.length;t<e;t++){const e=this.iks[t],i=r[e.effector],o=e.links;let s,n;s=i;for(let t=0,e=o.length;t<e;t++)n=r[o[t].index],s.parent!==n&&console.warn(`THREE.CCDIKSolver: bone ${s.name} is not the child of bone ${n.name}`),s=n}}update(){const t=this.mesh.skeleton.bones,e=this.iks,i=Math;for(let o=0,r=e.length;o<r;o++){const r=e[o],s=t[r.effector],n=t[r.target];this.targetPos.setFromMatrixPosition(n.matrixWorld);const a=r.links,h=void 0!==r.iteration?r.iteration:1;for(let e=0;e<h;e++){let e=!1;for(let o=0,n=a.length;o<n;o++){const n=t[a[o].index];if(!1===a[o].enabled)break;const h=a[o].limitation,l=a[o].rotationMin,c=a[o].rotationMax;n.matrixWorld.decompose(this.linkPos,this.invLinkQ,this.linkScale),this.invLinkQ.invert(),this.effectorPos.setFromMatrixPosition(s.matrixWorld),this.effectorVec.subVectors(this.effectorPos,this.linkPos),this.effectorVec.applyQuaternion(this.invLinkQ),this.effectorVec.normalize(),this.targetVec.subVectors(this.targetPos,this.linkPos),this.targetVec.applyQuaternion(this.invLinkQ),this.targetVec.normalize();let f=this.targetVec.dot(this.effectorVec);if(f>1?f=1:f<-1&&(f=-1),f=i.acos(f),!(f<1e-5)){if(void 0!==r.minAngle&&f<r.minAngle&&(f=r.minAngle),void 0!==r.maxAngle&&f>r.maxAngle&&(f=r.maxAngle),this.axis.crossVectors(this.effectorVec,this.targetVec),this.axis.normalize(),this.q.setFromAxisAngle(this.axis,f),n.quaternion.multiply(this.q),void 0!==h){let t=n.quaternion.w;t>1&&(t=1);const e=i.sqrt(1-t*t);n.quaternion.set(h.x*e,h.y*e,h.z*e,t)}void 0!==l&&n.rotation.setFromVector3(n.rotation.toVector3(this.vector).max(l)),void 0!==c&&n.rotation.setFromVector3(n.rotation.toVector3(this.vector).min(c)),n.updateMatrixWorld(!0),e=!0}}if(!e)break}}return this}createHelper(){return new r(this.mesh,this.mesh.geometry.userData.MMD.iks)}};