three-stdlib 2.15.2 → 2.16.1

package/shaders/VerticalBlurShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const v={uniforms:{tDiffuse:{value:null},v:{value:1/512}},vertexShader:"\n    varying vec2 vUv;\n\n    void main() {\n\n      vUv = uv;\n      gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n    }\n  ",fragmentShader:"\n\n  uniform sampler2D tDiffuse;\n  uniform float v;\n\n  varying vec2 vUv;\n\n  void main() {\n\n    vec4 sum = vec4( 0.0 );\n\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * v ) ) * 0.051;\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * v ) ) * 0.0918;\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * v ) ) * 0.12245;\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * v ) ) * 0.1531;\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * v ) ) * 0.1531;\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * v ) ) * 0.12245;\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * v ) ) * 0.0918;\n    sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * v ) ) * 0.051;\n\n    gl_FragColor = sum;\n\n  }\n  "};exports.VerticalBlurShader=v;

package/shaders/VerticalBlurShader.js

@@ -1,11 +1,24 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * Two pass Gaussian blur filter (horizontal and vertical blur shaders)
+ * - described in http://www.gamerendering.com/2008/10/11/gaussian-blur-filter-shader/
+ *   and used in http://www.cake23.de/traveling-wavefronts-lit-up.html
+ *
+ * - 9 samples per pass
+ * - standard deviation 2.7
+ * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
+ */
 const VerticalBlurShader = {
   uniforms: {
-    tDiffuse: { value: null },
-    v: { value: 1 / 512 }
+    tDiffuse: {
+      value: null
+    },
+    v: {
+      value: 1.0 / 512.0
+    }
   },
-  vertexShader: `
+  vertexShader:
+  /* glsl */
+  `
     varying vec2 vUv;
 
     void main() {
@@ -15,7 +28,9 @@ const VerticalBlurShader = {
 
     }
   `,
-  fragmentShader: `
+  fragmentShader:
+  /* glsl */
+  `
 
   uniform sampler2D tDiffuse;
   uniform float v;
@@ -41,4 +56,5 @@ const VerticalBlurShader = {
   }
   `
 };
-exports.VerticalBlurShader = VerticalBlurShader;
+
+export { VerticalBlurShader };

package/shaders/VerticalTiltShiftShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const v={uniforms:{tDiffuse:{value:null},v:{value:1/512},r:{value:.35}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform float v;","uniform float r;","varying vec2 vUv;","void main() {","\tvec4 sum = vec4( 0.0 );","\tfloat vv = v * abs( r - vUv.y );","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;","\tsum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;","\tgl_FragColor = sum;","}"].join("\n")};exports.VerticalTiltShiftShader=v;

package/shaders/VerticalTiltShiftShader.js

@@ -1,37 +1,25 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * Simple fake tilt-shift effect, modulating two pass Gaussian blur (see above) by vertical position
+ *
+ * - 9 samples per pass
+ * - standard deviation 2.7
+ * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
+ * - "r" parameter control where "focused" horizontal line lies
+ */
 const VerticalTiltShiftShader = {
   uniforms: {
-    tDiffuse: { value: null },
-    v: { value: 1 / 512 },
-    r: { value: 0.35 }
+    tDiffuse: {
+      value: null
+    },
+    v: {
+      value: 1.0 / 512.0
+    },
+    r: {
+      value: 0.35
+    }
   },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform sampler2D tDiffuse;",
-    "uniform float v;",
-    "uniform float r;",
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vec4 sum = vec4( 0.0 );",
-    "	float vv = v * abs( r - vUv.y );",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;",
-    "	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;",
-    "	gl_FragColor = sum;",
-    "}"
-  ].join("\n")
+  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
+  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform float v;', 'uniform float r;', 'varying vec2 vUv;', 'void main() {', '	vec4 sum = vec4( 0.0 );', '	float vv = v * abs( r - vUv.y );', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y ) ) * 0.1633;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;', '	sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;', '	gl_FragColor = sum;', '}'].join('\n')
 };
-exports.VerticalTiltShiftShader = VerticalTiltShiftShader;
+
+export { VerticalTiltShiftShader };

package/shaders/VignetteShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},offset:{value:1},darkness:{value:1}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform float offset;","uniform float darkness;","uniform sampler2D tDiffuse;","varying vec2 vUv;","void main() {","\tvec4 texel = texture2D( tDiffuse, vUv );","\tvec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );","\tgl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );","}"].join("\n")};exports.VignetteShader=e;

package/shaders/VignetteShader.js

