three-stdlib 2.22.7 → 2.22.9

package/dist/shaders/FilmShader.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Film grain & scanlines shader
+ *
+ * - ported from HLSL to WebGL / GLSL
+ * http://www.truevision3d.com/forums/showcase/staticnoise_colorblackwhite_scanline_shaders-t18698.0.html
+ *
+ * Screen Space Static Postprocessor
+ *
+ * Produces an analogue noise overlay similar to a film grain / TV static
+ *
+ * Original implementation and noise algorithm
+ * Pat 'Hawthorne' Shearon
+ *
+ * Optimized scanlines + noise version with intensity scaling
+ * Georg 'Leviathan' Steinrohder
+ *
+ * This version is provided under a Creative Commons Attribution 3.0 License
+ * http://creativecommons.org/licenses/by/3.0/
+ */
+export declare const FilmShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        time: {
+            value: number;
+        };
+        nIntensity: {
+            value: number;
+        };
+        sIntensity: {
+            value: number;
+        };
+        sCount: {
+            value: number;
+        };
+        grayscale: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/FilmShader.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const FilmShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    time: { value: 0 },
+    nIntensity: { value: 0.5 },
+    sIntensity: { value: 0.05 },
+    sCount: { value: 4096 },
+    grayscale: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#include <common>",
+    // control parameter
+    "uniform float time;",
+    "uniform bool grayscale;",
+    // noise effect intensity value (0 = no effect, 1 = full effect)
+    "uniform float nIntensity;",
+    // scanlines effect intensity value (0 = no effect, 1 = full effect)
+    "uniform float sIntensity;",
+    // scanlines effect count value (0 = no effect, 4096 = full effect)
+    "uniform float sCount;",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    // sample the source
+    "	vec4 cTextureScreen = texture2D( tDiffuse, vUv );",
+    // make some noise
+    "	float dx = rand( vUv + time );",
+    // add noise
+    "	vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx, 0.0, 1.0 );",
+    // get us a sine and cosine
+    "	vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );",
+    // add scanlines
+    "	cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;",
+    // interpolate between source and result by intensity
+    "	cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );",
+    // convert to grayscale if desired
+    "	if( grayscale ) {",
+    "		cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );",
+    "	}",
+    "	gl_FragColor =  vec4( cResult, cTextureScreen.a );",
+    "}"
+  ].join("\n")
+};
+exports.FilmShader = FilmShader;

package/dist/shaders/FilmShader.mjs

@@ -0,0 +1,53 @@
+const FilmShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    time: { value: 0 },
+    nIntensity: { value: 0.5 },
+    sIntensity: { value: 0.05 },
+    sCount: { value: 4096 },
+    grayscale: { value: 1 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#include <common>",
+    // control parameter
+    "uniform float time;",
+    "uniform bool grayscale;",
+    // noise effect intensity value (0 = no effect, 1 = full effect)
+    "uniform float nIntensity;",
+    // scanlines effect intensity value (0 = no effect, 1 = full effect)
+    "uniform float sIntensity;",
+    // scanlines effect count value (0 = no effect, 4096 = full effect)
+    "uniform float sCount;",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    // sample the source
+    "	vec4 cTextureScreen = texture2D( tDiffuse, vUv );",
+    // make some noise
+    "	float dx = rand( vUv + time );",
+    // add noise
+    "	vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx, 0.0, 1.0 );",
+    // get us a sine and cosine
+    "	vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );",
+    // add scanlines
+    "	cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;",
+    // interpolate between source and result by intensity
+    "	cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );",
+    // convert to grayscale if desired
+    "	if( grayscale ) {",
+    "		cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );",
+    "	}",
+    "	gl_FragColor =  vec4( cResult, cTextureScreen.a );",
+    "}"
+  ].join("\n")
+};
+export {
+  FilmShader
+};

