three-stdlib 2.22.7 → 2.22.8

package/dist/shaders/HueSaturationShader.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hue and saturation adjustment
+ * https://github.com/evanw/glfx.js
+ * hue: -1 to 1 (-1 is 180 degrees in the negative direction, 0 is no change, etc.
+ * saturation: -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)
+ */
+export declare const HueSaturationShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        hue: {
+            value: number;
+        };
+        saturation: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/HueSaturationShader.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const HueSaturationShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    hue: { value: 0 },
+    saturation: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float hue;",
+    "uniform float saturation;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	gl_FragColor = texture2D( tDiffuse, vUv );",
+    // hue
+    "	float angle = hue * 3.14159265;",
+    "	float s = sin(angle), c = cos(angle);",
+    "	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;",
+    "	float len = length(gl_FragColor.rgb);",
+    "	gl_FragColor.rgb = vec3(",
+    "		dot(gl_FragColor.rgb, weights.xyz),",
+    "		dot(gl_FragColor.rgb, weights.zxy),",
+    "		dot(gl_FragColor.rgb, weights.yzx)",
+    "	);",
+    // saturation
+    "	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;",
+    "	if (saturation > 0.0) {",
+    "		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));",
+    "	} else {",
+    "		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);",
+    "	}",
+    "}"
+  ].join("\n")
+};
+exports.HueSaturationShader = HueSaturationShader;

package/dist/shaders/HueSaturationShader.mjs

@@ -0,0 +1,43 @@
+const HueSaturationShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    hue: { value: 0 },
+    saturation: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float hue;",
+    "uniform float saturation;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	gl_FragColor = texture2D( tDiffuse, vUv );",
+    // hue
+    "	float angle = hue * 3.14159265;",
+    "	float s = sin(angle), c = cos(angle);",
+    "	vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;",
+    "	float len = length(gl_FragColor.rgb);",
+    "	gl_FragColor.rgb = vec3(",
+    "		dot(gl_FragColor.rgb, weights.xyz),",
+    "		dot(gl_FragColor.rgb, weights.zxy),",
+    "		dot(gl_FragColor.rgb, weights.yzx)",
+    "	);",
+    // saturation
+    "	float average = (gl_FragColor.r + gl_FragColor.g + gl_FragColor.b) / 3.0;",
+    "	if (saturation > 0.0) {",
+    "		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (1.0 - 1.0 / (1.001 - saturation));",
+    "	} else {",
+    "		gl_FragColor.rgb += (average - gl_FragColor.rgb) * (-saturation);",
+    "	}",
+    "}"
+  ].join("\n")
+};
+export {
+  HueSaturationShader
+};

package/dist/shaders/KaleidoShader.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Kaleidoscope Shader
+ * Radial reflection around center point
+ * Ported from: http://pixelshaders.com/editor/
+ * by Toby Schachman / http://tobyschachman.com/
+ *
+ * sides: number of reflections
+ * angle: initial angle in radians
+ */
+export declare const KaleidoShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        sides: {
+            value: number;
+        };
+        angle: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/KaleidoShader.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const KaleidoShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    sides: { value: 6 },
+    angle: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float sides;",
+    "uniform float angle;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec2 p = vUv - 0.5;",
+    "	float r = length(p);",
+    "	float a = atan(p.y, p.x) + angle;",
+    "	float tau = 2. * 3.1416 ;",
+    "	a = mod(a, tau/sides);",
+    "	a = abs(a - tau/sides/2.) ;",
+    "	p = r * vec2(cos(a), sin(a));",
+    "	vec4 color = texture2D(tDiffuse, p + 0.5);",
+    "	gl_FragColor = color;",
+    "}"
+  ].join("\n")
+};
+exports.KaleidoShader = KaleidoShader;

package/dist/shaders/KaleidoShader.mjs

