three-stdlib 2.22.5 → 2.22.7

package/shaders/SSRShader.d.ts

@@ -1,90 +0,0 @@
-import { Matrix4, Vector2 } from 'three';
-export declare const SSRShader: {
-    defines: {
-        MAX_STEP: number;
-        isPerspectiveCamera: boolean;
-        isDistanceAttenuation: boolean;
-        isFresnel: boolean;
-        isInfiniteThick: boolean;
-        isSelective: boolean;
-    };
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        tNormal: {
-            value: null;
-        };
-        tMetalness: {
-            value: null;
-        };
-        tDepth: {
-            value: null;
-        };
-        cameraNear: {
-            value: null;
-        };
-        cameraFar: {
-            value: null;
-        };
-        resolution: {
-            value: Vector2;
-        };
-        cameraProjectionMatrix: {
-            value: Matrix4;
-        };
-        cameraInverseProjectionMatrix: {
-            value: Matrix4;
-        };
-        opacity: {
-            value: number;
-        };
-        maxDistance: {
-            value: number;
-        };
-        cameraRange: {
-            value: number;
-        };
-        surfDist: {
-            value: number;
-        };
-        thickTolerance: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-export declare const SSRDepthShader: {
-    defines: {
-        PERSPECTIVE_CAMERA: number;
-    };
-    uniforms: {
-        tDepth: {
-            value: null;
-        };
-        cameraNear: {
-            value: null;
-        };
-        cameraFar: {
-            value: null;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-export declare const SSRBlurShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        resolution: {
-            value: Vector2;
-        };
-        opacity: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/SSRShader.js

@@ -1,379 +0,0 @@
-import { Vector2, Matrix4 } from 'three';
-
-/**
- * References:
- * https://lettier.github.io/3d-game-shaders-for-beginners/screen-space-reflection.html
- */
-
-const SSRShader = {
-  defines: {
-    MAX_STEP: 0,
-    isPerspectiveCamera: true,
-    isDistanceAttenuation: true,
-    isFresnel: true,
-    isInfiniteThick: false,
-    isSelective: false
-  },
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    tNormal: {
-      value: null
-    },
-    tMetalness: {
-      value: null
-    },
-    tDepth: {
-      value: null
-    },
-    cameraNear: {
-      value: null
-    },
-    cameraFar: {
-      value: null
-    },
-    resolution: {
-      value: new Vector2()
-    },
-    cameraProjectionMatrix: {
-      value: new Matrix4()
-    },
-    cameraInverseProjectionMatrix: {
-      value: new Matrix4()
-    },
-    opacity: {
-      value: 0.5
-    },
-    maxDistance: {
-      value: 180
-    },
-    cameraRange: {
-      value: 0
-    },
-    surfDist: {
-      value: 0.007
-    },
-    thickTolerance: {
-      value: 0.03
-    }
-  },
-  vertexShader:
-  /* glsl */
-  `
-
-    varying vec2 vUv;
-
-    void main() {
-
-			vUv = uv;
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-    }
-
-  `,
-  fragmentShader:
-  /* glsl */
-  `
-		// precision highp float;
-		precision highp sampler2D;
-		varying vec2 vUv;
-		uniform sampler2D tDepth;
-		uniform sampler2D tNormal;
-		uniform sampler2D tMetalness;
-		uniform sampler2D tDiffuse;
-		uniform float cameraRange;
-		uniform vec2 resolution;
-		uniform float opacity;
-		uniform float cameraNear;
-		uniform float cameraFar;
-		uniform float maxDistance;
-		uniform float surfDist;
-		uniform mat4 cameraProjectionMatrix;
-		uniform mat4 cameraInverseProjectionMatrix;
-		uniform float thickTolerance;
-		#include <packing>
-		float pointToLineDistance(vec3 x0, vec3 x1, vec3 x2) {
-			//x0: point, x1: linePointA, x2: linePointB
-			//https://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
-			return length(cross(x0-x1,x0-x2))/length(x2-x1);
-		}
-		float pointPlaneDistance(vec3 point,vec3 planePoint,vec3 planeNormal){
-			// https://mathworld.wolfram.com/Point-PlaneDistance.html
-			//// https://en.wikipedia.org/wiki/Plane_(geometry)
-			//// http://paulbourke.net/geometry/pointlineplane/
-			float a=planeNormal.x,b=planeNormal.y,c=planeNormal.z;
-			float x0=point.x,y0=point.y,z0=point.z;
-			float x=planePoint.x,y=planePoint.y,z=planePoint.z;
-			float d=-(a*x+b*y+c*z);
-			float distance=(a*x0+b*y0+c*z0+d)/sqrt(a*a+b*b+c*c);
-			return distance;
-		}
-		float getDepth( const in vec2 uv ) {
-			return texture2D( tDepth, uv ).x;
-		}
-		float getViewZ( const in float depth ) {
-			#ifdef isPerspectiveCamera
-				return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );
-			#else
-				return orthographicDepthToViewZ( depth, cameraNear, cameraFar );
-			#endif
-		}
-		vec3 getViewPosition( const in vec2 uv, const in float depth/*clip space*/, const in float clipW ) {
-			vec4 clipPosition = vec4( ( vec3( uv, depth ) - 0.5 ) * 2.0, 1.0 );//ndc
-			clipPosition *= clipW; //clip
-			return ( cameraInverseProjectionMatrix * clipPosition ).xyz;//view
-		}
-		vec3 getViewNormal( const in vec2 uv ) {
-			return unpackRGBToNormal( texture2D( tNormal, uv ).xyz );
-		}
-		vec2 viewPositionToXY(vec3 viewPosition){
-			vec2 xy;
-			vec4 clip=cameraProjectionMatrix*vec4(viewPosition,1);
-			xy=clip.xy;//clip
-			float clipW=clip.w;
-			xy/=clipW;//NDC
-			xy=(xy+1.)/2.;//uv
-			xy*=resolution;//screen
-			return xy;
-		}
-		void main(){
-			#ifdef isSelective
-				float metalness=texture2D(tMetalness,vUv).r;
-				if(metalness==0.) return;
-			#endif
-
-			float depth = getDepth( vUv );
-			float viewZ = getViewZ( depth );
-			if(-viewZ>=cameraFar) return;
-
-			float clipW = cameraProjectionMatrix[2][3] * viewZ+cameraProjectionMatrix[3][3];
-			vec3 viewPosition=getViewPosition( vUv, depth, clipW );
-
-			vec2 d0=gl_FragCoord.xy;
-			vec2 d1;
-
-			vec3 viewNormal=getViewNormal( vUv );
-
-			#ifdef isPerspectiveCamera
-				vec3 viewIncidenceDir=normalize(viewPosition);
-				vec3 viewReflectDir=reflect(viewIncidenceDir,viewNormal);
-			#else
-				vec3 viewIncidenceDir=vec3(0,0,-1);
-				vec3 viewReflectDir=reflect(viewIncidenceDir,viewNormal);
-			#endif
-
-			float maxReflectRayLen=maxDistance/dot(-viewIncidenceDir,viewNormal);
-			// dot(a,b)==length(a)*length(b)*cos(theta) // https://www.mathsisfun.com/algebra/vectors-dot-product.html
-			// if(a.isNormalized&&b.isNormalized) dot(a,b)==cos(theta)
-			// maxDistance/maxReflectRayLen=cos(theta)
-			// maxDistance/maxReflectRayLen==dot(a,b)
-			// maxReflectRayLen==maxDistance/dot(a,b)
-
-			vec3 d1viewPosition=viewPosition+viewReflectDir*maxReflectRayLen;
-			#ifdef isPerspectiveCamera
-				if(d1viewPosition.z>-cameraNear){
-					//https://tutorial.math.lamar.edu/Classes/CalcIII/EqnsOfLines.aspx
-					float t=(-cameraNear-viewPosition.z)/viewReflectDir.z;
-					d1viewPosition=viewPosition+viewReflectDir*t;
-				}
-			#endif
-			d1=viewPositionToXY(d1viewPosition);
-
-			float totalLen=length(d1-d0);
-			float xLen=d1.x-d0.x;
-			float yLen=d1.y-d0.y;
-			float totalStep=max(abs(xLen),abs(yLen));
-			float xSpan=xLen/totalStep;
-			float ySpan=yLen/totalStep;
-			for(float i=0.;i<MAX_STEP;i++){
-				if(i>=totalStep) break;
-				vec2 xy=vec2(d0.x+i*xSpan,d0.y+i*ySpan);
-				if(xy.x<0.||xy.x>resolution.x||xy.y<0.||xy.y>resolution.y) break;
-				float s=length(xy-d0)/totalLen;
-				vec2 uv=xy/resolution;
-
-				float d = getDepth(uv);
-				float vZ = getViewZ( d );
-				if(-vZ>=cameraFar) continue;
-				float cW = cameraProjectionMatrix[2][3] * vZ+cameraProjectionMatrix[3][3];
-				vec3 vP=getViewPosition( uv, d, cW );
-
-				#ifdef isPerspectiveCamera
-					// https://www.comp.nus.edu.sg/~lowkl/publications/lowk_persp_interp_techrep.pdf
-					float recipVPZ=1./viewPosition.z;
-					float viewReflectRayZ=1./(recipVPZ+s*(1./d1viewPosition.z-recipVPZ));
-					float sD=surfDist*cW;
-				#else
-					float viewReflectRayZ=viewPosition.z+s*(d1viewPosition.z-viewPosition.z);
-					float sD=surfDist;
-				#endif
-				if(viewReflectRayZ-sD>vZ) continue;
-
-				#ifdef isInfiniteThick
-					if(viewReflectRayZ+thickTolerance*clipW<vP.z) break;
-				#endif
-				float away=pointToLineDistance(vP,viewPosition,d1viewPosition);
-
-				float op=opacity;
-
-				if(away<sD){
-					vec3 vN=getViewNormal( uv );
-					if(dot(viewReflectDir,vN)>=0.) continue;
-					float distance=pointPlaneDistance(vP,viewPosition,viewNormal);
-					if(distance>maxDistance) break;
-					#ifdef isDistanceAttenuation
-						float ratio=1.-(distance/maxDistance);
-						float attenuation=ratio*ratio;
-						op=opacity*attenuation;
-					#endif
-					#ifdef isFresnel
-						float fresnel=(dot(viewIncidenceDir,viewReflectDir)+1.)/2.;
-						op*=fresnel;
-					#endif
-					vec4 reflectColor=texture2D(tDiffuse,uv);
-					gl_FragColor.xyz=reflectColor.xyz;
-					gl_FragColor.a=op;
-					break;
-				}
-			}
-		}
-	`
-};
-const SSRDepthShader = {
-  defines: {
-    PERSPECTIVE_CAMERA: 1
-  },
-  uniforms: {
-    tDepth: {
-      value: null
-    },
-    cameraNear: {
-      value: null
-    },
-    cameraFar: {
-      value: null
-    }
-  },
-  vertexShader:
-  /* glsl */
-  `
-
-    varying vec2 vUv;
-
-    void main() {
-
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-    }
-
-  `,
-  fragmentShader:
-  /* glsl */
-  `
-
-    uniform sampler2D tDepth;
-
-    uniform float cameraNear;
-    uniform float cameraFar;
-
-    varying vec2 vUv;
-
-    #include <packing>
-
-		float getLinearDepth( const in vec2 uv ) {
-
-			#if PERSPECTIVE_CAMERA == 1
-
-				float fragCoordZ = texture2D( tDepth, uv ).x;
-				float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
-				return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
-
-			#else
-
-				return texture2D( tDepth, uv ).x;
-
-			#endif
-
-		}
-
-    void main() {
-
-    	float depth = getLinearDepth( vUv );
-			float d = 1.0 - depth;
-			// d=(d-.999)*1000.;
-    	gl_FragColor = vec4( vec3( d ), 1.0 );
-
-    }
-
-  `
-};
-const SSRBlurShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    resolution: {
-      value: new Vector2()
-    },
-    opacity: {
-      value: 0.5
-    }
-  },
-  vertexShader:
-  /* glsl */
-  `
-
-    varying vec2 vUv;
-
-    void main() {
-
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-    }
-
-  `,
-  fragmentShader:
-  /* glsl */
-  `
-
-    uniform sampler2D tDiffuse;
-    uniform vec2 resolution;
-    varying vec2 vUv;
-    void main() {
-			//reverse engineering from PhotoShop blur filter, then change coefficient
-
-    	vec2 texelSize = ( 1.0 / resolution );
-
-			vec4 c=texture2D(tDiffuse,vUv);
-
-			vec2 offset;
-
-			offset=(vec2(-1,0))*texelSize;
-			vec4 cl=texture2D(tDiffuse,vUv+offset);
-
-			offset=(vec2(1,0))*texelSize;
-			vec4 cr=texture2D(tDiffuse,vUv+offset);
-
-			offset=(vec2(0,-1))*texelSize;
-			vec4 cb=texture2D(tDiffuse,vUv+offset);
-
-			offset=(vec2(0,1))*texelSize;
-			vec4 ct=texture2D(tDiffuse,vUv+offset);
-
-			// float coeCenter=.5;
-			// float coeSide=.125;
-			float coeCenter=.2;
-			float coeSide=.2;
-			float a=c.a*coeCenter+cl.a*coeSide+cr.a*coeSide+cb.a*coeSide+ct.a*coeSide;
-			vec3 rgb=(c.rgb*c.a*coeCenter+cl.rgb*cl.a*coeSide+cr.rgb*cr.a*coeSide+cb.rgb*cb.a*coeSide+ct.rgb*ct.a*coeSide)/a;
-			gl_FragColor=vec4(rgb,a);
-
-		}
-	`
-};
-
-export { SSRBlurShader, SSRDepthShader, SSRShader };

package/shaders/SepiaShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const o={uniforms:{tDiffuse:{value:null},amount:{value:1}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform float amount;","uniform sampler2D tDiffuse;","varying vec2 vUv;","void main() {","\tvec4 color = texture2D( tDiffuse, vUv );","\tvec3 c = color.rgb;","\tcolor.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );","\tcolor.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );","\tcolor.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );","\tgl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );","}"].join("\n")};exports.SepiaShader=o;