@@ -1,28 +1,32 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * Vignette shader
+ * based on PaintEffect postprocess from ro.me
+ * http://code.google.com/p/3-dreams-of-black/source/browse/deploy/js/effects/PaintEffect.js
+ */
 const VignetteShader = {
   uniforms: {
-    tDiffuse: { value: null },
-    offset: { value: 1 },
-    darkness: { value: 1 }
+    tDiffuse: {
+      value: null
+    },
+    offset: {
+      value: 1.0
+    },
+    darkness: {
+      value: 1.0
+    }
   },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform float offset;",
-    "uniform float darkness;",
-    "uniform sampler2D tDiffuse;",
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vec4 texel = texture2D( tDiffuse, vUv );",
-    "	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );",
-    "	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );",
-    "}"
-  ].join("\n")
+  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
+  fragmentShader: ['uniform float offset;', 'uniform float darkness;', 'uniform sampler2D tDiffuse;', 'varying vec2 vUv;', 'void main() {', // Eskil's vignette
+  '	vec4 texel = texture2D( tDiffuse, vUv );', '	vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );', '	gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );',
+  /*
+  // alternative version from glfx.js
+  // this one makes more "dusty" look (as opposed to "burned")
+  "	vec4 color = texture2D( tDiffuse, vUv );",
+  "	float dist = distance( vUv, vec2( 0.5 ) );",
+  "	color.rgb *= smoothstep( 0.8, offset * 0.799, dist *( darkness + offset ) );",
+  "	gl_FragColor = color;",
+  */
+  '}'].join('\n')
 };
-exports.VignetteShader = VignetteShader;
+
+export { VignetteShader };

