super-three 0.136.0 → 0.141.0

package/examples/js/shaders/SSRrShader.js

@@ -1,336 +0,0 @@
-( function () {
-
-	const SSRrShader = {
-		defines: {
-			MAX_STEP: 0,
-			PERSPECTIVE_CAMERA: true,
-			SPECULAR: true,
-			FILL_HOLE: true,
-			INFINITE_THICK: false
-		},
-		uniforms: {
-			'tDiffuse': {
-				value: null
-			},
-			'tSpecular': {
-				value: null
-			},
-			'tNormalSelects': {
-				value: null
-			},
-			'tRefractive': {
-				value: null
-			},
-			'tDepth': {
-				value: null
-			},
-			'tDepthSelects': {
-				value: null
-			},
-			'cameraNear': {
-				value: null
-			},
-			'cameraFar': {
-				value: null
-			},
-			'resolution': {
-				value: new THREE.Vector2()
-			},
-			'cameraProjectionMatrix': {
-				value: new THREE.Matrix4()
-			},
-			'cameraInverseProjectionMatrix': {
-				value: new THREE.Matrix4()
-			},
-			'ior': {
-				value: 1.03
-			},
-			'cameraRange': {
-				value: 0
-			},
-			'maxDistance': {
-				value: 180
-			},
-			'surfDist': {
-				value: .007
-			}
-		},
-		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 tDepthSelects;
-		uniform sampler2D tNormalSelects;
-		uniform sampler2D tRefractive;
-		uniform sampler2D tDiffuse;
-		uniform sampler2D tSpecular;
-		uniform float cameraRange;
-		uniform vec2 resolution;
-		uniform float cameraNear;
-		uniform float cameraFar;
-		uniform float ior;
-		uniform mat4 cameraProjectionMatrix;
-		uniform mat4 cameraInverseProjectionMatrix;
-		uniform float maxDistance;
-		uniform float surfDist;
-		#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 getDepthSelects( const in vec2 uv ) {
-			return texture2D( tDepthSelects, uv ).x;
-		}
-		float getViewZ( const in float depth ) {
-			#ifdef PERSPECTIVE_CAMERA
-				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 getViewNormalSelects( const in vec2 uv ) {
-			return unpackRGBToNormal( texture2D( tNormalSelects, 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 setResultColor(vec2 uv){
-			vec4 refractColor=texture2D(tDiffuse,uv);
-			#ifdef SPECULAR
-				vec4 specularColor=texture2D(tSpecular,vUv);
-				gl_FragColor.xyz=mix(refractColor.xyz,vec3(1),specularColor.r);
-				// gl_FragColor.xyz=refractColor.xyz*(1.+specularColor.r*3.);
-			#else
-				gl_FragColor.xyz=refractColor.xyz;
-			#endif
-			gl_FragColor.a=1.;
-
-		}
-		void main(){
-			if(ior==1.) return; // Adding this line may have better performance, but more importantly, it can avoid display errors at the very edges of the model when IOR is equal to 1.
-
-			float refractive=texture2D(tRefractive,vUv).r;
-			if(refractive<=0.) return;
-
-			// gl_FragColor=vec4(0,0,.5,1);return;
-			vec3 viewNormalSelects=getViewNormalSelects( vUv );
-			// gl_FragColor=vec4(viewNormalSelects,1);return;
-
-			// if(viewNormalSelects.x<=0.&&viewNormalSelects.y<=0.&&viewNormalSelects.z<=0.) return;
-
-			float depth = getDepthSelects( 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;
-
-			#ifdef PERSPECTIVE_CAMERA
-				vec3 viewIncidentDir=normalize(viewPosition);
-			#else
-				vec3 viewIncidentDir=vec3(0,0,-1);
-			#endif
-
-			vec3 viewRefractDir=refract(viewIncidentDir,viewNormalSelects,1./ior);
-			// https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/refract.xhtml
-
-			vec3 d1viewPosition=viewPosition+viewRefractDir*maxDistance;
-			#ifdef PERSPECTIVE_CAMERA
-				if(d1viewPosition.z>-cameraNear){
-					//https://tutorial.math.lamar.edu/Classes/CalcIII/EqnsOfLines.aspx
-					float t=(-cameraNear-viewPosition.z)/viewRefractDir.z;
-					d1viewPosition=viewPosition+viewRefractDir*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;
-			#ifdef FILL_HOLE
-				bool isRough=false;
-				vec2 uvRough;
-			#endif
-			for(float i=0.;i<float(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 );
-				float cW = cameraProjectionMatrix[2][3] * vZ+cameraProjectionMatrix[3][3];
-				vec3 vP=getViewPosition( uv, d, cW );
-
-				#ifdef PERSPECTIVE_CAMERA
-					// https://comp.nus.edu.sg/~lowkl/publications/lowk_persp_interp_techrep.pdf
-					float recipVPZ=1./viewPosition.z;
-					float viewRefractRayZ=1./(recipVPZ+s*(1./d1viewPosition.z-recipVPZ));
-					float sD=surfDist*cW;
-				#else
-					float viewRefractRayZ=viewPosition.z+s*(d1viewPosition.z-viewPosition.z);
-					float sD=surfDist;
-				#endif
-
-				#ifdef FILL_HOLE // TODO: May can improve performance by check if INFINITE_THICK too.
-					if(viewRefractRayZ<=vZ){
-						if(!isRough){
-							uvRough=uv;
-							isRough=true;
-						}
-					}
-				#endif
-
-				bool hit;
-				#ifdef INFINITE_THICK
-					hit=viewRefractRayZ<=vZ;
-				#else
-					if(viewRefractRayZ-sD>vZ) continue;
-					float away=pointToLineDistance(vP,viewPosition,d1viewPosition);
-					hit=away<=sD;
-				#endif
-				if(hit){
-					setResultColor(uv);
-					return;
-				}
-			}
-
-			#ifdef FILL_HOLE
-				if(isRough){
-					setResultColor(uvRough);
-				}
-				// else{
-				// 	gl_FragColor=texture2D(tDiffuse,vUv);//For afterward add color mix feature.
-				// }
-			#else
-				// gl_FragColor=texture2D(tDiffuse,vUv);//For afterward add color mix feature.
-			#endif
-		}
-	`
-	};
-	var SSRrDepthShader = {
-		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 );
-
-		}
-
-	`
-	};
-
-	THREE.SSRrDepthShader = SSRrDepthShader;
-	THREE.SSRrShader = SSRrShader;
-
-} )();

package/examples/js/utils/RoughnessMipmapper.js

@@ -1,268 +0,0 @@
-( function () {
-
-	/**
- * This class generates custom mipmaps for a roughness map by encoding the lost variation in the
- * normal map mip levels as increased roughness in the corresponding roughness mip levels. This
- * helps with rendering accuracy for MeshStandardMaterial, and also helps with anti-aliasing when
- * using PMREM. If the normal map is larger than the roughness map, the roughness map will be
- * enlarged to match the dimensions of the normal map.
- */
-
-	const _mipmapMaterial = _getMipmapMaterial();
-
-	const _mesh = new THREE.Mesh( new THREE.PlaneGeometry( 2, 2 ), _mipmapMaterial );
-
-	const _flatCamera = new THREE.OrthographicCamera( 0, 1, 0, 1, 0, 1 );
-
-	let _tempTarget = null;
-	let _renderer = null;
-
-	class RoughnessMipmapper {
-
-		constructor( renderer ) {
-
-			_renderer = renderer;
-
-			_renderer.compile( _mesh, _flatCamera );
-
-		}
-
-		generateMipmaps( material ) {
-
-			if ( 'roughnessMap' in material === false ) return;
-			const {
-				roughnessMap,
-				normalMap
-			} = material;
-			if ( roughnessMap === null || normalMap === null || ! roughnessMap.generateMipmaps || material.userData.roughnessUpdated ) return;
-			material.userData.roughnessUpdated = true;
-			let width = Math.max( roughnessMap.image.width, normalMap.image.width );
-			let height = Math.max( roughnessMap.image.height, normalMap.image.height );
-			if ( ! THREE.MathUtils.isPowerOfTwo( width ) || ! THREE.MathUtils.isPowerOfTwo( height ) ) return;
-
-			const oldTarget = _renderer.getRenderTarget();
-
-			const autoClear = _renderer.autoClear;
-			_renderer.autoClear = false;
-
-			if ( _tempTarget === null || _tempTarget.width !== width || _tempTarget.height !== height ) {
-
-				if ( _tempTarget !== null ) _tempTarget.dispose();
-				_tempTarget = new THREE.WebGLRenderTarget( width, height, {
-					depthBuffer: false
-				} );
-				_tempTarget.scissorTest = true;
-
-			}
-
-			const newRoughnessTexture = new THREE.FramebufferTexture( width, height, roughnessMap.format );
-			newRoughnessTexture.wrapS = roughnessMap.wrapS;
-			newRoughnessTexture.wrapT = roughnessMap.wrapT;
-			newRoughnessTexture.minFilter = roughnessMap.minFilter;
-			newRoughnessTexture.magFilter = roughnessMap.magFilter;
-			material.roughnessMap = newRoughnessTexture;
-			if ( material.metalnessMap == roughnessMap ) material.metalnessMap = material.roughnessMap;
-			if ( material.aoMap == roughnessMap ) material.aoMap = material.roughnessMap; // Copy UV transform parameters
-
-			material.roughnessMap.offset.copy( roughnessMap.offset );
-			material.roughnessMap.repeat.copy( roughnessMap.repeat );
-			material.roughnessMap.center.copy( roughnessMap.center );
-			material.roughnessMap.rotation = roughnessMap.rotation;
-			material.roughnessMap.image = roughnessMap.image; // required for USDZExporter, see #22741
-
-			material.roughnessMap.matrixAutoUpdate = roughnessMap.matrixAutoUpdate;
-			material.roughnessMap.matrix.copy( roughnessMap.matrix );
-			_mipmapMaterial.uniforms.roughnessMap.value = roughnessMap;
-			_mipmapMaterial.uniforms.normalMap.value = normalMap;
-			const position = new THREE.Vector2( 0, 0 );
-			const texelSize = _mipmapMaterial.uniforms.texelSize.value;
-
-			for ( let mip = 0; width >= 1 && height >= 1; ++ mip, width /= 2, height /= 2 ) {
-
-				// Rendering to a mip level is not allowed in webGL1. Instead we must set
-				// up a secondary texture to write the result to, then copy it back to the
-				// proper mipmap level.
-				texelSize.set( 1.0 / width, 1.0 / height );
-				if ( mip == 0 ) texelSize.set( 0.0, 0.0 );
-
-				_tempTarget.viewport.set( position.x, position.y, width, height );
-
-				_tempTarget.scissor.set( position.x, position.y, width, height );
-
-				_renderer.setRenderTarget( _tempTarget );
-
-				_renderer.render( _mesh, _flatCamera );
-
-				_renderer.copyFramebufferToTexture( position, material.roughnessMap, mip );
-
-				_mipmapMaterial.uniforms.roughnessMap.value = material.roughnessMap;
-
-			}
-
-			roughnessMap.dispose();
-
-			_renderer.setRenderTarget( oldTarget );
-
-			_renderer.autoClear = autoClear;
-
-		}
-
-		dispose() {
-
-			_mipmapMaterial.dispose();
-
-			_mesh.geometry.dispose();
-
-			if ( _tempTarget != null ) _tempTarget.dispose();
-
-		}
-
-	}
-
-	function _getMipmapMaterial() {
-
-		const shaderMaterial = new THREE.RawShaderMaterial( {
-			uniforms: {
-				roughnessMap: {
-					value: null
-				},
-				normalMap: {
-					value: null
-				},
-				texelSize: {
-					value: new THREE.Vector2( 1, 1 )
-				}
-			},
-			vertexShader:
-    /* glsl */
-    `
-			precision mediump float;
-			precision mediump int;
-
-			attribute vec3 position;
-			attribute vec2 uv;
-
-			varying vec2 vUv;
-
-			void main() {
-
-				vUv = uv;
-
-				gl_Position = vec4( position, 1.0 );
-
-			}
-		`,
-			fragmentShader:
-    /* glsl */
-    `
-			precision mediump float;
-			precision mediump int;
-
-			varying vec2 vUv;
-
-			uniform sampler2D roughnessMap;
-			uniform sampler2D normalMap;
-			uniform vec2 texelSize;
-
-			#define ENVMAP_TYPE_CUBE_UV
-
-			vec4 envMapTexelToLinear( vec4 a ) { return a; }
-
-			#include <cube_uv_reflection_fragment>
-
-			float roughnessToVariance( float roughness ) {
-
-				float variance = 0.0;
-
-				if ( roughness >= r1 ) {
-
-					variance = ( r0 - roughness ) * ( v1 - v0 ) / ( r0 - r1 ) + v0;
-
-				} else if ( roughness >= r4 ) {
-
-					variance = ( r1 - roughness ) * ( v4 - v1 ) / ( r1 - r4 ) + v1;
-
-				} else if ( roughness >= r5 ) {
-
-					variance = ( r4 - roughness ) * ( v5 - v4 ) / ( r4 - r5 ) + v4;
-
-				} else {
-
-					float roughness2 = roughness * roughness;
-
-					variance = 1.79 * roughness2 * roughness2;
-
-				}
-
-				return variance;
-
-			}
-
-			float varianceToRoughness( float variance ) {
-
-				float roughness = 0.0;
-
-				if ( variance >= v1 ) {
-
-					roughness = ( v0 - variance ) * ( r1 - r0 ) / ( v0 - v1 ) + r0;
-
-				} else if ( variance >= v4 ) {
-
-					roughness = ( v1 - variance ) * ( r4 - r1 ) / ( v1 - v4 ) + r1;
-
-				} else if ( variance >= v5 ) {
-
-					roughness = ( v4 - variance ) * ( r5 - r4 ) / ( v4 - v5 ) + r4;
-
-				} else {
-
-					roughness = pow( 0.559 * variance, 0.25 ); // 0.559 = 1.0 / 1.79
-
-				}
-
-				return roughness;
-
-			}
-
-			void main() {
-
-				gl_FragColor = texture2D( roughnessMap, vUv, - 1.0 );
-
-				if ( texelSize.x == 0.0 ) return;
-
-				float roughness = gl_FragColor.g;
-
-				float variance = roughnessToVariance( roughness );
-
-				vec3 avgNormal;
-
-				for ( float x = - 1.0; x < 2.0; x += 2.0 ) {
-
-					for ( float y = - 1.0; y < 2.0; y += 2.0 ) {
-
-						vec2 uv = vUv + vec2( x, y ) * 0.25 * texelSize;
-
-						avgNormal += normalize( texture2D( normalMap, uv, - 1.0 ).xyz - 0.5 );
-
-					}
-
-				}
-
-				variance += 1.0 - 0.25 * length( avgNormal );
-
-				gl_FragColor.g = varianceToRoughness( variance );
-
-			}
-		`,
-			blending: THREE.NoBlending,
-			depthTest: false,
-			depthWrite: false
-		} );
-		shaderMaterial.type = 'RoughnessMipmapper';
-		return shaderMaterial;
-
-	}
-
-	THREE.RoughnessMipmapper = RoughnessMipmapper;
-
-} )();