three-stdlib 2.22.7 → 2.22.8

package/dist/postprocessing/LUTPass.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ShaderPass = require("./ShaderPass.js");
+const LUTShader = {
+  defines: {
+    USE_3DTEXTURE: 1
+  },
+  uniforms: {
+    lut3d: { value: null },
+    lut: { value: null },
+    lutSize: { value: 0 },
+    tDiffuse: { value: null },
+    intensity: { value: 1 }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}
+
+	`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+
+		uniform float lutSize;
+		#if USE_3DTEXTURE
+		precision highp sampler3D;
+		uniform sampler3D lut3d;
+		#else
+		uniform sampler2D lut;
+
+		vec3 lutLookup( sampler2D tex, float size, vec3 rgb ) {
+
+			float sliceHeight = 1.0 / size;
+			float yPixelHeight = 1.0 / ( size * size );
+
+			// Get the slices on either side of the sample
+			float slice = rgb.b * size;
+			float interp = fract( slice );
+			float slice0 = slice - interp;
+			float centeredInterp = interp - 0.5;
+
+			float slice1 = slice0 + sign( centeredInterp );
+
+			// Pull y sample in by half a pixel in each direction to avoid color
+			// bleeding from adjacent slices.
+			float greenOffset = clamp( rgb.g * sliceHeight, yPixelHeight * 0.5, sliceHeight - yPixelHeight * 0.5 );
+
+			vec2 uv0 = vec2(
+				rgb.r,
+				slice0 * sliceHeight + greenOffset
+			);
+			vec2 uv1 = vec2(
+				rgb.r,
+				slice1 * sliceHeight + greenOffset
+			);
+
+			vec3 sample0 = texture2D( tex, uv0 ).rgb;
+			vec3 sample1 = texture2D( tex, uv1 ).rgb;
+
+			return mix( sample0, sample1, abs( centeredInterp ) );
+
+		}
+		#endif
+
+		varying vec2 vUv;
+		uniform float intensity;
+		uniform sampler2D tDiffuse;
+		void main() {
+
+			vec4 val = texture2D( tDiffuse, vUv );
+			vec4 lutVal;
+
+			// pull the sample in by half a pixel so the sample begins
+			// at the center of the edge pixels.
+			float pixelWidth = 1.0 / lutSize;
+			float halfPixelWidth = 0.5 / lutSize;
+			vec3 uvw = vec3( halfPixelWidth ) + val.rgb * ( 1.0 - pixelWidth );
+
+			#if USE_3DTEXTURE
+
+			lutVal = vec4( texture( lut3d, uvw ).rgb, val.a );
+
+			#else
+
+			lutVal = vec4( lutLookup( lut, lutSize, uvw ), val.a );
+
+			#endif
+
+			gl_FragColor = vec4( mix( val, lutVal, intensity ) );
+
+		}
+
+	`
+  )
+};
+class LUTPass extends ShaderPass.ShaderPass {
+  set lut(v) {
+    const material = this.material;
+    if (v !== this.lut) {
+      material.uniforms.lut3d.value = null;
+      material.uniforms.lut.value = null;
+      if (v) {
+        const is3dTextureDefine = v.isData3DTexture ? 1 : 0;
+        if (is3dTextureDefine !== material.defines.USE_3DTEXTURE) {
+          material.defines.USE_3DTEXTURE = is3dTextureDefine;
+          material.needsUpdate = true;
+        }
+        material.uniforms.lutSize.value = v.image.width;
+        if (v.isData3DTexture) {
+          material.uniforms.lut3d.value = v;
+        } else {
+          material.uniforms.lut.value = v;
+        }
+      }
+    }
+  }
+  get lut() {
+    return this.material.uniforms.lut.value || this.material.uniforms.lut3d.value;
+  }
+  set intensity(v) {
+    this.material.uniforms.intensity.value = v;
+  }
+  get intensity() {
+    return this.material.uniforms.intensity.value;
+  }
+  constructor(options = {}) {
+    super(LUTShader);
+    this.lut = options.lut || null;
+    this.intensity = "intensity" in options ? options.intensity : 1;
+  }
+}
+exports.LUTPass = LUTPass;