package/shaders/VolumeShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("three");const e={uniforms:{u_size:{value:new t.Vector3(1,1,1)},u_renderstyle:{value:0},u_renderthreshold:{value:.5},u_clim:{value:new t.Vector2(1,1)},u_data:{value:null},u_cmdata:{value:null}},vertexShader:["\t\tvarying vec4 v_nearpos;","\t\tvarying vec4 v_farpos;","\t\tvarying vec3 v_position;","\t\tvoid main() {","\t\t\t\tmat4 viewtransformf = modelViewMatrix;","\t\t\t\tmat4 viewtransformi = inverse(modelViewMatrix);","\t\t\t\tvec4 position4 = vec4(position, 1.0);","\t\t\t\tvec4 pos_in_cam = viewtransformf * position4;","\t\t\t\tpos_in_cam.z = -pos_in_cam.w;","\t\t\t\tv_nearpos = viewtransformi * pos_in_cam;","\t\t\t\tpos_in_cam.z = pos_in_cam.w;","\t\t\t\tv_farpos = viewtransformi * pos_in_cam;","\t\t\t\tv_position = position;","\t\t\t\tgl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;","\t\t}"].join("\n"),fragmentShader:["\t\tprecision highp float;","\t\tprecision mediump sampler3D;","\t\tuniform vec3 u_size;","\t\tuniform int u_renderstyle;","\t\tuniform float u_renderthreshold;","\t\tuniform vec2 u_clim;","\t\tuniform sampler3D u_data;","\t\tuniform sampler2D u_cmdata;","\t\tvarying vec3 v_position;","\t\tvarying vec4 v_nearpos;","\t\tvarying vec4 v_farpos;","\t\tconst int MAX_STEPS = 887;\t// 887 for 512^3, 1774 for 1024^3","\t\tconst int REFINEMENT_STEPS = 4;","\t\tconst float relative_step_size = 1.0;","\t\tconst vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);","\t\tconst vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);","\t\tconst vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);","\t\tconst float shininess = 40.0;","\t\tvoid cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);","\t\tvoid cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);","\t\tfloat sample1(vec3 texcoords);","\t\tvec4 apply_colormap(float val);","\t\tvec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);","\t\tvoid main() {","\t\t\t\tvec3 farpos = v_farpos.xyz / v_farpos.w;","\t\t\t\tvec3 nearpos = v_nearpos.xyz / v_nearpos.w;","\t\t\t\tvec3 view_ray = normalize(nearpos.xyz - farpos.xyz);","\t\t\t\tfloat distance = dot(nearpos - v_position, view_ray);","\t\t\t\tdistance = max(distance, min((-0.5 - v_position.x) / view_ray.x,","\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t(u_size.x - 0.5 - v_position.x) / view_ray.x));","\t\t\t\tdistance = max(distance, min((-0.5 - v_position.y) / view_ray.y,","\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t(u_size.y - 0.5 - v_position.y) / view_ray.y));","\t\t\t\tdistance = max(distance, min((-0.5 - v_position.z) / view_ray.z,","\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t(u_size.z - 0.5 - v_position.z) / view_ray.z));","\t\t\t\tvec3 front = v_position + view_ray * distance;","\t\t\t\tint nsteps = int(-distance / relative_step_size + 0.5);","\t\t\t\tif ( nsteps < 1 )","\t\t\t\t\t\tdiscard;","\t\t\t\tvec3 step = ((v_position - front) / u_size) / float(nsteps);","\t\t\t\tvec3 start_loc = front / u_size;","\t\t\t\tif (u_renderstyle == 0)","\t\t\t\t\t\tcast_mip(start_loc, step, nsteps, view_ray);","\t\t\t\telse if (u_renderstyle == 1)","\t\t\t\t\t\tcast_iso(start_loc, step, nsteps, view_ray);","\t\t\t\tif (gl_FragColor.a < 0.05)","\t\t\t\t\t\tdiscard;","\t\t}","\t\tfloat sample1(vec3 texcoords) {","\t\t\t\t/* Sample float value from a 3D texture. Assumes intensity data. */","\t\t\t\treturn texture(u_data, texcoords.xyz).r;","\t\t}","\t\tvec4 apply_colormap(float val) {","\t\t\t\tval = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);","\t\t\t\treturn texture2D(u_cmdata, vec2(val, 0.5));","\t\t}","\t\tvoid cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {","\t\t\t\tfloat max_val = -1e6;","\t\t\t\tint max_i = 100;","\t\t\t\tvec3 loc = start_loc;","\t\t\t\tfor (int iter=0; iter<MAX_STEPS; iter++) {","\t\t\t\t\t\tif (iter >= nsteps)","\t\t\t\t\t\t\t\tbreak;","\t\t\t\t\t\tfloat val = sample1(loc);","\t\t\t\t\t\tif (val > max_val) {","\t\t\t\t\t\t\t\tmax_val = val;","\t\t\t\t\t\t\t\tmax_i = iter;","\t\t\t\t\t\t}","\t\t\t\t\t\tloc += step;","\t\t\t\t}","\t\t\t\tvec3 iloc = start_loc + step * (float(max_i) - 0.5);","\t\t\t\tvec3 istep = step / float(REFINEMENT_STEPS);","\t\t\t\tfor (int i=0; i<REFINEMENT_STEPS; i++) {","\t\t\t\t\t\tmax_val = max(max_val, sample1(iloc));","\t\t\t\t\t\tiloc += istep;","\t\t\t\t}","\t\t\t\tgl_FragColor = apply_colormap(max_val);","\t\t}","\t\tvoid cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {","\t\t\t\tgl_FragColor = vec4(0.0);\t// init transparent","\t\t\t\tvec4 color3 = vec4(0.0);\t// final color","\t\t\t\tvec3 dstep = 1.5 / u_size;\t// step to sample derivative","\t\t\t\tvec3 loc = start_loc;","\t\t\t\tfloat low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);","\t\t\t\tfor (int iter=0; iter<MAX_STEPS; iter++) {","\t\t\t\t\t\tif (iter >= nsteps)","\t\t\t\t\t\t\t\tbreak;","\t\t\t\t\t\tfloat val = sample1(loc);","\t\t\t\t\t\tif (val > low_threshold) {","\t\t\t\t\t\t\t\tvec3 iloc = loc - 0.5 * step;","\t\t\t\t\t\t\t\tvec3 istep = step / float(REFINEMENT_STEPS);","\t\t\t\t\t\t\t\tfor (int i=0; i<REFINEMENT_STEPS; i++) {","\t\t\t\t\t\t\t\t\t\tval = sample1(iloc);","\t\t\t\t\t\t\t\t\t\tif (val > u_renderthreshold) {","\t\t\t\t\t\t\t\t\t\t\t\tgl_FragColor = add_lighting(val, iloc, dstep, view_ray);","\t\t\t\t\t\t\t\t\t\t\t\treturn;","\t\t\t\t\t\t\t\t\t\t}","\t\t\t\t\t\t\t\t\t\tiloc += istep;","\t\t\t\t\t\t\t\t}","\t\t\t\t\t\t}","\t\t\t\t\t\tloc += step;","\t\t\t\t}","\t\t}","\t\tvec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)","\t\t{","\t\t\t\tvec3 V = normalize(view_ray);","\t\t\t\tvec3 N;","\t\t\t\tfloat val1, val2;","\t\t\t\tval1 = sample1(loc + vec3(-step[0], 0.0, 0.0));","\t\t\t\tval2 = sample1(loc + vec3(+step[0], 0.0, 0.0));","\t\t\t\tN[0] = val1 - val2;","\t\t\t\tval = max(max(val1, val2), val);","\t\t\t\tval1 = sample1(loc + vec3(0.0, -step[1], 0.0));","\t\t\t\tval2 = sample1(loc + vec3(0.0, +step[1], 0.0));","\t\t\t\tN[1] = val1 - val2;","\t\t\t\tval = max(max(val1, val2), val);","\t\t\t\tval1 = sample1(loc + vec3(0.0, 0.0, -step[2]));","\t\t\t\tval2 = sample1(loc + vec3(0.0, 0.0, +step[2]));","\t\t\t\tN[2] = val1 - val2;","\t\t\t\tval = max(max(val1, val2), val);","\t\t\t\tfloat gm = length(N); // gradient magnitude","\t\t\t\tN = normalize(N);","\t\t\t\tfloat Nselect = float(dot(N, V) > 0.0);","\t\t\t\tN = (2.0 * Nselect - 1.0) * N;\t// ==\tNselect * N - (1.0-Nselect)*N;","\t\t\t\tvec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);","\t\t\t\tvec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);","\t\t\t\tvec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);","\t\t\t\tfor (int i=0; i<1; i++)","\t\t\t\t{","\t\t\t\t\t\tvec3 L = normalize(view_ray);\t//lightDirs[i];","\t\t\t\t\t\tfloat lightEnabled = float( length(L) > 0.0 );","\t\t\t\t\t\tL = normalize(L + (1.0 - lightEnabled));","\t\t\t\t\t\tfloat lambertTerm = clamp(dot(N, L), 0.0, 1.0);","\t\t\t\t\t\tvec3 H = normalize(L+V); // Halfway vector","\t\t\t\t\t\tfloat specularTerm = pow(max(dot(H, N), 0.0), shininess);","\t\t\t\t\t\tfloat mask1 = lightEnabled;","\t\t\t\t\t\tambient_color +=\tmask1 * ambient_color;\t// * gl_LightSource[i].ambient;","\t\t\t\t\t\tdiffuse_color +=\tmask1 * lambertTerm;","\t\t\t\t\t\tspecular_color += mask1 * specularTerm * specular_color;","\t\t\t\t}","\t\t\t\tvec4 final_color;","\t\t\t\tvec4 color = apply_colormap(val);","\t\t\t\tfinal_color = color * (ambient_color + diffuse_color) + specular_color;","\t\t\t\tfinal_color.a = color.a;","\t\t\t\treturn final_color;","\t\t}"].join("\n")};exports.VolumeRenderShader1=e;

