three-stdlib 2.15.2 → 2.16.1

package/nodes/utils/JoinNode.mjs

@@ -1,26 +0,0 @@
-import Node from "../core/Node.mjs";
-class JoinNode extends Node {
-  constructor(nodes = []) {
-    super();
-    this.nodes = nodes;
-  }
-  getNodeType(builder) {
-    return builder.getTypeFromLength(
-      this.nodes.reduce((count, cur) => count + builder.getTypeLength(cur.getNodeType(builder)), 0)
-    );
-  }
-  generate(builder) {
-    const type = this.getNodeType(builder);
-    const nodes = this.nodes;
-    const snippetValues = [];
-    for (let i = 0; i < nodes.length; i++) {
-      const input = nodes[i];
-      const inputSnippet = input.build(builder);
-      snippetValues.push(inputSnippet);
-    }
-    return `${builder.getType(type)}( ${snippetValues.join(", ")} )`;
-  }
-}
-export {
-  JoinNode as default
-};

package/nodes/utils/MatcapUVNode.mjs

@@ -1,16 +0,0 @@
-import TempNode from "../core/TempNode.mjs";
-import { normalize, join, positionViewDirection, negate, cross, add, mul, dot, transformedNormalView } from "../ShaderNode.mjs";
-class MatcapUVNode extends TempNode {
-  constructor() {
-    super("vec2");
-  }
-  generate(builder) {
-    const x = normalize(join(positionViewDirection.z, 0, negate(positionViewDirection.x)));
-    const y = cross(positionViewDirection, x);
-    const uv = add(mul(join(dot(x, transformedNormalView), dot(y, transformedNormalView)), 0.495), 0.5);
-    return uv.build(builder, this.getNodeType(builder));
-  }
-}
-export {
-  MatcapUVNode as default
-};

package/nodes/utils/OscNode.mjs

@@ -1,50 +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 TimerNode from "./TimerNode.mjs";
-import { add, mul, sin, round, fract, abs, sub } from "../ShaderNode.mjs";
-const _OscNode = class extends Node {
-  constructor(method = _OscNode.SINE, timeNode = new TimerNode()) {
-    super();
-    this.method = method;
-    this.timeNode = timeNode;
-  }
-  getNodeType(builder) {
-    return this.timeNode.getNodeType(builder);
-  }
-  generate(builder) {
-    const method = this.method;
-    const timeNode = this.timeNode;
-    let outputNode = null;
-    if (method === _OscNode.SINE) {
-      outputNode = add(mul(sin(mul(add(timeNode, 0.75), Math.PI * 2)), 0.5), 0.5);
-    } else if (method === _OscNode.SQUARE) {
-      outputNode = round(fract(timeNode));
-    } else if (method === _OscNode.TRIANGLE) {
-      outputNode = abs(sub(1, mul(fract(add(timeNode, 0.5)), 2)));
-    } else if (method === _OscNode.SAWTOOTH) {
-      outputNode = fract(timeNode);
-    }
-    return outputNode.build(builder);
-  }
-  serialize(data) {
-    super.serialize(data);
-    data.method = this.method;
-  }
-  deserialize(data) {
-    super.deserialize(data);
-    this.method = data.method;
-  }
-};
-let OscNode = _OscNode;
-__publicField(OscNode, "SINE", "sine");
-__publicField(OscNode, "SQUARE", "square");
-__publicField(OscNode, "TRIANGLE", "triangle");
-__publicField(OscNode, "SAWTOOTH", "sawtooth");
-export {
-  OscNode as default
-};

package/nodes/utils/SplitNode.mjs

@@ -1,45 +0,0 @@
-import Node from "../core/Node.mjs";
-import { vector } from "../core/NodeBuilder.mjs";
-class SplitNode extends Node {
-  constructor(node, components = "x") {
-    super();
-    this.node = node;
-    this.components = components;
-  }
-  getVectorLength() {
-    let vectorLength = this.components.length;
-    for (const c of this.components) {
-      vectorLength = Math.max(vector.indexOf(c) + 1, vectorLength);
-    }
-    return vectorLength;
-  }
-  getNodeType(builder) {
-    return builder.getTypeFromLength(this.components.length);
-  }
-  generate(builder) {
-    const node = this.node;
-    const nodeTypeLength = builder.getTypeLength(node.getNodeType(builder));
-    if (nodeTypeLength > 1) {
-      let type = null;
-      const componentsLength = this.getVectorLength();
-      if (componentsLength >= nodeTypeLength) {
-        type = builder.getTypeFromLength(this.getVectorLength());
-      }
-      const nodeSnippet = node.build(builder, type);
-      return `${nodeSnippet}.${this.components}`;
-    } else {
-      return node.build(builder);
-    }
-  }
-  serialize(data) {
-    super.serialize(data);
-    data.components = this.components;
-  }
-  deserialize(data) {
-    super.deserialize(data);
-    this.components = data.components;
-  }
-}
-export {
-  SplitNode as default
-};