package/dist/postprocessing/LUTPass.mjs

@@ -0,0 +1,142 @@
+import { ShaderPass } from "./ShaderPass.mjs";
+const LUTShader = {
+  defines: {
+    USE_3DTEXTURE: 1
+  },
+  uniforms: {
+    lut3d: { value: null },
+    lut: { value: null },
+    lutSize: { value: 0 },
+    tDiffuse: { value: null },
+    intensity: { value: 1 }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}
+
+	`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+
+		uniform float lutSize;
+		#if USE_3DTEXTURE
+		precision highp sampler3D;
+		uniform sampler3D lut3d;
+		#else
+		uniform sampler2D lut;
+
+		vec3 lutLookup( sampler2D tex, float size, vec3 rgb ) {
+
+			float sliceHeight = 1.0 / size;
+			float yPixelHeight = 1.0 / ( size * size );
+
+			// Get the slices on either side of the sample
+			float slice = rgb.b * size;
+			float interp = fract( slice );
+			float slice0 = slice - interp;
+			float centeredInterp = interp - 0.5;
+
+			float slice1 = slice0 + sign( centeredInterp );
+
+			// Pull y sample in by half a pixel in each direction to avoid color
+			// bleeding from adjacent slices.
+			float greenOffset = clamp( rgb.g * sliceHeight, yPixelHeight * 0.5, sliceHeight - yPixelHeight * 0.5 );
+
+			vec2 uv0 = vec2(
+				rgb.r,
+				slice0 * sliceHeight + greenOffset
+			);
+			vec2 uv1 = vec2(
+				rgb.r,
+				slice1 * sliceHeight + greenOffset
+			);
+
+			vec3 sample0 = texture2D( tex, uv0 ).rgb;
+			vec3 sample1 = texture2D( tex, uv1 ).rgb;
+
+			return mix( sample0, sample1, abs( centeredInterp ) );
+
+		}
+		#endif
+
+		varying vec2 vUv;
+		uniform float intensity;
+		uniform sampler2D tDiffuse;
+		void main() {
+
+			vec4 val = texture2D( tDiffuse, vUv );
+			vec4 lutVal;
+
+			// pull the sample in by half a pixel so the sample begins
+			// at the center of the edge pixels.
+			float pixelWidth = 1.0 / lutSize;
+			float halfPixelWidth = 0.5 / lutSize;
+			vec3 uvw = vec3( halfPixelWidth ) + val.rgb * ( 1.0 - pixelWidth );
+
+			#if USE_3DTEXTURE
+
+			lutVal = vec4( texture( lut3d, uvw ).rgb, val.a );
+
+			#else
+
+			lutVal = vec4( lutLookup( lut, lutSize, uvw ), val.a );
+
+			#endif
+
+			gl_FragColor = vec4( mix( val, lutVal, intensity ) );
+
+		}
+
+	`
+  )
+};
+class LUTPass extends ShaderPass {
+  set lut(v) {
+    const material = this.material;
+    if (v !== this.lut) {
+      material.uniforms.lut3d.value = null;
+      material.uniforms.lut.value = null;
+      if (v) {
+        const is3dTextureDefine = v.isData3DTexture ? 1 : 0;
+        if (is3dTextureDefine !== material.defines.USE_3DTEXTURE) {
+          material.defines.USE_3DTEXTURE = is3dTextureDefine;
+          material.needsUpdate = true;
+        }
+        material.uniforms.lutSize.value = v.image.width;
+        if (v.isData3DTexture) {
+          material.uniforms.lut3d.value = v;
+        } else {
+          material.uniforms.lut.value = v;
+        }
+      }
+    }
+  }
+  get lut() {
+    return this.material.uniforms.lut.value || this.material.uniforms.lut3d.value;
+  }
+  set intensity(v) {
+    this.material.uniforms.intensity.value = v;
+  }
+  get intensity() {
+    return this.material.uniforms.intensity.value;
+  }
+  constructor(options = {}) {
+    super(LUTShader);
+    this.lut = options.lut || null;
+    this.intensity = "intensity" in options ? options.intensity : 1;
+  }
+}
+export {
+  LUTPass
+};

