three-stdlib 2.16.0 → 2.16.1

package/shaders/ToonShader.mjs

@@ -1,188 +0,0 @@
-import { Vector3, Color } from "three";
-const ToonShader1 = {
-  uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(15658734) },
-    uAmbientLightColor: { value: new Color(328965) },
-    uBaseColor: { value: new Color(16777215) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "varying vec3 vRefract;",
-    "void main() {",
-    "	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
-    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
-    "	vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "	vec3 I = worldPosition.xyz - cameraPosition;",
-    "	vRefract = refract( normalize( I ), worldNormal, 1.02 );",
-    "	gl_Position = projectionMatrix * mvPosition;",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "varying vec3 vRefract;",
-    "void main() {",
-    "	float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);",
-    "	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "	float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );",
-    "	intensity += length(lightWeighting) * 0.2;",
-    "	float cameraWeighting = dot( normalize( vNormal ), vRefract );",
-    "	intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );",
-    "	intensity = intensity * 0.2 + 0.3;",
-    "	if ( intensity < 0.50 ) {",
-    "		gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );",
-    "	} else {",
-    "		gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );",
-    "}",
-    "}"
-  ].join("\n")
-};
-const ToonShader2 = {
-  uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(15658734) },
-    uAmbientLightColor: { value: new Color(328965) },
-    uBaseColor: { value: new Color(15658734) },
-    uLineColor1: { value: new Color(8421504) },
-    uLineColor2: { value: new Color(0) },
-    uLineColor3: { value: new Color(0) },
-    uLineColor4: { value: new Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);",
-    "	float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);",
-    "	gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "	if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {",
-    "		gl_FragColor *= vec4( uLineColor1, 1.0 );",
-    "	}",
-    "	if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {",
-    "		gl_FragColor *= vec4( uLineColor2, 1.0 );",
-    "	}",
-    "}"
-  ].join("\n")
-};
-const ToonShaderHatching = {
-  uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(15658734) },
-    uAmbientLightColor: { value: new Color(328965) },
-    uBaseColor: { value: new Color(16777215) },
-    uLineColor1: { value: new Color(0) },
-    uLineColor2: { value: new Color(0) },
-    uLineColor3: { value: new Color(0) },
-    uLineColor4: { value: new Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);",
-    "	vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "	gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "	if ( length(lightWeighting) < 1.00 ) {",
-    "		if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.75 ) {",
-    "		if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor2, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.50 ) {",
-    "		if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor3, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.3465 ) {",
-    "		if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {",
-    "			gl_FragColor = vec4( uLineColor4, 1.0 );",
-    "	}",
-    "	}",
-    "}"
-  ].join("\n")
-};
-const ToonShaderDotted = {
-  uniforms: {
-    uDirLightPos: { value: new Vector3() },
-    uDirLightColor: { value: new Color(15658734) },
-    uAmbientLightColor: { value: new Color(328965) },
-    uBaseColor: { value: new Color(16777215) },
-    uLineColor1: { value: new Color(0) }
-  },
-  vertexShader: [
-    "varying vec3 vNormal;",
-    "void main() {",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	vNormal = normalize( normalMatrix * normal );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform vec3 uBaseColor;",
-    "uniform vec3 uLineColor1;",
-    "uniform vec3 uLineColor2;",
-    "uniform vec3 uLineColor3;",
-    "uniform vec3 uLineColor4;",
-    "uniform vec3 uDirLightPos;",
-    "uniform vec3 uDirLightColor;",
-    "uniform vec3 uAmbientLightColor;",
-    "varying vec3 vNormal;",
-    "void main() {",
-    "float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);",
-    "vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
-    "gl_FragColor = vec4( uBaseColor, 1.0 );",
-    "if ( length(lightWeighting) < 1.00 ) {",
-    "		if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "	if ( length(lightWeighting) < 0.50 ) {",
-    "		if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {",
-    "			gl_FragColor = vec4( uLineColor1, 1.0 );",
-    "		}",
-    "	}",
-    "}"
-  ].join("\n")
-};
-export {
-  ToonShader1,
-  ToonShader2,
-  ToonShaderDotted,
-  ToonShaderHatching
-};

package/shaders/TriangleBlurShader.mjs

@@ -1,36 +0,0 @@
-import { Vector2 } from "three";
-const TriangleBlurShader = {
-  uniforms: {
-    texture: { value: null },
-    delta: { value: new Vector2(1, 1) }
-  },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "#include <common>",
-    "#define ITERATIONS 10.0",
-    "uniform sampler2D texture;",
-    "uniform vec2 delta;",
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vec4 color = vec4( 0.0 );",
-    "	float total = 0.0;",
-    "	float offset = rand( vUv );",
-    "	for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {",
-    "		float percent = ( t + offset - 0.5 ) / ITERATIONS;",
-    "		float weight = 1.0 - abs( percent );",
-    "		color += texture2D( texture, vUv + delta * percent ) * weight;",
-    "		total += weight;",
-    "	}",
-    "	gl_FragColor = color / total;",
-    "}"
-  ].join("\n")
-};
-export {
-  TriangleBlurShader
-};