package/nodes/utils/SpriteSheetUVNode.mjs

@@ -1,40 +0,0 @@
-import Node from "../core/Node.mjs";
-import ConstNode from "../core/ConstNode.mjs";
-import UVNode from "../accessors/UVNode.mjs";
-import MathNode from "../math/MathNode.mjs";
-import OperatorNode from "../math/OperatorNode.mjs";
-import SplitNode from "./SplitNode.mjs";
-import JoinNode from "./JoinNode.mjs";
-class SpriteSheetUVNode extends Node {
-  constructor(countNode, uvNode = new UVNode(), frameNode = new ConstNode(0)) {
-    super("vec2");
-    this.countNode = countNode;
-    this.uvNode = uvNode;
-    this.frameNode = frameNode;
-  }
-  generate(builder) {
-    const count = this.countNode;
-    const uv = this.uvNode;
-    const frame = this.frameNode;
-    const one = new ConstNode(1);
-    const width = new SplitNode(count, "x");
-    const height = new SplitNode(count, "y");
-    const total = new OperatorNode("*", width, height);
-    const roundFrame = new MathNode(MathNode.FLOOR, new MathNode(MathNode.MOD, frame, total));
-    const frameNum = new OperatorNode("+", roundFrame, one);
-    const cell = new MathNode(MathNode.MOD, roundFrame, width);
-    const row = new MathNode(MathNode.CEIL, new OperatorNode("/", frameNum, width));
-    const rowInv = new OperatorNode("-", height, row);
-    const scale = new OperatorNode("/", one, count);
-    const uvFrameOffset = new JoinNode([
-      new OperatorNode("*", cell, new SplitNode(scale, "x")),
-      new OperatorNode("*", rowInv, new SplitNode(scale, "y"))
-    ]);
-    const uvScale = new OperatorNode("*", uv, scale);
-    const uvFrame = new OperatorNode("+", uvScale, uvFrameOffset);
-    return uvFrame.build(builder, this.getNodeType(builder));
-  }
-}
-export {
-  SpriteSheetUVNode as default
-};

package/nodes/utils/TimerNode.mjs

@@ -1,44 +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 UniformNode from "../core/UniformNode.mjs";
-import { NodeUpdateType } from "../core/constants.mjs";
-const _TimerNode = class extends UniformNode {
-  constructor(scope = _TimerNode.LOCAL) {
-    super(0);
-    this.scope = scope;
-    this.scale = 1;
-    this.updateType = NodeUpdateType.Frame;
-  }
-  update(frame) {
-    const scope = this.scope;
-    const scale = this.scale;
-    if (scope === _TimerNode.LOCAL) {
-      this.value += frame.deltaTime * scale;
-    } else if (scope === _TimerNode.DELTA) {
-      this.value = frame.deltaTime * scale;
-    } else {
-      this.value = frame.time * scale;
-    }
-  }
-  serialize(data) {
-    super.serialize(data);
-    data.scope = this.scope;
-    data.scale = this.scale;
-  }
-  deserialize(data) {
-    super.deserialize(data);
-    this.scope = data.scope;
-    this.scale = data.scale;
-  }
-};
-let TimerNode = _TimerNode;
-__publicField(TimerNode, "LOCAL", "local");
-__publicField(TimerNode, "GLOBAL", "global");
-__publicField(TimerNode, "DELTA", "delta");
-export {
-  TimerNode as default
-};

package/objects/GroundProjectedEnv.mjs