package/dist/postprocessing/MaskPass.d.ts

@@ -0,0 +1,14 @@
+import { Camera, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Pass } from './Pass';
+declare class MaskPass extends Pass {
+    scene: Scene;
+    camera: Camera;
+    inverse: boolean;
+    constructor(scene: Scene, camera: Camera);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+}
+declare class ClearMaskPass extends Pass {
+    constructor();
+    render(renderer: WebGLRenderer): void;
+}
+export { MaskPass, ClearMaskPass };

package/dist/postprocessing/MaskPass.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Pass = require("./Pass.js");
+class MaskPass extends Pass.Pass {
+  constructor(scene, camera) {
+    super();
+    __publicField(this, "scene");
+    __publicField(this, "camera");
+    __publicField(this, "inverse");
+    this.scene = scene;
+    this.camera = camera;
+    this.clear = true;
+    this.needsSwap = false;
+    this.inverse = false;
+  }
+  render(renderer, writeBuffer, readBuffer) {
+    const context = renderer.getContext();
+    const state = renderer.state;
+    state.buffers.color.setMask(false);
+    state.buffers.depth.setMask(false);
+    state.buffers.color.setLocked(true);
+    state.buffers.depth.setLocked(true);
+    let writeValue, clearValue;
+    if (this.inverse) {
+      writeValue = 0;
+      clearValue = 1;
+    } else {
+      writeValue = 1;
+      clearValue = 0;
+    }
+    state.buffers.stencil.setTest(true);
+    state.buffers.stencil.setOp(context.REPLACE, context.REPLACE, context.REPLACE);
+    state.buffers.stencil.setFunc(context.ALWAYS, writeValue, 4294967295);
+    state.buffers.stencil.setClear(clearValue);
+    state.buffers.stencil.setLocked(true);
+    renderer.setRenderTarget(readBuffer);
+    if (this.clear)
+      renderer.clear();
+    renderer.render(this.scene, this.camera);
+    renderer.setRenderTarget(writeBuffer);
+    if (this.clear)
+      renderer.clear();
+    renderer.render(this.scene, this.camera);
+    state.buffers.color.setLocked(false);
+    state.buffers.depth.setLocked(false);
+    state.buffers.stencil.setLocked(false);
+    state.buffers.stencil.setFunc(context.EQUAL, 1, 4294967295);
+    state.buffers.stencil.setOp(context.KEEP, context.KEEP, context.KEEP);
+    state.buffers.stencil.setLocked(true);
+  }
+}
+class ClearMaskPass extends Pass.Pass {
+  constructor() {
+    super();
+    this.needsSwap = false;
+  }
+  render(renderer) {
+    renderer.state.buffers.stencil.setLocked(false);
+    renderer.state.buffers.stencil.setTest(false);
+  }
+}
+exports.ClearMaskPass = ClearMaskPass;
+exports.MaskPass = MaskPass;

package/dist/postprocessing/MaskPass.mjs