package/dist/shaders/FocusShader.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Focus shader
+ * based on PaintEffect postprocess from ro.me
+ * http://code.google.com/p/3-dreams-of-black/source/browse/deploy/js/effects/PaintEffect.js
+ */
+export declare const FocusShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        screenWidth: {
+            value: number;
+        };
+        screenHeight: {
+            value: number;
+        };
+        sampleDistance: {
+            value: number;
+        };
+        waveFactor: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/FocusShader.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const FocusShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    screenWidth: { value: 1024 },
+    screenHeight: { value: 1024 },
+    sampleDistance: { value: 0.94 },
+    waveFactor: { value: 125e-5 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float screenWidth;",
+    "uniform float screenHeight;",
+    "uniform float sampleDistance;",
+    "uniform float waveFactor;",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 color, org, tmp, add;",
+    "	float sample_dist, f;",
+    "	vec2 vin;",
+    "	vec2 uv = vUv;",
+    "	add = color = org = texture2D( tDiffuse, uv );",
+    "	vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );",
+    "	sample_dist = dot( vin, vin ) * 2.0;",
+    "	f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;",
+    "	vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );",
+    "	color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );",
+    "	gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );",
+    "}"
+  ].join("\n")
+};
+exports.FocusShader = FocusShader;

package/dist/shaders/FocusShader.mjs

@@ -0,0 +1,55 @@
+const FocusShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    screenWidth: { value: 1024 },
+    screenHeight: { value: 1024 },
+    sampleDistance: { value: 0.94 },
+    waveFactor: { value: 125e-5 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform float screenWidth;",
+    "uniform float screenHeight;",
+    "uniform float sampleDistance;",
+    "uniform float waveFactor;",
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 color, org, tmp, add;",
+    "	float sample_dist, f;",
+    "	vec2 vin;",
+    "	vec2 uv = vUv;",
+    "	add = color = org = texture2D( tDiffuse, uv );",
+    "	vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );",
+    "	sample_dist = dot( vin, vin ) * 2.0;",
+    "	f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;",
+    "	vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );",
+    "	if( tmp.b < color.b ) color = tmp;",
+    "	color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );",
+    "	color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );",
+    "	gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );",
+    "}"
+  ].join("\n")
+};
+export {
+  FocusShader
+};

package/dist/shaders/FreiChenShader.d.ts

@@ -0,0 +1,19 @@
+import { Vector2 } from 'three';
+/**
+ * Edge Detection Shader using Frei-Chen filter
+ * Based on http://rastergrid.com/blog/2011/01/frei-chen-edge-detector
+ *
+ * aspect: vec2 of (1/width, 1/height)
+ */
+export declare const FreiChenShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        aspect: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/FreiChenShader.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const FreiChenShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    aspect: { value: new THREE.Vector2(512, 512) }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "uniform vec2 aspect;",
+    "vec2 texel = vec2(1.0 / aspect.x, 1.0 / aspect.y);",
+    "mat3 G[9];",
+    // hard coded matrix values!!!! as suggested in https://github.com/neilmendoza/ofxPostProcessing/blob/master/src/EdgePass.cpp#L45
+    "const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );",
+    "const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );",
+    "const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );",
+    "const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );",
+    "const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );",
+    "const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );",
+    "const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );",
+    "const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );",
+    "const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );",
+    "void main(void)",
+    "{",
+    "	G[0] = g0,",
+    "	G[1] = g1,",
+    "	G[2] = g2,",
+    "	G[3] = g3,",
+    "	G[4] = g4,",
+    "	G[5] = g5,",
+    "	G[6] = g6,",
+    "	G[7] = g7,",
+    "	G[8] = g8;",
+    "	mat3 I;",
+    "	float cnv[9];",
+    "	vec3 sample;",
+    /* fetch the 3x3 neighbourhood and use the RGB vector's length as intensity value */
+    "	for (float i=0.0; i<3.0; i++) {",
+    "		for (float j=0.0; j<3.0; j++) {",
+    "			sample = texture2D(tDiffuse, vUv + texel * vec2(i-1.0,j-1.0) ).rgb;",
+    "			I[int(i)][int(j)] = length(sample);",
+    "		}",
+    "	}",
+    /* calculate the convolution values for all the masks */
+    "	for (int i=0; i<9; i++) {",
+    "		float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);",
+    "		cnv[i] = dp3 * dp3;",
+    "	}",
+    "	float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);",
+    "	float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);",
+    "	gl_FragColor = vec4(vec3(sqrt(M/S)), 1.0);",
+    "}"
+  ].join("\n")
+};
+exports.FreiChenShader = FreiChenShader;

package/dist/shaders/FreiChenShader.mjs