@@ -1,130 +0,0 @@
-import { Mesh, IcosahedronGeometry, ShaderMaterial, DoubleSide } from "three";
-const isCubeTexture = (def) => def && def.isCubeTexture;
-class GroundProjectedEnv extends Mesh {
-  constructor(texture, options) {
-    var _a, _b;
-    const isCubeMap = isCubeTexture(texture);
-    const w = (_b = isCubeMap ? (_a = texture.image[0]) == null ? void 0 : _a.width : texture.image.width) != null ? _b : 1024;
-    const cubeSize = w / 4;
-    const _lodMax = Math.floor(Math.log2(cubeSize));
-    const _cubeSize = Math.pow(2, _lodMax);
-    const width = 3 * Math.max(_cubeSize, 16 * 7);
-    const height = 4 * _cubeSize;
-    const defines = [
-      isCubeMap ? "#define ENVMAP_TYPE_CUBE" : "",
-      `#define CUBEUV_TEXEL_WIDTH ${1 / width}`,
-      `#define CUBEUV_TEXEL_HEIGHT ${1 / height}`,
-      `#define CUBEUV_MAX_MIP ${_lodMax}.0`
-    ];
-    const vertexShader = `
-        varying vec3 vWorldPosition;
-        void main() 
-        {
-            vec4 worldPosition = ( modelMatrix * vec4( position, 1.0 ) );
-            vWorldPosition = worldPosition.xyz;
-            
-            gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-        }
-        `;
-    const fragmentShader = defines.join("\n") + `
-        #define ENVMAP_TYPE_CUBE_UV
-        varying vec3 vWorldPosition;
-        uniform float radius;
-        uniform float height;
-        uniform float angle;
-        #ifdef ENVMAP_TYPE_CUBE
-            uniform samplerCube map;
-        #else
-            uniform sampler2D map;
-        #endif
-        // From: https://www.shadertoy.com/view/4tsBD7
-        float diskIntersectWithBackFaceCulling( vec3 ro, vec3 rd, vec3 c, vec3 n, float r ) 
-        {
-            float d = dot ( rd, n );
-            
-            if( d > 0.0 ) { return 1e6; }
-            
-            vec3  o = ro - c;
-            float t = - dot( n, o ) / d;
-            vec3  q = o + rd * t;
-            
-            return ( dot( q, q ) < r * r ) ? t : 1e6;
-        }
-        // From: https://www.iquilezles.org/www/articles/intersectors/intersectors.htm
-        float sphereIntersect( vec3 ro, vec3 rd, vec3 ce, float ra ) 
-        {
-            vec3 oc = ro - ce;
-            float b = dot( oc, rd );
-            float c = dot( oc, oc ) - ra * ra;
-            float h = b * b - c;
-            
-            if( h < 0.0 ) { return -1.0; }
-            
-            h = sqrt( h );
-            
-            return - b + h;
-        }
-        vec3 project() 
-        {
-            vec3 p = normalize( vWorldPosition );
-            vec3 camPos = cameraPosition;
-            camPos.y -= height;
-            float intersection = sphereIntersect( camPos, p, vec3( 0.0 ), radius );
-            if( intersection > 0.0 ) {
-                
-                vec3 h = vec3( 0.0, - height, 0.0 );
-                float intersection2 = diskIntersectWithBackFaceCulling( camPos, p, h, vec3( 0.0, 1.0, 0.0 ), radius );
-                p = ( camPos + min( intersection, intersection2 ) * p ) / radius;
-            } else {
-                p = vec3( 0.0, 1.0, 0.0 );
-            }
-            return p;
-        }
-        #include <common>
-        #include <cube_uv_reflection_fragment>
-        void main() 
-        {
-            vec3 projectedWorldPosition = project();
-            
-            #ifdef ENVMAP_TYPE_CUBE
-                vec3 outcolor = textureCube( map, projectedWorldPosition ).rgb;
-            #else
-                vec3 direction = normalize( projectedWorldPosition );
-                vec2 uv = equirectUv( direction );
-                vec3 outcolor = texture2D( map, uv ).rgb;
-            #endif
-            gl_FragColor = vec4( outcolor, 1.0 );
-            #include <tonemapping_fragment>
-            #include <encodings_fragment>
-        }
-        `;
-    const uniforms = {
-      map: { value: texture },
-      height: { value: (options == null ? void 0 : options.height) || 15 },
-      radius: { value: (options == null ? void 0 : options.radius) || 100 }
-    };
-    const geometry = new IcosahedronGeometry(1, 16);
-    const material = new ShaderMaterial({
-      uniforms,
-      fragmentShader,
-      vertexShader,
-      side: DoubleSide
-    });
-    super(geometry, material);
-  }
-  set radius(radius) {
-    this.material.uniforms.radius.value = radius;
-  }
-  get radius() {
-    return this.material.uniforms.radius.value;
-  }
-  set height(height) {
-    this.material.uniforms.height.value = height;
-  }
-  get height() {
-    return this.material.uniforms.height.value;
-  }
-}
-export {
-  GroundProjectedEnv
-};