package/shaders/VolumeShader.js

@@ -1,178 +1,81 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import { Vector3, Vector2 } from 'three';
+
+/**
+ * Shaders to render 3D volumes using raycasting.
+ * The applied techniques are based on similar implementations in the Visvis and Vispy projects.
+ * This is not the only approach, therefore it's marked 1.
+ */
+
 const VolumeRenderShader1 = {
   uniforms: {
-    u_size: { value: new THREE.Vector3(1, 1, 1) },
-    u_renderstyle: { value: 0 },
-    u_renderthreshold: { value: 0.5 },
-    u_clim: { value: new THREE.Vector2(1, 1) },
-    u_data: { value: null },
-    u_cmdata: { value: null }
+    u_size: {
+      value: new Vector3(1, 1, 1)
+    },
+    u_renderstyle: {
+      value: 0
+    },
+    u_renderthreshold: {
+      value: 0.5
+    },
+    u_clim: {
+      value: new Vector2(1, 1)
+    },
+    u_data: {
+      value: null
+    },
+    u_cmdata: {
+      value: null
+    }
   },
-  vertexShader: [
-    "		varying vec4 v_nearpos;",
-    "		varying vec4 v_farpos;",
-    "		varying vec3 v_position;",
-    "		void main() {",
-    "				mat4 viewtransformf = modelViewMatrix;",
-    "				mat4 viewtransformi = inverse(modelViewMatrix);",
-    "				vec4 position4 = vec4(position, 1.0);",
-    "				vec4 pos_in_cam = viewtransformf * position4;",
-    "				pos_in_cam.z = -pos_in_cam.w;",
-    "				v_nearpos = viewtransformi * pos_in_cam;",
-    "				pos_in_cam.z = pos_in_cam.w;",
-    "				v_farpos = viewtransformi * pos_in_cam;",
-    "				v_position = position;",
-    "				gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;",
-    "		}"
-  ].join("\n"),
-  fragmentShader: [
-    "		precision highp float;",
-    "		precision mediump sampler3D;",
-    "		uniform vec3 u_size;",
-    "		uniform int u_renderstyle;",
-    "		uniform float u_renderthreshold;",
-    "		uniform vec2 u_clim;",
-    "		uniform sampler3D u_data;",
-    "		uniform sampler2D u_cmdata;",
-    "		varying vec3 v_position;",
-    "		varying vec4 v_nearpos;",
-    "		varying vec4 v_farpos;",
-    "		const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3",
-    "		const int REFINEMENT_STEPS = 4;",
-    "		const float relative_step_size = 1.0;",
-    "		const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);",
-    "		const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);",
-    "		const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);",
-    "		const float shininess = 40.0;",
-    "		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);",
-    "		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);",
-    "		float sample1(vec3 texcoords);",
-    "		vec4 apply_colormap(float val);",
-    "		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);",
-    "		void main() {",
-    "				vec3 farpos = v_farpos.xyz / v_farpos.w;",
-    "				vec3 nearpos = v_nearpos.xyz / v_nearpos.w;",
-    "				vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);",
-    "				float distance = dot(nearpos - v_position, view_ray);",
-    "				distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,",
-    "																		(u_size.x - 0.5 - v_position.x) / view_ray.x));",
-    "				distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,",
-    "																		(u_size.y - 0.5 - v_position.y) / view_ray.y));",
-    "				distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,",
-    "																		(u_size.z - 0.5 - v_position.z) / view_ray.z));",
-    "				vec3 front = v_position + view_ray * distance;",
-    "				int nsteps = int(-distance / relative_step_size + 0.5);",
-    "				if ( nsteps < 1 )",
-    "						discard;",
-    "				vec3 step = ((v_position - front) / u_size) / float(nsteps);",
-    "				vec3 start_loc = front / u_size;",
-    "				if (u_renderstyle == 0)",
-    "						cast_mip(start_loc, step, nsteps, view_ray);",
-    "				else if (u_renderstyle == 1)",
-    "						cast_iso(start_loc, step, nsteps, view_ray);",
-    "				if (gl_FragColor.a < 0.05)",
-    "						discard;",
-    "		}",
-    "		float sample1(vec3 texcoords) {",
-    "				/* Sample float value from a 3D texture. Assumes intensity data. */",
-    "				return texture(u_data, texcoords.xyz).r;",
-    "		}",
-    "		vec4 apply_colormap(float val) {",
-    "				val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);",
-    "				return texture2D(u_cmdata, vec2(val, 0.5));",
-    "		}",
-    "		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {",
-    "				float max_val = -1e6;",
-    "				int max_i = 100;",
-    "				vec3 loc = start_loc;",
-    "				for (int iter=0; iter<MAX_STEPS; iter++) {",
-    "						if (iter >= nsteps)",
-    "								break;",
-    "						float val = sample1(loc);",
-    "						if (val > max_val) {",
-    "								max_val = val;",
-    "								max_i = iter;",
-    "						}",
-    "						loc += step;",
-    "				}",
-    "				vec3 iloc = start_loc + step * (float(max_i) - 0.5);",
-    "				vec3 istep = step / float(REFINEMENT_STEPS);",
-    "				for (int i=0; i<REFINEMENT_STEPS; i++) {",
-    "						max_val = max(max_val, sample1(iloc));",
-    "						iloc += istep;",
-    "				}",
-    "				gl_FragColor = apply_colormap(max_val);",
-    "		}",
-    "		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {",
-    "				gl_FragColor = vec4(0.0);	// init transparent",
-    "				vec4 color3 = vec4(0.0);	// final color",
-    "				vec3 dstep = 1.5 / u_size;	// step to sample derivative",
-    "				vec3 loc = start_loc;",
-    "				float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);",
-    "				for (int iter=0; iter<MAX_STEPS; iter++) {",
-    "						if (iter >= nsteps)",
-    "								break;",
-    "						float val = sample1(loc);",
-    "						if (val > low_threshold) {",
-    "								vec3 iloc = loc - 0.5 * step;",
-    "								vec3 istep = step / float(REFINEMENT_STEPS);",
-    "								for (int i=0; i<REFINEMENT_STEPS; i++) {",
-    "										val = sample1(iloc);",
-    "										if (val > u_renderthreshold) {",
-    "												gl_FragColor = add_lighting(val, iloc, dstep, view_ray);",
-    "												return;",
-    "										}",
-    "										iloc += istep;",
-    "								}",
-    "						}",
-    "						loc += step;",
-    "				}",
-    "		}",
-    "		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)",
-    "		{",
-    "				vec3 V = normalize(view_ray);",
-    "				vec3 N;",
-    "				float val1, val2;",
-    "				val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));",
-    "				val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));",
-    "				N[0] = val1 - val2;",
-    "				val = max(max(val1, val2), val);",
-    "				val1 = sample1(loc + vec3(0.0, -step[1], 0.0));",
-    "				val2 = sample1(loc + vec3(0.0, +step[1], 0.0));",
-    "				N[1] = val1 - val2;",
-    "				val = max(max(val1, val2), val);",
-    "				val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));",
-    "				val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));",
-    "				N[2] = val1 - val2;",
-    "				val = max(max(val1, val2), val);",
-    "				float gm = length(N); // gradient magnitude",
-    "				N = normalize(N);",
-    "				float Nselect = float(dot(N, V) > 0.0);",
-    "				N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;",
-    "				vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);",
-    "				vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);",
-    "				vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);",
-    "				for (int i=0; i<1; i++)",
-    "				{",
-    "						vec3 L = normalize(view_ray);	//lightDirs[i];",
-    "						float lightEnabled = float( length(L) > 0.0 );",
-    "						L = normalize(L + (1.0 - lightEnabled));",
-    "						float lambertTerm = clamp(dot(N, L), 0.0, 1.0);",
-    "						vec3 H = normalize(L+V); // Halfway vector",
-    "						float specularTerm = pow(max(dot(H, N), 0.0), shininess);",
-    "						float mask1 = lightEnabled;",
-    "						ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;",
-    "						diffuse_color +=	mask1 * lambertTerm;",
-    "						specular_color += mask1 * specularTerm * specular_color;",
-    "				}",
-    "				vec4 final_color;",
-    "				vec4 color = apply_colormap(val);",
-    "				final_color = color * (ambient_color + diffuse_color) + specular_color;",
-    "				final_color.a = color.a;",
-    "				return final_color;",
-    "		}"
-  ].join("\n")
+  vertexShader: ['		varying vec4 v_nearpos;', '		varying vec4 v_farpos;', '		varying vec3 v_position;', '		void main() {', // Prepare transforms to map to "camera view". See also:
+  // https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
+  '				mat4 viewtransformf = modelViewMatrix;', '				mat4 viewtransformi = inverse(modelViewMatrix);', // Project local vertex coordinate to camera position. Then do a step
+  // backward (in cam coords) to the near clipping plane, and project back. Do
+  // the same for the far clipping plane. This gives us all the information we
+  // need to calculate the ray and truncate it to the viewing cone.
+  '				vec4 position4 = vec4(position, 1.0);', '				vec4 pos_in_cam = viewtransformf * position4;', // Intersection of ray and near clipping plane (z = -1 in clip coords)
+  '				pos_in_cam.z = -pos_in_cam.w;', '				v_nearpos = viewtransformi * pos_in_cam;', // Intersection of ray and far clipping plane (z = +1 in clip coords)
+  '				pos_in_cam.z = pos_in_cam.w;', '				v_farpos = viewtransformi * pos_in_cam;', // Set varyings and output pos
+  '				v_position = position;', '				gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;', '		}'].join('\n'),
+  fragmentShader: ['		precision highp float;', '		precision mediump sampler3D;', '		uniform vec3 u_size;', '		uniform int u_renderstyle;', '		uniform float u_renderthreshold;', '		uniform vec2 u_clim;', '		uniform sampler3D u_data;', '		uniform sampler2D u_cmdata;', '		varying vec3 v_position;', '		varying vec4 v_nearpos;', '		varying vec4 v_farpos;', // The maximum distance through our rendering volume is sqrt(3).
+  '		const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3', '		const int REFINEMENT_STEPS = 4;', '		const float relative_step_size = 1.0;', '		const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);', '		const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);', '		const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);', '		const float shininess = 40.0;', '		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);', '		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);', '		float sample1(vec3 texcoords);', '		vec4 apply_colormap(float val);', '		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);', '		void main() {', // Normalize clipping plane info
+  '				vec3 farpos = v_farpos.xyz / v_farpos.w;', '				vec3 nearpos = v_nearpos.xyz / v_nearpos.w;', // Calculate unit vector pointing in the view direction through this fragment.
+  '				vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);', // Compute the (negative) distance to the front surface or near clipping plane.
+  // v_position is the back face of the cuboid, so the initial distance calculated in the dot
+  // product below is the distance from near clip plane to the back of the cuboid
+  '				float distance = dot(nearpos - v_position, view_ray);', '				distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,', '																		(u_size.x - 0.5 - v_position.x) / view_ray.x));', '				distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,', '																		(u_size.y - 0.5 - v_position.y) / view_ray.y));', '				distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,', '																		(u_size.z - 0.5 - v_position.z) / view_ray.z));', // Now we have the starting position on the front surface
+  '				vec3 front = v_position + view_ray * distance;', // Decide how many steps to take
+  '				int nsteps = int(-distance / relative_step_size + 0.5);', '				if ( nsteps < 1 )', '						discard;', // Get starting location and step vector in texture coordinates
+  '				vec3 step = ((v_position - front) / u_size) / float(nsteps);', '				vec3 start_loc = front / u_size;', // For testing: show the number of steps. This helps to establish
+  // whether the rays are correctly oriented
+  //'gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);',
+  //'return;',
+  '				if (u_renderstyle == 0)', '						cast_mip(start_loc, step, nsteps, view_ray);', '				else if (u_renderstyle == 1)', '						cast_iso(start_loc, step, nsteps, view_ray);', '				if (gl_FragColor.a < 0.05)', '						discard;', '		}', '		float sample1(vec3 texcoords) {', '				/* Sample float value from a 3D texture. Assumes intensity data. */', '				return texture(u_data, texcoords.xyz).r;', '		}', '		vec4 apply_colormap(float val) {', '				val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);', '				return texture2D(u_cmdata, vec2(val, 0.5));', '		}', '		void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {', '				float max_val = -1e6;', '				int max_i = 100;', '				vec3 loc = start_loc;', // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+  // non-constant expression. So we use a hard-coded max, and an additional condition
+  // inside the loop.
+  '				for (int iter=0; iter<MAX_STEPS; iter++) {', '						if (iter >= nsteps)', '								break;', // Sample from the 3D texture
+  '						float val = sample1(loc);', // Apply MIP operation
+  '						if (val > max_val) {', '								max_val = val;', '								max_i = iter;', '						}', // Advance location deeper into the volume
+  '						loc += step;', '				}', // Refine location, gives crispier images
+  '				vec3 iloc = start_loc + step * (float(max_i) - 0.5);', '				vec3 istep = step / float(REFINEMENT_STEPS);', '				for (int i=0; i<REFINEMENT_STEPS; i++) {', '						max_val = max(max_val, sample1(iloc));', '						iloc += istep;', '				}', // Resolve final color
+  '				gl_FragColor = apply_colormap(max_val);', '		}', '		void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {', '				gl_FragColor = vec4(0.0);	// init transparent', '				vec4 color3 = vec4(0.0);	// final color', '				vec3 dstep = 1.5 / u_size;	// step to sample derivative', '				vec3 loc = start_loc;', '				float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);', // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+  // non-constant expression. So we use a hard-coded max, and an additional condition
+  // inside the loop.
+  '				for (int iter=0; iter<MAX_STEPS; iter++) {', '						if (iter >= nsteps)', '								break;', // Sample from the 3D texture
+  '						float val = sample1(loc);', '						if (val > low_threshold) {', // Take the last interval in smaller steps
+  '								vec3 iloc = loc - 0.5 * step;', '								vec3 istep = step / float(REFINEMENT_STEPS);', '								for (int i=0; i<REFINEMENT_STEPS; i++) {', '										val = sample1(iloc);', '										if (val > u_renderthreshold) {', '												gl_FragColor = add_lighting(val, iloc, dstep, view_ray);', '												return;', '										}', '										iloc += istep;', '								}', '						}', // Advance location deeper into the volume
+  '						loc += step;', '				}', '		}', '		vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)', '		{', // Calculate color by incorporating lighting
+  // View direction
+  '				vec3 V = normalize(view_ray);', // calculate normal vector from gradient
+  '				vec3 N;', '				float val1, val2;', '				val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));', '				val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));', '				N[0] = val1 - val2;', '				val = max(max(val1, val2), val);', '				val1 = sample1(loc + vec3(0.0, -step[1], 0.0));', '				val2 = sample1(loc + vec3(0.0, +step[1], 0.0));', '				N[1] = val1 - val2;', '				val = max(max(val1, val2), val);', '				val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));', '				val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));', '				N[2] = val1 - val2;', '				val = max(max(val1, val2), val);', '				float gm = length(N); // gradient magnitude', '				N = normalize(N);', // Flip normal so it points towards viewer
+  '				float Nselect = float(dot(N, V) > 0.0);', '				N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;', // Init colors
+  '				vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);', '				vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);', '				vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);', // note: could allow multiple lights
+  '				for (int i=0; i<1; i++)', '				{', // Get light direction (make sure to prevent zero devision)
+  '						vec3 L = normalize(view_ray);	//lightDirs[i];', '						float lightEnabled = float( length(L) > 0.0 );', '						L = normalize(L + (1.0 - lightEnabled));', // Calculate lighting properties
+  '						float lambertTerm = clamp(dot(N, L), 0.0, 1.0);', '						vec3 H = normalize(L+V); // Halfway vector', '						float specularTerm = pow(max(dot(H, N), 0.0), shininess);', // Calculate mask
+  '						float mask1 = lightEnabled;', // Calculate colors
+  '						ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;', '						diffuse_color +=	mask1 * lambertTerm;', '						specular_color += mask1 * specularTerm * specular_color;', '				}', // Calculate final color by componing different components
+  '				vec4 final_color;', '				vec4 color = apply_colormap(val);', '				final_color = color * (ambient_color + diffuse_color) + specular_color;', '				final_color.a = color.a;', '				return final_color;', '		}'].join('\n')
 };
