three-stdlib 2.16.0 → 2.16.2

package/shaders/SSRShader.mjs

@@ -1,324 +0,0 @@
-import { Vector2, Matrix4 } from "three";
-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: 7e-3 },
-    thickTolerance: { value: 0.03 }
-  },
-  vertexShader: `
-
-    varying vec2 vUv;
-
-    void main() {
-
-			vUv = uv;
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-    }
-
-  `,
-  fragmentShader: `
-		// 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: `
-
-    varying vec2 vUv;
-
-    void main() {
-
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-    }
-
-  `,
-  fragmentShader: `
-
-    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: `
-
-    varying vec2 vUv;
-
-    void main() {
-
-    	vUv = uv;
-    	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-    }
-
-  `,
-  fragmentShader: `
-
-    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.mjs

@@ -1,29 +0,0 @@
-const SepiaShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    amount: { value: 1 }
-  },
-  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.mjs

@@ -1,44 +0,0 @@
-import { Vector2 } from "three";
-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 );",
-    "	const mat3 Gx = mat3( -1, -2, -1, 0, 0, 0, 1, 2, 1 );",
-    "	const mat3 Gy = mat3( -1, 0, 1, -2, 0, 2, -1, 0, 1 );",
-    "	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;",
-    "	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;",
-    "	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;",
-    "	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; ",
-    "	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; ",
-    "	float G = sqrt( ( valueGx * valueGx ) + ( valueGy * valueGy ) );",
-    "	gl_FragColor = vec4( vec3( G ), 1 );",
-    "}"
-  ].join("\n")
-};
-export {
-  SobelOperatorShader
-};

package/shaders/SubsurfaceScatteringShader.mjs

@@ -1,59 +0,0 @@
-import { ShaderChunk, UniformsUtils, ShaderLib, Color } from "three";
-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(16777215) },
-      thicknessDistortion: { value: 0.1 },
-      thicknessAmbient: { value: 0 },
-      thicknessAttenuation: { value: 0.1 },
-      thicknessPower: { value: 2 },
-      thicknessScale: { value: 10 }
-    }
-  ]),
-  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.mjs

@@ -1,24 +0,0 @@
-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.mjs

@@ -1,48 +0,0 @@
-const ToneMapShader = {
-  uniforms: {
-    tDiffuse: { value: null },
-    averageLuminance: { value: 1 },
-    luminanceMap: { value: null },
-    maxLuminance: { value: 16 },
-    minLuminance: { value: 0.01 },
-    middleGrey: { value: 0.6 }
-  },
-  vertexShader: [
-    "varying vec2 vUv;",
-    "void main() {",
-    "	vUv = uv;",
-    "	gl_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",
-    "	uniform sampler2D luminanceMap;",
-    "#else",
-    "	uniform float averageLuminance;",
-    "#endif",
-    "vec3 ToneMap( vec3 vColor ) {",
-    "	#ifdef ADAPTED_LUMINANCE",
-    "		float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;",
-    "	#else",
-    "		float fLumAvg = averageLuminance;",
-    "	#endif",
-    "	float fLumPixel = linearToRelativeLuminance( vColor );",
-    "	float fLumScaled = (fLumPixel * middleGrey) / max( minLuminance, fLumAvg );",
-    "	float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);",
-    "	return fLumCompressed * vColor;",
-    "}",
-    "void main() {",
-    "	vec4 texel = texture2D( tDiffuse, vUv );",
-    "	gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );",
-    "}"
-  ].join("\n")
-};
-export {
-  ToneMapShader
-};