@@ -0,0 +1,34 @@
+const KaleidoShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    sides: { value: 6 },
+    angle: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float sides;",
+    "uniform float angle;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec2 p = vUv - 0.5;",
+    "	float r = length(p);",
+    "	float a = atan(p.y, p.x) + angle;",
+    "	float tau = 2. * 3.1416 ;",
+    "	a = mod(a, tau/sides);",
+    "	a = abs(a - tau/sides/2.) ;",
+    "	p = r * vec2(cos(a), sin(a));",
+    "	vec4 color = texture2D(tDiffuse, p + 0.5);",
+    "	gl_FragColor = color;",
+    "}"
+  ].join("\n")
+};
+export {
+  KaleidoShader
+};

package/dist/shaders/LuminosityHighPassShader.d.ts

@@ -0,0 +1,27 @@
+import { Color } from 'three';
+/**
+ * Luminosity
+ * http://en.wikipedia.org/wiki/Luminosity
+ */
+export declare const LuminosityHighPassShader: {
+    shaderID: string;
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        luminosityThreshold: {
+            value: number;
+        };
+        smoothWidth: {
+            value: number;
+        };
+        defaultColor: {
+            value: Color;
+        };
+        defaultOpacity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/LuminosityHighPassShader.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const LuminosityHighPassShader = {
+  shaderID: "luminosityHighPass",
+  uniforms: {
+    tDiffuse: { value: null },
+    luminosityThreshold: { value: 1 },
+    smoothWidth: { value: 1 },
+    defaultColor: { value: new THREE.Color(0) },
+    defaultOpacity: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform vec3 defaultColor;",
+    "uniform float defaultOpacity;",
+    "uniform float luminosityThreshold;",
+    "uniform float smoothWidth;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 texel = texture2D( tDiffuse, vUv );",
+    "	vec3 luma = vec3( 0.299, 0.587, 0.114 );",
+    "	float v = dot( texel.xyz, luma );",
+    "	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );",
+    "	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );",
+    "	gl_FragColor = mix( outputColor, texel, alpha );",
+    "}"
+  ].join("\n")
+};
+exports.LuminosityHighPassShader = LuminosityHighPassShader;

package/dist/shaders/LuminosityHighPassShader.mjs

@@ -0,0 +1,37 @@
+import { Color } from "three";
+const LuminosityHighPassShader = {
+  shaderID: "luminosityHighPass",
+  uniforms: {
+    tDiffuse: { value: null },
+    luminosityThreshold: { value: 1 },
+    smoothWidth: { value: 1 },
+    defaultColor: { value: new Color(0) },
+    defaultOpacity: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform vec3 defaultColor;",
+    "uniform float defaultOpacity;",
+    "uniform float luminosityThreshold;",
+    "uniform float smoothWidth;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 texel = texture2D( tDiffuse, vUv );",
+    "	vec3 luma = vec3( 0.299, 0.587, 0.114 );",
+    "	float v = dot( texel.xyz, luma );",
+    "	vec4 outputColor = vec4( defaultColor.rgb, defaultOpacity );",
+    "	float alpha = smoothstep( luminosityThreshold, luminosityThreshold + smoothWidth, v );",
+    "	gl_FragColor = mix( outputColor, texel, alpha );",
+    "}"
+  ].join("\n")
+};
+export {
+  LuminosityHighPassShader
+};

package/dist/shaders/LuminosityShader.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Luminosity
+ * http://en.wikipedia.org/wiki/Luminosity
+ */
+export declare const LuminosityShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/LuminosityShader.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const LuminosityShader = {
+  uniforms: {
+    tDiffuse: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#include <common>",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 texel = texture2D( tDiffuse, vUv );",
+    "	float l = linearToRelativeLuminance( texel.rgb );",
+    "	gl_FragColor = vec4( l, l, l, texel.w );",
+    "}"
+  ].join("\n")
+};
+exports.LuminosityShader = LuminosityShader;

package/dist/shaders/LuminosityShader.mjs

@@ -0,0 +1,25 @@
+const LuminosityShader = {
+  uniforms: {
+    tDiffuse: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#include <common>",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 texel = texture2D( tDiffuse, vUv );",
+    "	float l = linearToRelativeLuminance( texel.rgb );",
+    "	gl_FragColor = vec4( l, l, l, texel.w );",
+    "}"
+  ].join("\n")
+};
+export {
+  LuminosityShader
+};

package/dist/shaders/MirrorShader.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mirror Shader
+ * Copies half the input to the other half
+ *
+ * side: side of input to mirror (0 = left, 1 = right, 2 = top, 3 = bottom)
+ */
+export declare const MirrorShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        side: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/MirrorShader.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const MirrorShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    side: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform int side;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec2 p = vUv;",
+    "	if (side == 0){",
+    "		if (p.x > 0.5) p.x = 1.0 - p.x;",
+    "	}else if (side == 1){",
+    "		if (p.x < 0.5) p.x = 1.0 - p.x;",
+    "	}else if (side == 2){",
+    "		if (p.y < 0.5) p.y = 1.0 - p.y;",
+    "	}else if (side == 3){",
+    "		if (p.y > 0.5) p.y = 1.0 - p.y;",
+    "	} ",
+    "	vec4 color = texture2D(tDiffuse, p);",
+    "	gl_FragColor = color;",
+    "}"
+  ].join("\n")
+};
+exports.MirrorShader = MirrorShader;