-exports.VolumeRenderShader1 = VolumeRenderShader1;
+
+export { VolumeRenderShader1 };

package/shaders/WaterRefractionShader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{color:{value:null},time:{value:0},tDiffuse:{value:null},tDudv:{value:null},textureMatrix:{value:null}},vertexShader:["uniform mat4 textureMatrix;","varying vec2 vUv;","varying vec4 vUvRefraction;","void main() {","\tvUv = uv;","\tvUvRefraction = textureMatrix * vec4( position, 1.0 );","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform vec3 color;","uniform float time;","uniform sampler2D tDiffuse;","uniform sampler2D tDudv;","varying vec2 vUv;","varying vec4 vUvRefraction;","float blendOverlay( float base, float blend ) {","\treturn( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );","}","vec3 blendOverlay( vec3 base, vec3 blend ) {","\treturn vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );","}","void main() {"," float waveStrength = 0.1;"," float waveSpeed = 0.03;","\tvec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;","\tdistortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );","\tvec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;"," vec4 uv = vec4( vUvRefraction );"," uv.xy += distortion;","\tvec4 base = texture2DProj( tDiffuse, uv );","\tgl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );","}"].join("\n")};exports.WaterRefractionShader=e;

package/shaders/WaterRefractionShader.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const WaterRefractionShader = {
   uniforms: {
     color: {
@@ -18,40 +16,10 @@ const WaterRefractionShader = {
       value: null
     }
   },
-  vertexShader: [
-    "uniform mat4 textureMatrix;",
-    "varying vec2 vUv;",
-    "varying vec4 vUvRefraction;",
-    "void main() {",
-    "	vUv = uv;",
-    "	vUvRefraction = textureMatrix * vec4( position, 1.0 );",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 color;",
-    "uniform float time;",
-    "uniform sampler2D tDiffuse;",
-    "uniform sampler2D tDudv;",
-    "varying vec2 vUv;",
-    "varying vec4 vUvRefraction;",
-    "float blendOverlay( float base, float blend ) {",
-    "	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );",
-    "}",
-    "vec3 blendOverlay( vec3 base, vec3 blend ) {",
-    "	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );",
-    "}",
-    "void main() {",
-    " float waveStrength = 0.1;",
-    " float waveSpeed = 0.03;",
-    "	vec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;",
-    "	distortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );",
-    "	vec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;",
-    " vec4 uv = vec4( vUvRefraction );",
-    " uv.xy += distortion;",
-    "	vec4 base = texture2DProj( tDiffuse, uv );",
-    "	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );",
-    "}"
-  ].join("\n")
+  vertexShader: ['uniform mat4 textureMatrix;', 'varying vec2 vUv;', 'varying vec4 vUvRefraction;', 'void main() {', '	vUv = uv;', '	vUvRefraction = textureMatrix * vec4( position, 1.0 );', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
+  fragmentShader: ['uniform vec3 color;', 'uniform float time;', 'uniform sampler2D tDiffuse;', 'uniform sampler2D tDudv;', 'varying vec2 vUv;', 'varying vec4 vUvRefraction;', 'float blendOverlay( float base, float blend ) {', '	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );', '}', 'vec3 blendOverlay( vec3 base, vec3 blend ) {', '	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ),blendOverlay( base.b, blend.b ) );', '}', 'void main() {', ' float waveStrength = 0.1;', ' float waveSpeed = 0.03;', // simple distortion (ripple) via dudv map (see https://www.youtube.com/watch?v=6B7IF6GOu7s)
+  '	vec2 distortedUv = texture2D( tDudv, vec2( vUv.x + time * waveSpeed, vUv.y ) ).rg * waveStrength;', '	distortedUv = vUv.xy + vec2( distortedUv.x, distortedUv.y + time * waveSpeed );', '	vec2 distortion = ( texture2D( tDudv, distortedUv ).rg * 2.0 - 1.0 ) * waveStrength;', // new uv coords
+  ' vec4 uv = vec4( vUvRefraction );', ' uv.xy += distortion;', '	vec4 base = texture2DProj( tDiffuse, uv );', '	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );', '}'].join('\n')
 };
-exports.WaterRefractionShader = WaterRefractionShader;
+
+export { WaterRefractionShader };

package/shaders/types.cjs.js

@@ -0,0 +1 @@
+"use strict";

package/shaders/types.js

@@ -1 +1 @@
-"use strict";
+

package/textures/FlakesTexture.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});exports.FlakesTexture=class{constructor(t=512,e=512){const r=document.createElement("canvas");r.width=t,r.height=e;const a=r.getContext("2d");a.fillStyle="rgb(127,127,255)",a.fillRect(0,0,t,e);for(let r=0;r<4e3;r++){const r=Math.random()*t,o=Math.random()*e,l=3*Math.random()+3;let n=2*Math.random()-1,s=2*Math.random()-1,c=1.5;const h=Math.sqrt(n*n+s*s+c*c);n/=h,s/=h,c/=h,a.fillStyle="rgb("+(127*n+127)+","+(127*s+127)+","+255*c+")",a.beginPath(),a.arc(r,o,l,0,2*Math.PI),a.fill()}return r}};