package/shaders/SepiaShader.d.ts

@@ -1,12 +0,0 @@
-export declare const SepiaShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        amount: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/SepiaShader.js

@@ -1,19 +0,0 @@
-/**
- * Sepia tone shader
- * based on glfx.js sepia shader
- * https://github.com/evanw/glfx.js
- */
-const SepiaShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    amount: {
-      value: 1.0
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform float amount;', 'uniform sampler2D tDiffuse;', 'varying vec2 vUv;', 'void main() {', '	vec4 color = texture2D( tDiffuse, vUv );', '	vec3 c = color.rgb;', '	color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );', '	color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );', '	color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );', '	gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );', '}'].join('\n')
-};
-
-export { SepiaShader };

package/shaders/SobelOperatorShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const t={uniforms:{tDiffuse:{value:null},resolution:{value:new(require("three").Vector2)}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","uniform vec2 resolution;","varying vec2 vUv;","void main() {","\tvec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );","\tconst mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 );","\tconst mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 );","\tfloat tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;","\tfloat tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;","\tfloat tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;","\tfloat tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;","\tfloat tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;","\tfloat tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;","\tfloat tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;","\tfloat tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;","\tfloat tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;","\tfloat valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + ","\t\tGx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + ","\t\tGx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; ","\tfloat valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + ","\t\tGy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + ","\t\tGy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; ","\tfloat G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );","\tgl_FragColor = vec4( vec3( G ), 1 );","}"].join("\n")};exports.SobelOperatorShader=t;

