three-stdlib 2.22.5 → 2.22.7

package/shaders/VolumeShader.js

@@ -1,81 +0,0 @@
-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 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() {', // 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')
-};
-
-export { VolumeRenderShader1 };

package/shaders/WaterRefractionShader.cjs.js

@@ -1 +0,0 @@
-"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.d.ts

@@ -1,21 +0,0 @@
-export declare const WaterRefractionShader: {
-    uniforms: {
-        color: {
-            value: null;
-        };
-        time: {
-            value: number;
-        };
-        tDiffuse: {
-            value: null;
-        };
-        tDudv: {
-            value: null;
-        };
-        textureMatrix: {
-            value: null;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/WaterRefractionShader.js

@@ -1,25 +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;', // 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')
-};
-
-export { WaterRefractionShader };

package/shaders/types.cjs.js

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

package/shaders/types.d.ts

@@ -1,14 +0,0 @@
-import type { IUniform, Shader } from 'three';
-declare type Defines = {
-    [key: string]: boolean | number | string;
-};
-declare type Uniforms = {
-    [key: string]: IUniform;
-};
-export interface IShader<U extends Uniforms, D extends Defines | undefined = undefined> extends Shader {
-    defines?: D;
-    fragmentShader: string;
-    uniforms: U;
-    vertexShader: string;
-}
-export {};

package/shaders/types.js

@@ -1 +0,0 @@
-

package/textures/FlakesTexture.cjs.js

@@ -1 +0,0 @@
-"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.d.ts

@@ -1,4 +0,0 @@
-declare class FlakesTexture {
-    constructor(width?: number, height?: number);
-}
-export { FlakesTexture };

package/textures/FlakesTexture.js

@@ -1,32 +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 < 4000; 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.cjs.js

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

package/types/helpers.d.ts

@@ -1 +0,0 @@
-export declare const getWithKey: <T, K extends keyof T>(obj: T, key: K) => T[K];

package/types/helpers.js

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

package/types/shared.cjs.js

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

package/types/shared.d.ts

@@ -1,2 +0,0 @@
-export declare type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
-export declare type TypedArrayConstructors = Int8Array['constructor'] | Uint8Array['constructor'] | Uint8ClampedArray['constructor'] | Int16Array['constructor'] | Uint16Array['constructor'] | Int32Array['constructor'] | Uint32Array['constructor'] | Float32Array['constructor'] | Float64Array['constructor'];

package/types/shared.js

@@ -1 +0,0 @@
-

package/types/utils.cjs.js

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

package/types/utils.d.ts

@@ -1,3 +0,0 @@
-export declare type Nullable<T> = {
-    [K in keyof T]: T[K] | null;
-};

package/types/utils.js

@@ -1 +0,0 @@
-

package/utils/BufferGeometryUtils.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("three"),require("../types/helpers.cjs.js");var e=require("../BufferGeometryUtils-903f7ecb.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.toCreasedNormals=e.toCreasedNormals,exports.toTrianglesDrawMode=e.toTrianglesDrawMode;

package/utils/BufferGeometryUtils.d.ts

@@ -1,15 +0,0 @@
-import { BufferAttribute, BufferGeometry, Float32BufferAttribute, InterleavedBufferAttribute, Mesh, Line, Points } from 'three';
-export declare const mergeBufferGeometries: (geometries: BufferGeometry[], useGroups?: boolean | undefined) => BufferGeometry | null;
-export declare const mergeBufferAttributes: (attributes: BufferAttribute[]) => BufferAttribute | null | undefined;
-export declare const interleaveAttributes: (attributes: BufferAttribute[]) => InterleavedBufferAttribute[] | null;
-export declare function estimateBytesUsed(geometry: BufferGeometry): number;
-export declare function mergeVertices(geometry: BufferGeometry, tolerance?: number): BufferGeometry;
-export declare function toTrianglesDrawMode(geometry: BufferGeometry, drawMode: number): BufferGeometry;
-export declare type ComputedMorphedAttribute = {
-    positionAttribute: BufferAttribute | InterleavedBufferAttribute;
-    normalAttribute: BufferAttribute | InterleavedBufferAttribute;
-    morphedPositionAttribute: Float32BufferAttribute;
-    morphedNormalAttribute: Float32BufferAttribute;
-};
-export declare function computeMorphedAttributes(object: Mesh | Line | Points): ComputedMorphedAttribute | null;
-export declare function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;