@@ -0,0 +1,64 @@
+import { Vector2 } from "three";
+const FreiChenShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    aspect: { value: new Vector2(512, 512) }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "uniform vec2 aspect;",
+    "vec2 texel = vec2(1.0 / aspect.x, 1.0 / aspect.y);",
+    "mat3 G[9];",
+    // hard coded matrix values!!!! as suggested in https://github.com/neilmendoza/ofxPostProcessing/blob/master/src/EdgePass.cpp#L45
+    "const mat3 g0 = mat3( 0.3535533845424652, 0, -0.3535533845424652, 0.5, 0, -0.5, 0.3535533845424652, 0, -0.3535533845424652 );",
+    "const mat3 g1 = mat3( 0.3535533845424652, 0.5, 0.3535533845424652, 0, 0, 0, -0.3535533845424652, -0.5, -0.3535533845424652 );",
+    "const mat3 g2 = mat3( 0, 0.3535533845424652, -0.5, -0.3535533845424652, 0, 0.3535533845424652, 0.5, -0.3535533845424652, 0 );",
+    "const mat3 g3 = mat3( 0.5, -0.3535533845424652, 0, -0.3535533845424652, 0, 0.3535533845424652, 0, 0.3535533845424652, -0.5 );",
+    "const mat3 g4 = mat3( 0, -0.5, 0, 0.5, 0, 0.5, 0, -0.5, 0 );",
+    "const mat3 g5 = mat3( -0.5, 0, 0.5, 0, 0, 0, 0.5, 0, -0.5 );",
+    "const mat3 g6 = mat3( 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.6666666865348816, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204 );",
+    "const mat3 g7 = mat3( -0.3333333432674408, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, 0.6666666865348816, 0.1666666716337204, -0.3333333432674408, 0.1666666716337204, -0.3333333432674408 );",
+    "const mat3 g8 = mat3( 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408, 0.3333333432674408 );",
+    "void main(void)",
+    "{",
+    "	G[0] = g0,",
+    "	G[1] = g1,",
+    "	G[2] = g2,",
+    "	G[3] = g3,",
+    "	G[4] = g4,",
+    "	G[5] = g5,",
+    "	G[6] = g6,",
+    "	G[7] = g7,",
+    "	G[8] = g8;",
+    "	mat3 I;",
+    "	float cnv[9];",
+    "	vec3 sample;",
+    /* fetch the 3x3 neighbourhood and use the RGB vector's length as intensity value */
+    "	for (float i=0.0; i<3.0; i++) {",
+    "		for (float j=0.0; j<3.0; j++) {",
+    "			sample = texture2D(tDiffuse, vUv + texel * vec2(i-1.0,j-1.0) ).rgb;",
+    "			I[int(i)][int(j)] = length(sample);",
+    "		}",
+    "	}",
+    /* calculate the convolution values for all the masks */
+    "	for (int i=0; i<9; i++) {",
+    "		float dp3 = dot(G[i][0], I[0]) + dot(G[i][1], I[1]) + dot(G[i][2], I[2]);",
+    "		cnv[i] = dp3 * dp3;",
+    "	}",
+    "	float M = (cnv[0] + cnv[1]) + (cnv[2] + cnv[3]);",
+    "	float S = (cnv[4] + cnv[5]) + (cnv[6] + cnv[7]) + (cnv[8] + M);",
+    "	gl_FragColor = vec4(vec3(sqrt(M/S)), 1.0);",
+    "}"
+  ].join("\n")
+};
+export {
+  FreiChenShader
+};