package/shaders/SobelOperatorShader.d.ts

@@ -1,13 +0,0 @@
-import { Vector2 } from 'three';
-export declare const SobelOperatorShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        resolution: {
-            value: Vector2;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/SobelOperatorShader.js

@@ -1,33 +0,0 @@
-import { Vector2 } from 'three';
-
-/**
- * Sobel Edge Detection (see https://youtu.be/uihBwtPIBxM)
- *
- * As mentioned in the video the Sobel operator expects a grayscale image as input.
- *
- */
-
-const SobelOperatorShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    resolution: {
-      value: new Vector2()
-    }
-  },
-  vertexShader: ['varying vec2 vUv;', 'void main() {', '	vUv = uv;', '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );', '}'].join('\n'),
-  fragmentShader: ['uniform sampler2D tDiffuse;', 'uniform vec2 resolution;', 'varying vec2 vUv;', 'void main() {', '	vec2 texel = vec2( 1.0 / resolution.x, 1.0 / resolution.y );', // kernel definition (in glsl matrices are filled in column-major order)
-  '	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 );', // x direction kernel
-  '	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 );', // y direction kernel
-  // fetch the 3x3 neighbourhood of a fragment
-  // first column
-  '	float tx0y0 = texture2D( tDiffuse, vUv + texel * vec2( -1, -1 ) ).r;', '	float tx0y1 = texture2D( tDiffuse, vUv + texel * vec2( -1,  0 ) ).r;', '	float tx0y2 = texture2D( tDiffuse, vUv + texel * vec2( -1,  1 ) ).r;', // second column
-  '	float tx1y0 = texture2D( tDiffuse, vUv + texel * vec2(  0, -1 ) ).r;', '	float tx1y1 = texture2D( tDiffuse, vUv + texel * vec2(  0,  0 ) ).r;', '	float tx1y2 = texture2D( tDiffuse, vUv + texel * vec2(  0,  1 ) ).r;', // third column
-  '	float tx2y0 = texture2D( tDiffuse, vUv + texel * vec2(  1, -1 ) ).r;', '	float tx2y1 = texture2D( tDiffuse, vUv + texel * vec2(  1,  0 ) ).r;', '	float tx2y2 = texture2D( tDiffuse, vUv + texel * vec2(  1,  1 ) ).r;', // gradient value in x direction
-  '	float valueGx = Gx[0][0] * tx0y0 + Gx[1][0] * tx1y0 + Gx[2][0] * tx2y0 + ', '		Gx[0][1] * tx0y1 + Gx[1][1] * tx1y1 + Gx[2][1] * tx2y1 + ', '		Gx[0][2] * tx0y2 + Gx[1][2] * tx1y2 + Gx[2][2] * tx2y2; ', // gradient value in y direction
-  '	float valueGy = Gy[0][0] * tx0y0 + Gy[1][0] * tx1y0 + Gy[2][0] * tx2y0 + ', '		Gy[0][1] * tx0y1 + Gy[1][1] * tx1y1 + Gy[2][1] * tx2y1 + ', '		Gy[0][2] * tx0y2 + Gy[1][2] * tx1y2 + Gy[2][2] * tx2y2; ', // magnitute of the total gradient
-  '	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );', '	gl_FragColor = vec4( vec3( G ), 1 );', '}'].join('\n')
-};
-
-export { SobelOperatorShader };