package/dist/shaders/MirrorShader.mjs

@@ -0,0 +1,35 @@
+const MirrorShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    side: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform int side;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec2 p = vUv;",
+    "	if (side == 0){",
+    "		if (p.x > 0.5) p.x = 1.0 - p.x;",
+    "	}else if (side == 1){",
+    "		if (p.x < 0.5) p.x = 1.0 - p.x;",
+    "	}else if (side == 2){",
+    "		if (p.y < 0.5) p.y = 1.0 - p.y;",
+    "	}else if (side == 3){",
+    "		if (p.y > 0.5) p.y = 1.0 - p.y;",
+    "	} ",
+    "	vec4 color = texture2D(tDiffuse, p);",
+    "	gl_FragColor = color;",
+    "}"
+  ].join("\n")
+};
+export {
+  MirrorShader
+};

package/dist/shaders/NormalMapShader.d.ts

@@ -0,0 +1,23 @@
+import { Vector2 } from 'three';
+/**
+ * Normal map shader
+ * - compute normals from heightmap
+ */
+export declare const NormalMapShader: {
+    uniforms: {
+        heightMap: {
+            value: null;
+        };
+        resolution: {
+            value: Vector2;
+        };
+        scale: {
+            value: Vector2;
+        };
+        height: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/NormalMapShader.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const NormalMapShader = {
+  uniforms: {
+    heightMap: { value: null },
+    resolution: { value: new THREE.Vector2(512, 512) },
+    scale: { value: new THREE.Vector2(1, 1) },
+    height: { value: 0.05 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float height;",
+    "uniform vec2 resolution;",
+    "uniform sampler2D heightMap;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	float val = texture2D( heightMap, vUv ).x;",
+    "	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;",
+    "	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;",
+    "	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );",
+    "}"
+  ].join("\n")
+};
+exports.NormalMapShader = NormalMapShader;

package/dist/shaders/NormalMapShader.mjs

@@ -0,0 +1,31 @@
+import { Vector2 } from "three";
+const NormalMapShader = {
+  uniforms: {
+    heightMap: { value: null },
+    resolution: { value: new Vector2(512, 512) },
+    scale: { value: new Vector2(1, 1) },
+    height: { value: 0.05 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float height;",
+    "uniform vec2 resolution;",
+    "uniform sampler2D heightMap;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	float val = texture2D( heightMap, vUv ).x;",
+    "	float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;",
+    "	float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;",
+    "	gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );",
+    "}"
+  ].join("\n")
+};
+export {
+  NormalMapShader
+};

package/dist/shaders/ParallaxShader.d.ts

@@ -0,0 +1,28 @@
+export declare const ParallaxShader: {
+    modes: {
+        none: string;
+        basic: string;
+        steep: string;
+        occlusion: string;
+        relief: string;
+    };
+    uniforms: {
+        bumpMap: {
+            value: null;
+        };
+        map: {
+            value: null;
+        };
+        parallaxScale: {
+            value: null;
+        };
+        parallaxMinLayers: {
+            value: null;
+        };
+        parallaxMaxLayers: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};