package/shaders/UnpackDepthRGBAShader.mjs

@@ -1,26 +0,0 @@
-const UnpackDepthRGBAShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    opacity: { value: 1 }
-  },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "uniform float opacity;",
-    "uniform sampler2D tDiffuse;",
-    "varying vec2 vUv;",
-    "#include <packing>",
-    "void main() {",
-    "	float depth = 1.0 - unpackRGBAToDepth( texture2D( tDiffuse, vUv ) );",
-    "	gl_FragColor = vec4( vec3( depth ), opacity );",
-    "}"
-  ].join("\n")
-};
-export {
-  UnpackDepthRGBAShader
-};

package/shaders/VerticalBlurShader.mjs

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

package/shaders/VerticalTiltShiftShader.mjs

@@ -1,37 +0,0 @@
-const VerticalTiltShiftShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    v: { value: 1 / 512 },
-    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")
-};
-export {
-  VerticalTiltShiftShader
-};

package/shaders/VignetteShader.mjs

@@ -1,28 +0,0 @@
-const VignetteShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    offset: { value: 1 },
-    darkness: { value: 1 }
-  },
-  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")
-};
-export {
-  VignetteShader
-};

package/shaders/VolumeShader.mjs

@@ -1,178 +0,0 @@
-import { Vector3, Vector2 } from "three";
-const VolumeRenderShader1 = {
-  uniforms: {
-    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")
-};
-export {
-  VolumeRenderShader1
-};

package/shaders/WaterRefractionShader.mjs

@@ -1,57 +0,0 @@
-const WaterRefractionShader = {
-  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() {",
-    "	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")
-};
-export {
-  WaterRefractionShader
-};

package/textures/FlakesTexture.mjs

@@ -1,30 +0,0 @@
-class FlakesTexture {
-  constructor(width = 512, height = 512) {
-    const canvas = document.createElement("canvas");
-    canvas.width = width;
-    canvas.height = height;
-    const context = canvas.getContext("2d");
-    context.fillStyle = "rgb(127,127,255)";
-    context.fillRect(0, 0, width, height);
-    for (let i = 0; i < 4e3; i++) {
-      const x = Math.random() * width;
-      const y = Math.random() * height;
-      const r = Math.random() * 3 + 3;
-      let nx = Math.random() * 2 - 1;
-      let ny = Math.random() * 2 - 1;
-      let nz = 1.5;
-      const l = Math.sqrt(nx * nx + ny * ny + nz * nz);
-      nx /= l;
-      ny /= l;
-      nz /= l;
-      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;
-  }
-}
-export {
-  FlakesTexture
-};

package/types/helpers.mjs

@@ -1,4 +0,0 @@
-const getWithKey = (obj, key) => obj[key];
-export {
-  getWithKey
-};