package/shaders/SubsurfaceScatteringShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");const t=e.ShaderChunk.meshphong_frag.slice(0,e.ShaderChunk.meshphong_frag.indexOf("void main() {")),i=e.ShaderChunk.meshphong_frag.slice(e.ShaderChunk.meshphong_frag.indexOf("void main() {")),n={uniforms:e.UniformsUtils.merge([e.ShaderLib.phong.uniforms,{thicknessMap:{value:null},thicknessColor:{value:new e.Color(16777215)},thicknessDistortion:{value:.1},thicknessAmbient:{value:0},thicknessAttenuation:{value:.1},thicknessPower:{value:2},thicknessScale:{value:10}}]),vertexShader:["#define USE_UV",e.ShaderChunk.meshphong_vert].join("\n"),fragmentShader:["#define USE_UV","#define SUBSURFACE",t,"uniform sampler2D thicknessMap;","uniform float thicknessPower;","uniform float thicknessScale;","uniform float thicknessDistortion;","uniform float thicknessAmbient;","uniform float thicknessAttenuation;","uniform vec3 thicknessColor;","void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {","\tvec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;","\tvec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));","\tfloat scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;","\tvec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;","\treflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;","}",i.replace("#include <lights_fragment_begin>",(r=e.ShaderChunk.lights_fragment_begin,s="RE_Direct( directLight, geometry, material, reflectedLight );",o=["RE_Direct( directLight, geometry, material, reflectedLight );","#if defined( SUBSURFACE ) && defined( USE_UV )"," RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);","#endif"].join("\n"),r.split(s).join(o)))].join("\n")};var r,s,o;exports.SubsurfaceScatteringShader=n;

package/shaders/SubsurfaceScatteringShader.d.ts

@@ -1,5 +0,0 @@
-export declare const SubsurfaceScatteringShader: {
-    uniforms: any;
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/SubsurfaceScatteringShader.js

@@ -1,45 +0,0 @@
-import { ShaderChunk, UniformsUtils, ShaderLib, Color } from 'three';
-
-/**
- * ------------------------------------------------------------------------------------------
- * Subsurface Scattering shader
- * Based on GDC 2011 – Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look
- * https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/
- *------------------------------------------------------------------------------------------
- */
-
-function replaceAll(string, find, replace) {
-  return string.split(find).join(replace);
-}
-
-const meshphong_frag_head = ShaderChunk['meshphong_frag'].slice(0, ShaderChunk['meshphong_frag'].indexOf('void main() {'));
-const meshphong_frag_body = ShaderChunk['meshphong_frag'].slice(ShaderChunk['meshphong_frag'].indexOf('void main() {'));
-const SubsurfaceScatteringShader = {
-  uniforms: UniformsUtils.merge([ShaderLib['phong'].uniforms, {
-    thicknessMap: {
-      value: null
-    },
-    thicknessColor: {
-      value: new Color(0xffffff)
-    },
-    thicknessDistortion: {
-      value: 0.1
-    },
-    thicknessAmbient: {
-      value: 0.0
-    },
-    thicknessAttenuation: {
-      value: 0.1
-    },
-    thicknessPower: {
-      value: 2.0
-    },
-    thicknessScale: {
-      value: 10.0
-    }
-  }]),
-  vertexShader: ['#define USE_UV', ShaderChunk['meshphong_vert']].join('\n'),
-  fragmentShader: ['#define USE_UV', '#define SUBSURFACE', meshphong_frag_head, 'uniform sampler2D thicknessMap;', 'uniform float thicknessPower;', 'uniform float thicknessScale;', 'uniform float thicknessDistortion;', 'uniform float thicknessAmbient;', 'uniform float thicknessAttenuation;', 'uniform vec3 thicknessColor;', 'void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {', '	vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;', '	vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));', '	float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;', '	vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;', '	reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;', '}', meshphong_frag_body.replace('#include <lights_fragment_begin>', replaceAll(ShaderChunk['lights_fragment_begin'], 'RE_Direct( directLight, geometry, material, reflectedLight );', ['RE_Direct( directLight, geometry, material, reflectedLight );', '#if defined( SUBSURFACE ) && defined( USE_UV )', ' RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);', '#endif'].join('\n')))].join('\n')
-};
-
-export { SubsurfaceScatteringShader };

package/shaders/TechnicolorShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D tDiffuse;","varying vec2 vUv;","void main() {","\tvec4 tex = texture2D( tDiffuse, vec2( vUv.x, vUv.y ) );","\tvec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);","\tgl_FragColor = newTex;","}"].join("\n")};exports.TechnicolorShader=e;

package/shaders/TechnicolorShader.d.ts

@@ -1,9 +0,0 @@
-export declare const TechnicolorShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};

package/shaders/TechnicolorShader.js

@@ -1,17 +0,0 @@
-/**
- * Technicolor Shader
- * Simulates the look of the two-strip technicolor process popular in early 20th century films.
- * More historical info here: http://www.widescreenmuseum.com/oldcolor/technicolor1.htm
- * Demo here: http://charliehoey.com/technicolor_shader/shader_test.html
- */
-const TechnicolorShader = {
-  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, vec2( vUv.x, vUv.y ) );', '	vec4 newTex = vec4(tex.r, (tex.g + tex.b) * .5, (tex.g + tex.b) * .5, 1.0);', '	gl_FragColor = newTex;', '}'].join('\n')
-};
-
-export { TechnicolorShader };