package/textures/FlakesTexture.js

@@ -1,14 +1,13 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 class FlakesTexture {
   constructor(width = 512, height = 512) {
-    const canvas = document.createElement("canvas");
+    const canvas = document.createElement('canvas');
     canvas.width = width;
     canvas.height = height;
-    const context = canvas.getContext("2d");
-    context.fillStyle = "rgb(127,127,255)";
+    const context = canvas.getContext('2d');
+    context.fillStyle = 'rgb(127,127,255)';
     context.fillRect(0, 0, width, height);
-    for (let i = 0; i < 4e3; i++) {
+
+    for (let i = 0; i < 4000; i++) {
       const x = Math.random() * width;
       const y = Math.random() * height;
       const r = Math.random() * 3 + 3;
@@ -19,12 +18,15 @@ class FlakesTexture {
       nx /= l;
       ny /= l;
       nz /= l;
-      context.fillStyle = "rgb(" + (nx * 127 + 127) + "," + (ny * 127 + 127) + "," + nz * 255 + ")";
+      context.fillStyle = 'rgb(' + (nx * 127 + 127) + ',' + (ny * 127 + 127) + ',' + nz * 255 + ')';
       context.beginPath();
       context.arc(x, y, r, 0, Math.PI * 2);
       context.fill();
     }
+
     return canvas;
   }
+
 }
-exports.FlakesTexture = FlakesTexture;
+
+export { FlakesTexture };

package/types/helpers.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});exports.getWithKey=(e,t)=>e[t];

package/types/helpers.js

@@ -1,4 +1,3 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const getWithKey = (obj, key) => obj[key];
-exports.getWithKey = getWithKey;
+
+export { getWithKey };

package/types/shared.cjs.js

@@ -0,0 +1 @@
+"use strict";

package/types/shared.js

@@ -0,0 +1 @@
+

package/types/utils.cjs.js

@@ -0,0 +1 @@
+"use strict";

package/types/utils.js

@@ -0,0 +1 @@
+

package/utils/BufferGeometryUtils.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("three"),require("../types/helpers.cjs.js");var e=require("../BufferGeometryUtils-971dfde3.js");exports.computeMorphedAttributes=e.computeMorphedAttributes,exports.estimateBytesUsed=e.estimateBytesUsed,exports.interleaveAttributes=e.interleaveAttributes,exports.mergeBufferAttributes=e.mergeBufferAttributes,exports.mergeBufferGeometries=e.mergeBufferGeometries,exports.mergeVertices=e.mergeVertices,exports.toTrianglesDrawMode=e.toTrianglesDrawMode;