package/dist/shaders/FresnelShader.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Based on Nvidia Cg tutorial
+ */
+export declare const FresnelShader: {
+    uniforms: {
+        mRefractionRatio: {
+            value: number;
+        };
+        mFresnelBias: {
+            value: number;
+        };
+        mFresnelPower: {
+            value: number;
+        };
+        mFresnelScale: {
+            value: number;
+        };
+        tCube: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/FresnelShader.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const FresnelShader = {
+  uniforms: {
+    mRefractionRatio: { value: 1.02 },
+    mFresnelBias: { value: 0.1 },
+    mFresnelPower: { value: 2 },
+    mFresnelScale: { value: 1 },
+    tCube: { value: null }
+  },
+  vertexShader: [
+    "uniform float mRefractionRatio;",
+    "uniform float mFresnelBias;",
+    "uniform float mFresnelScale;",
+    "uniform float mFresnelPower;",
+    "varying vec3 vReflect;",
+    "varying vec3 vRefract[3];",
+    "varying float vReflectionFactor;",
+    "void main() {",
+    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+    "	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+    "	vec3 worldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );",
+    "	vec3 I = worldPosition.xyz - cameraPosition;",
+    "	vReflect = reflect( I, worldNormal );",
+    "	vRefract[0] = refract( normalize( I ), worldNormal, mRefractionRatio );",
+    "	vRefract[1] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.99 );",
+    "	vRefract[2] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.98 );",
+    "	vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), worldNormal ), mFresnelPower );",
+    "	gl_Position = projectionMatrix * mvPosition;",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform samplerCube tCube;",
+    "varying vec3 vReflect;",
+    "varying vec3 vRefract[3];",
+    "varying float vReflectionFactor;",
+    "void main() {",
+    "	vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );",
+    "	vec4 refractedColor = vec4( 1.0 );",
+    "	refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;",
+    "	refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;",
+    "	refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;",
+    "	gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );",
+    "}"
+  ].join("\n")
+};
+exports.FresnelShader = FresnelShader;

package/dist/shaders/FresnelShader.mjs

@@ -0,0 +1,47 @@
+const FresnelShader = {
+  uniforms: {
+    mRefractionRatio: { value: 1.02 },
+    mFresnelBias: { value: 0.1 },
+    mFresnelPower: { value: 2 },
+    mFresnelScale: { value: 1 },
+    tCube: { value: null }
+  },
+  vertexShader: [
+    "uniform float mRefractionRatio;",
+    "uniform float mFresnelBias;",
+    "uniform float mFresnelScale;",
+    "uniform float mFresnelPower;",
+    "varying vec3 vReflect;",
+    "varying vec3 vRefract[3];",
+    "varying float vReflectionFactor;",
+    "void main() {",
+    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+    "	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+    "	vec3 worldNormal = normalize( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );",
+    "	vec3 I = worldPosition.xyz - cameraPosition;",
+    "	vReflect = reflect( I, worldNormal );",
+    "	vRefract[0] = refract( normalize( I ), worldNormal, mRefractionRatio );",
+    "	vRefract[1] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.99 );",
+    "	vRefract[2] = refract( normalize( I ), worldNormal, mRefractionRatio * 0.98 );",
+    "	vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), worldNormal ), mFresnelPower );",
+    "	gl_Position = projectionMatrix * mvPosition;",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform samplerCube tCube;",
+    "varying vec3 vReflect;",
+    "varying vec3 vRefract[3];",
+    "varying float vReflectionFactor;",
+    "void main() {",
+    "	vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );",
+    "	vec4 refractedColor = vec4( 1.0 );",
+    "	refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;",
+    "	refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;",
+    "	refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;",
+    "	gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );",
+    "}"
+  ].join("\n")
+};
+export {
+  FresnelShader
+};

package/dist/shaders/GammaCorrectionShader.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Gamma Correction Shader
+ * http://en.wikipedia.org/wiki/gamma_correction
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types';
+export declare type GammaCorrectionShaderUniforms = {
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface IGammaCorrectionShader extends IShader<GammaCorrectionShaderUniforms> {
+}
+export declare const GammaCorrectionShader: IGammaCorrectionShader;

package/dist/shaders/GammaCorrectionShader.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const GammaCorrectionShader = {
+  uniforms: {
+    tDiffuse: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 tex = texture2D( tDiffuse, vUv );",
+    "	gl_FragColor = LinearTosRGB( tex );",
+    "}"
+  ].join("\n")
+};
+exports.GammaCorrectionShader = GammaCorrectionShader;

package/dist/shaders/GammaCorrectionShader.mjs

@@ -0,0 +1,23 @@
+const GammaCorrectionShader = {
+  uniforms: {
+    tDiffuse: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec4 tex = texture2D( tDiffuse, vUv );",
+    "	gl_FragColor = LinearTosRGB( tex );",
+    "}"
+  ].join("\n")
+};
+export {
+  GammaCorrectionShader
+};