package/shaders/ToneMapShader.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={uniforms:{tDiffuse:{value:null},averageLuminance:{value:1},luminanceMap:{value:null},maxLuminance:{value:16},minLuminance:{value:.01},middleGrey:{value:.6}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = uv;","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["#include <common>","uniform sampler2D tDiffuse;","varying vec2 vUv;","uniform float middleGrey;","uniform float minLuminance;","uniform float maxLuminance;","#ifdef ADAPTED_LUMINANCE","\tuniform sampler2D luminanceMap;","#else","\tuniform float averageLuminance;","#endif","vec3 ToneMap( vec3 vColor ) {","\t#ifdef ADAPTED_LUMINANCE","\t\tfloat fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;","\t#else","\t\tfloat fLumAvg = averageLuminance;","\t#endif","\tfloat fLumPixel = linearToRelativeLuminance( vColor );","\tfloat fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );","\tfloat fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);","\treturn fLumCompressed * vColor;","}","void main() {","\tvec4 texel = texture2D( tDiffuse, vUv );","\tgl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );","}"].join("\n")};exports.ToneMapShader=e;

package/shaders/ToneMapShader.d.ts

@@ -1,24 +0,0 @@
-export declare const ToneMapShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        averageLuminance: {
-            value: number;
-        };
-        luminanceMap: {
-            value: null;
-        };
-        maxLuminance: {
-            value: number;
-        };
-        minLuminance: {
-            value: number;
-        };
-        middleGrey: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};