@@ -0,0 +1,69 @@
+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 { Pass } from "./Pass.mjs";
+class MaskPass extends Pass {
+  constructor(scene, camera) {
+    super();
+    __publicField(this, "scene");
+    __publicField(this, "camera");
+    __publicField(this, "inverse");
+    this.scene = scene;
+    this.camera = camera;
+    this.clear = true;
+    this.needsSwap = false;
+    this.inverse = false;
+  }
+  render(renderer, writeBuffer, readBuffer) {
+    const context = renderer.getContext();
+    const state = renderer.state;
+    state.buffers.color.setMask(false);
+    state.buffers.depth.setMask(false);
+    state.buffers.color.setLocked(true);
+    state.buffers.depth.setLocked(true);
+    let writeValue, clearValue;
+    if (this.inverse) {
+      writeValue = 0;
+      clearValue = 1;
+    } else {
+      writeValue = 1;
+      clearValue = 0;
+    }
+    state.buffers.stencil.setTest(true);
+    state.buffers.stencil.setOp(context.REPLACE, context.REPLACE, context.REPLACE);
+    state.buffers.stencil.setFunc(context.ALWAYS, writeValue, 4294967295);
+    state.buffers.stencil.setClear(clearValue);
+    state.buffers.stencil.setLocked(true);
+    renderer.setRenderTarget(readBuffer);
+    if (this.clear)
+      renderer.clear();
+    renderer.render(this.scene, this.camera);
+    renderer.setRenderTarget(writeBuffer);
+    if (this.clear)
+      renderer.clear();
+    renderer.render(this.scene, this.camera);
+    state.buffers.color.setLocked(false);
+    state.buffers.depth.setLocked(false);
+    state.buffers.stencil.setLocked(false);
+    state.buffers.stencil.setFunc(context.EQUAL, 1, 4294967295);
+    state.buffers.stencil.setOp(context.KEEP, context.KEEP, context.KEEP);
+    state.buffers.stencil.setLocked(true);
+  }
+}
+class ClearMaskPass extends Pass {
+  constructor() {
+    super();
+    this.needsSwap = false;
+  }
+  render(renderer) {
+    renderer.state.buffers.stencil.setLocked(false);
+    renderer.state.buffers.stencil.setTest(false);
+  }
+}
+export {
+  ClearMaskPass,
+  MaskPass
+};

package/dist/postprocessing/OutlinePass.d.ts

@@ -0,0 +1,53 @@
+import { Pass, FullScreenQuad } from './Pass';
+import { Camera, Color, Matrix4, MeshDepthMaterial, Object3D, Scene, ShaderMaterial, Texture, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+declare class OutlinePass extends Pass {
+    renderScene: Scene;
+    renderCamera: Camera;
+    selectedObjects: Object3D[];
+    visibleEdgeColor: Color;
+    hiddenEdgeColor: Color;
+    edgeGlow: number;
+    usePatternTexture: boolean;
+    edgeThickness: number;
+    edgeStrength: number;
+    downSampleRatio: number;
+    pulsePeriod: number;
+    resolution: Vector2;
+    renderTargetMaskBuffer: WebGLRenderTarget;
+    depthMaterial: MeshDepthMaterial;
+    prepareMaskMaterial: ShaderMaterial;
+    renderTargetDepthBuffer: WebGLRenderTarget;
+    renderTargetMaskDownSampleBuffer: WebGLRenderTarget;
+    renderTargetBlurBuffer1: WebGLRenderTarget;
+    renderTargetBlurBuffer2: WebGLRenderTarget;
+    edgeDetectionMaterial: ShaderMaterial;
+    renderTargetEdgeBuffer1: WebGLRenderTarget;
+    renderTargetEdgeBuffer2: WebGLRenderTarget;
+    separableBlurMaterial1: ShaderMaterial;
+    separableBlurMaterial2: ShaderMaterial;
+    overlayMaterial: ShaderMaterial;
+    materialCopy: ShaderMaterial;
+    oldClearAlpha: number;
+    fsQuad: FullScreenQuad;
+    tempPulseColor1: Color;
+    tempPulseColor2: Color;
+    textureMatrix: Matrix4;
+    patternTexture?: Texture;
+    private _visibilityCache;
+    private _oldClearColor;
+    copyUniforms: any;
+    BlurDirectionX: Vector2;
+    BlurDirectionY: Vector2;
+    constructor(resolution: Vector2, scene: Scene, camera: Camera, selectedObjects?: Object3D[]);
+    dispose(): void;
+    setSize(width: number, height: number): void;
+    changeVisibilityOfSelectedObjects(bVisible: boolean): void;
+    changeVisibilityOfNonSelectedObjects(bVisible: boolean): void;
+    updateTextureMatrix(): void;
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, deltaTime: number, maskActive: boolean): void;
+    getPrepareMaskMaterial(): ShaderMaterial;
+    getEdgeDetectionMaterial(): ShaderMaterial;
+    getSeperableBlurMaterial(maxRadius: number): ShaderMaterial;
+    getOverlayMaterial(): ShaderMaterial;
+}
+export { OutlinePass };