package/objects/Lensflare.mjs

@@ -1,262 +0,0 @@
-import { Mesh, MeshBasicMaterial, Vector3, DataTexture, RGBAFormat, NearestFilter, ClampToEdgeWrapping, RawShaderMaterial, Color, Vector2, AdditiveBlending, Box2, Vector4, BufferGeometry, InterleavedBuffer, InterleavedBufferAttribute } from "three";
-class Lensflare extends Mesh {
-  constructor() {
-    super(Lensflare.Geometry, new MeshBasicMaterial({ opacity: 0, transparent: true }));
-    this.type = "Lensflare";
-    this.frustumCulled = false;
-    this.renderOrder = Infinity;
-    const positionScreen = new Vector3();
-    const positionView = new Vector3();
-    const tempMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat);
-    tempMap.minFilter = NearestFilter;
-    tempMap.magFilter = NearestFilter;
-    tempMap.wrapS = ClampToEdgeWrapping;
-    tempMap.wrapT = ClampToEdgeWrapping;
-    const occlusionMap = new DataTexture(new Uint8Array(16 * 16 * 3), 16, 16, RGBAFormat);
-    occlusionMap.minFilter = NearestFilter;
-    occlusionMap.magFilter = NearestFilter;
-    occlusionMap.wrapS = ClampToEdgeWrapping;
-    occlusionMap.wrapT = ClampToEdgeWrapping;
-    const geometry = Lensflare.Geometry;
-    const material1a = new RawShaderMaterial({
-      uniforms: {
-        scale: { value: null },
-        screenPosition: { value: null }
-      },
-      vertexShader: `
-
-				precision highp float;
-
-				uniform vec3 screenPosition;
-				uniform vec2 scale;
-
-				attribute vec3 position;
-
-				void main() {
-
-					gl_Position = vec4( position.xy * scale + screenPosition.xy, screenPosition.z, 1.0 );
-
-				}`,
-      fragmentShader: `
-
-				precision highp float;
-
-				void main() {
-
-					gl_FragColor = vec4( 1.0, 0.0, 1.0, 1.0 );
-
-				}`,
-      depthTest: true,
-      depthWrite: false,
-      transparent: false
-    });
-    const material1b = new RawShaderMaterial({
-      uniforms: {
-        map: { value: tempMap },
-        scale: { value: null },
-        screenPosition: { value: null }
-      },
-      vertexShader: `
-
-				precision highp float;
-
-				uniform vec3 screenPosition;
-				uniform vec2 scale;
-
-				attribute vec3 position;
-				attribute vec2 uv;
-
-				varying vec2 vUV;
-
-				void main() {
-
-					vUV = uv;
-
-					gl_Position = vec4( position.xy * scale + screenPosition.xy, screenPosition.z, 1.0 );
-
-				}`,
-      fragmentShader: `
-
-				precision highp float;
-
-				uniform sampler2D map;
-
-				varying vec2 vUV;
-
-				void main() {
-
-					gl_FragColor = texture2D( map, vUV );
-
-				}`,
-      depthTest: false,
-      depthWrite: false,
-      transparent: false
-    });
-    const mesh1 = new Mesh(geometry, material1a);
-    const elements = [];
-    const shader = LensflareElement.Shader;
-    const material2 = new RawShaderMaterial({
-      uniforms: {
-        map: { value: null },
-        occlusionMap: { value: occlusionMap },
-        color: { value: new Color(16777215) },
-        scale: { value: new Vector2() },
-        screenPosition: { value: new Vector3() }
-      },
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      blending: AdditiveBlending,
-      transparent: true,
-      depthWrite: false
-    });
-    const mesh2 = new Mesh(geometry, material2);
-    this.addElement = function(element) {
-      elements.push(element);
-    };
-    const scale = new Vector2();
-    const screenPositionPixels = new Vector2();
-    const validArea = new Box2();
-    const viewport = new Vector4();
-    this.onBeforeRender = function(renderer, scene, camera) {
-      renderer.getCurrentViewport(viewport);
-      const invAspect = viewport.w / viewport.z;
-      const halfViewportWidth = viewport.z / 2;
-      const halfViewportHeight = viewport.w / 2;
-      let size = 16 / viewport.w;
-      scale.set(size * invAspect, size);
-      validArea.min.set(viewport.x, viewport.y);
-      validArea.max.set(viewport.x + (viewport.z - 16), viewport.y + (viewport.w - 16));
-      positionView.setFromMatrixPosition(this.matrixWorld);
-      positionView.applyMatrix4(camera.matrixWorldInverse);
-      if (positionView.z > 0)
-        return;
-      positionScreen.copy(positionView).applyMatrix4(camera.projectionMatrix);
-      screenPositionPixels.x = viewport.x + positionScreen.x * halfViewportWidth + halfViewportWidth - 8;
-      screenPositionPixels.y = viewport.y + positionScreen.y * halfViewportHeight + halfViewportHeight - 8;
-      if (validArea.containsPoint(screenPositionPixels)) {
-        renderer.copyFramebufferToTexture(screenPositionPixels, tempMap);
-        let uniforms = material1a.uniforms;
-        uniforms["scale"].value = scale;
-        uniforms["screenPosition"].value = positionScreen;
-        renderer.renderBufferDirect(camera, null, geometry, material1a, mesh1, null);
-        renderer.copyFramebufferToTexture(screenPositionPixels, occlusionMap);
-        uniforms = material1b.uniforms;
-        uniforms["scale"].value = scale;
-        uniforms["screenPosition"].value = positionScreen;
-        renderer.renderBufferDirect(camera, null, geometry, material1b, mesh1, null);
-        const vecX = -positionScreen.x * 2;
-        const vecY = -positionScreen.y * 2;
-        for (let i = 0, l = elements.length; i < l; i++) {
-          const element = elements[i];
-          const uniforms2 = material2.uniforms;
-          uniforms2["color"].value.copy(element.color);
-          uniforms2["map"].value = element.texture;
-          uniforms2["screenPosition"].value.x = positionScreen.x + vecX * element.distance;
-          uniforms2["screenPosition"].value.y = positionScreen.y + vecY * element.distance;
-          size = element.size / viewport.w;
-          const invAspect2 = viewport.w / viewport.z;
-          uniforms2["scale"].value.set(size * invAspect2, size);
-          material2.uniformsNeedUpdate = true;
-          renderer.renderBufferDirect(camera, null, geometry, material2, mesh2, null);
-        }
-      }
-    };
-    this.dispose = function() {
-      material1a.dispose();
-      material1b.dispose();
-      material2.dispose();
-      tempMap.dispose();
-      occlusionMap.dispose();
-      for (let i = 0, l = elements.length; i < l; i++) {
-        elements[i].texture.dispose();
-      }
-    };
-  }
-}
-Lensflare.prototype.isLensflare = true;
-class LensflareElement {
-  constructor(texture, size = 1, distance = 0, color = new Color(16777215)) {
-    this.texture = texture;
-    this.size = size;
-    this.distance = distance;
-    this.color = color;
-  }
-}
-LensflareElement.Shader = {
-  uniforms: {
-    map: { value: null },
-    occlusionMap: { value: null },
-    color: { value: null },
-    scale: { value: null },
-    screenPosition: { value: null }
-  },
-  vertexShader: `
-
-		precision highp float;
-
-		uniform vec3 screenPosition;
-		uniform vec2 scale;
-
-		uniform sampler2D occlusionMap;
-
-		attribute vec3 position;
-		attribute vec2 uv;
-
-		varying vec2 vUV;
-		varying float vVisibility;
-
-		void main() {
-
-			vUV = uv;
-
-			vec2 pos = position.xy;
-
-			vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );
-			visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );
-
-			vVisibility =        visibility.r / 9.0;
-			vVisibility *= 1.0 - visibility.g / 9.0;
-			vVisibility *=       visibility.b / 9.0;
-
-			gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );
-
-		}`,
-  fragmentShader: `
-
-		precision highp float;
-
-		uniform sampler2D map;
-		uniform vec3 color;
-
-		varying vec2 vUV;
-		varying float vVisibility;
-
-		void main() {
-
-			vec4 texture = texture2D( map, vUV );
-			texture.a *= vVisibility;
-			gl_FragColor = texture;
-			gl_FragColor.rgb *= color;
-
-		}`
-};
-Lensflare.Geometry = function() {
-  const geometry = new BufferGeometry();
-  const float32Array = new Float32Array([-1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, 1, 0, 1, 1, -1, 1, 0, 0, 1]);
-  const interleavedBuffer = new InterleavedBuffer(float32Array, 5);
-  geometry.setIndex([0, 1, 2, 0, 2, 3]);
-  geometry.setAttribute("position", new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false));
-  geometry.setAttribute("uv", new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false));
-  return geometry;
-}();
-export {
-  Lensflare,
-  LensflareElement
-};