three-gpu-pathtracer 0.0.3 → 0.0.4

package/src/shader/shaderStructs.js

@@ -41,17 +41,42 @@ export const shaderMaterialStructs = /* glsl */ `
 		int normalMap;
 		vec2 normalScale;
 
+		int alphaMap;
+
+		bool castShadow;
 		float opacity;
 		float alphaTest;
 
 		float side;
 		bool matte;
 
+		mat3 mapTransform;
+		mat3 metalnessMapTransform;
+		mat3 roughnessMapTransform;
+		mat3 transmissionMapTransform;
+		mat3 emissiveMapTransform;
+		mat3 normalMapTransform;
+
 	};
 
+	mat3 readTextureTransform( sampler2D tex, uint index ) {
+
+		mat3 textureTransform;
+
+		vec4 row1 = texelFetch1D( tex, index );
+		vec4 row2 = texelFetch1D( tex, index + 1u );
+
+		textureTransform[0] = vec3(row1.r, row2.r, 0.0);
+		textureTransform[1] = vec3(row1.g, row2.g, 0.0);
+		textureTransform[2] = vec3(row1.b, row2.b, 1.0);
+
+		return textureTransform;
+
+	}
+
 	Material readMaterialInfo( sampler2D tex, uint index ) {
 
-		uint i = index * 6u;
+		uint i = index * 19u;
 
 		vec4 s0 = texelFetch1D( tex, i + 0u );
 		vec4 s1 = texelFetch1D( tex, i + 1u );
@@ -59,32 +84,46 @@ export const shaderMaterialStructs = /* glsl */ `
 		vec4 s3 = texelFetch1D( tex, i + 3u );
 		vec4 s4 = texelFetch1D( tex, i + 4u );
 		vec4 s5 = texelFetch1D( tex, i + 5u );
+		vec4 s6 = texelFetch1D( tex, i + 6u );
 
 		Material m;
 		m.color = s0.rgb;
-		m.map = floatBitsToInt( s0.a );
+		m.map = int( round( s0.a ) );
 
 		m.metalness = s1.r;
-		m.metalnessMap = floatBitsToInt( s1.g );
+		m.metalnessMap = int( round( s1.g ) );
 		m.roughness = s1.b;
-		m.roughnessMap = floatBitsToInt( s1.a );
+		m.roughnessMap = int( round( s1.a ) );
 
 		m.ior = s2.r;
 		m.transmission = s2.g;
-		m.transmissionMap = floatBitsToInt( s2.b );
+		m.transmissionMap = int( round( s2.b ) );
 		m.emissiveIntensity = s2.a;
 
 		m.emissive = s3.rgb;
-		m.emissiveMap = floatBitsToInt( s3.a );
+		m.emissiveMap = int( round( s3.a ) );
 
-		m.normalMap = floatBitsToInt( s4.r );
+		m.normalMap = int( round( s4.r ) );
 		m.normalScale = s4.gb;
 
+		m.alphaMap = int( round( s4.a ) );
+
 		m.opacity = s5.r;
 		m.alphaTest = s5.g;
 		m.side = s5.b;
 		m.matte = bool( s5.a );
 
+		m.castShadow = ! bool( s6.r );
+
+		uint firstTextureTransformIdx = i + 7u;
+
+		m.mapTransform = m.map == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx);
+		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );
+		m.roughnessMapTransform = m.roughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 4u );
+		m.transmissionMapTransform = m.transmissionMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 6u );
+		m.emissiveMapTransform = m.emissiveMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 8u );
+		m.normalMapTransform = m.normalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 10u );
+
 		return m;
 
 	}

package/src/shader/shaderUtils.js

@@ -1,228 +1,246 @@
-export const shaderUtils = /* glsl */`
-
-	// https://google.github.io/filament/Filament.md.html#materialsystem/diffusebrdf
-	float schlickFresnel( float cosine, float f0 ) {
-
-		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
-
-	}
-
-	// https://raytracing.github.io/books/RayTracingInOneWeekend.html#dielectrics/schlickapproximation
-	float schlickFresnelFromIor( float cosine, float iorRatio ) {
-
-		// Schlick approximation
-		float r_0 = pow( ( 1.0 - iorRatio ) / ( 1.0 + iorRatio ), 2.0 );
-		return schlickFresnel( cosine, r_0 );
-
-	}
-
-	// forms a basis with the normal vector as Z
-	mat3 getBasisFromNormal( vec3 normal ) {
-
-		vec3 other;
-		if ( abs( normal.x ) > 0.5 ) {
-
-			other = vec3( 0.0, 1.0, 0.0 );
-
-		} else {
-
-			other = vec3( 1.0, 0.0, 0.0 );
-
-		}
-
-		vec3 ortho = normalize( cross( normal, other ) );
-		vec3 ortho2 = normalize( cross( normal, ortho ) );
-		return mat3( ortho2, ortho, normal );
-
-	}
-
-	vec3 getHalfVector( vec3 a, vec3 b ) {
-
-		return normalize( a + b );
-
-	}
-
-	// The discrepancy between interpolated surface normal and geometry normal can cause issues when a ray
-	// is cast that is on the top side of the geometry normal plane but below the surface normal plane. If
-	// we find a ray like that we ignore it to avoid artifacts.
-	// This function returns if the direction is on the same side of both planes.
-	bool isDirectionValid( vec3 direction, vec3 surfaceNormal, vec3 geometryNormal ) {
-
-		bool aboveSurfaceNormal = dot( direction, surfaceNormal ) > 0.0;
-		bool aboveGeometryNormal = dot( direction, geometryNormal ) > 0.0;
-		return aboveSurfaceNormal == aboveGeometryNormal;
-
-	}
-
-	vec3 getHemisphereSample( vec3 n, vec2 uv ) {
-
-		// https://www.rorydriscoll.com/2009/01/07/better-sampling/
-		// https://graphics.pixar.com/library/OrthonormalB/paper.pdf
-		float sign = n.z == 0.0 ? 1.0 : sign( n.z );
-		float a = - 1.0 / ( sign + n.z );
-		float b = n.x * n.y * a;
-		vec3 b1 = vec3( 1.0 + sign * n.x * n.x * a, sign * b, - sign * n.x );
-		vec3 b2 = vec3( b, sign + n.y * n.y * a, - n.y );
-
-		float r = sqrt( uv.x );
-		float theta = 2.0 * PI * uv.y;
-		float x = r * cos( theta );
-		float y = r * sin( theta );
-		return x * b1 + y * b2 + sqrt( 1.0 - uv.x ) * n;
-
-	}
-
-	// https://www.shadertoy.com/view/wltcRS
-	uvec4 s0;
-
-	void rng_initialize(vec2 p, int frame) {
-
-		// white noise seed
-		s0 = uvec4( p, uint( frame ), uint( p.x ) + uint( p.y ) );
-
-	}
-
-	// https://www.pcg-random.org/
-	void pcg4d( inout uvec4 v ) {
-
-		v = v * 1664525u + 1013904223u;
-		v.x += v.y * v.w;
-		v.y += v.z * v.x;
-		v.z += v.x * v.y;
-		v.w += v.y * v.z;
-		v = v ^ ( v >> 16u );
-		v.x += v.y*v.w;
-		v.y += v.z*v.x;
-		v.z += v.x*v.y;
-		v.w += v.y*v.z;
-
-	}
-
-	// returns [ 0, 1 ]
-	float rand() {
-
-		pcg4d(s0);
-		return float( s0.x ) / float( 0xffffffffu );
-
-	}
-
-	vec2 rand2() {
-
-		pcg4d( s0 );
-		return vec2( s0.xy ) / float(0xffffffffu);
-
-	}
-
-	vec3 rand3() {
-
-		pcg4d(s0);
-		return vec3( s0.xyz ) / float( 0xffffffffu );
-
-	}
-
-	vec4 rand4() {
-
-		pcg4d(s0);
-		return vec4(s0)/float(0xffffffffu);
-
-	}
-
-	// https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js#L724
-	vec3 randDirection() {
-
-		vec2 r = rand2();
-		float u = ( r.x - 0.5 ) * 2.0;
-		float t = r.y * PI * 2.0;
-		float f = sqrt( 1.0 - u * u );
-
-		return vec3( f * cos( t ), f * sin( t ), u );
-
-	}
-
-	vec2 triangleSample( vec2 a, vec2 b, vec2 c ) {
-
-		// get the edges of the triangle and the diagonal across the
-		// center of the parallelogram
-		vec2 e1 = a - b;
-		vec2 e2 = c - b;
-		vec2 diag = normalize( e1 + e2 );
-
-		// pick a random point in the parallelogram
-		vec2 r = rand2();
-		if ( r.x + r.y > 1.0 ) {
-
-			r = vec2( 1.0 ) - r;
-
-		}
-
-		return e1 * r.x + e2 * r.y;
-
-	}
-
-	// samples an aperture shape with the given number of sides. 0 means circle
-	vec2 sampleAperture( int blades ) {
-
-		if ( blades == 0 ) {
-
-			vec2 r = rand2();
-			float angle = 2.0 * PI * r.x;
-			float radius = sqrt( rand() );
-			return vec2( cos( angle ), sin( angle ) ) * radius;
-
-		} else {
-
-			blades = max( blades, 3 );
-
-			vec3 r = rand3();
-			float anglePerSegment = 2.0 * PI / float( blades );
-			float segment = floor( float( blades ) * r.x );
-
-			float angle1 = anglePerSegment * segment;
-			float angle2 = angle1 + anglePerSegment;
-			vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
-			vec2 b = vec2( 0.0, 0.0 );
-			vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
-
-			return triangleSample( a, b, c );
-
-		}
-
-	}
-
-	float colorToLuminance( vec3 color ) {
-
-		// https://en.wikipedia.org/wiki/Relative_luminance
-		return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
-
-	}
-
-	// ray sampling x and z are swapped to align with expected background view
-	vec2 equirectDirectionToUv( vec3 direction ) {
-
-		// from Spherical.setFromCartesianCoords
-		vec2 uv = vec2( atan( direction.z, direction.x ), acos( direction.y ) );
-		uv /= vec2( 2.0 * PI, PI );
-
-		// apply adjustments to get values in range [0, 1] and y right side up
-		uv.x += 0.5;
-		uv.y = 1.0 - uv.y;
-		return uv;
-
-	}
-
-	vec3 equirectUvToDirection( vec2 uv ) {
-
-		// undo above adjustments
-		uv.x -= 0.5;
-		uv.y = 1.0 - uv.y;
-
-		// from Vector3.setFromSphericalCoords
-		float theta = uv.x * 2.0 * PI;
-		float phi = uv.y * PI;
-
-		float sinPhi = sin( phi );
-
-		return vec3( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );
-
-	}
-`;
+export const shaderUtils = /* glsl */`
+
+	// https://google.github.io/filament/Filament.md.html#materialsystem/diffusebrdf
+	float schlickFresnel( float cosine, float f0 ) {
+
+		return f0 + ( 1.0 - f0 ) * pow( 1.0 - cosine, 5.0 );
+
+	}
+
+	// https://raytracing.github.io/books/RayTracingInOneWeekend.html#dielectrics/schlickapproximation
+	float schlickFresnelFromIor( float cosine, float iorRatio ) {
+
+		// Schlick approximation
+		float r_0 = pow( ( 1.0 - iorRatio ) / ( 1.0 + iorRatio ), 2.0 );
+		return schlickFresnel( cosine, r_0 );
+
+	}
+
+	// forms a basis with the normal vector as Z
+	mat3 getBasisFromNormal( vec3 normal ) {
+
+		vec3 other;
+		if ( abs( normal.x ) > 0.5 ) {
+
+			other = vec3( 0.0, 1.0, 0.0 );
+
+		} else {
+
+			other = vec3( 1.0, 0.0, 0.0 );
+
+		}
+
+		vec3 ortho = normalize( cross( normal, other ) );
+		vec3 ortho2 = normalize( cross( normal, ortho ) );
+		return mat3( ortho2, ortho, normal );
+
+	}
+
+	vec3 getHalfVector( vec3 a, vec3 b ) {
+
+		return normalize( a + b );
+
+	}
+
+	// The discrepancy between interpolated surface normal and geometry normal can cause issues when a ray
+	// is cast that is on the top side of the geometry normal plane but below the surface normal plane. If
+	// we find a ray like that we ignore it to avoid artifacts.
+	// This function returns if the direction is on the same side of both planes.
+	bool isDirectionValid( vec3 direction, vec3 surfaceNormal, vec3 geometryNormal ) {
+
+		bool aboveSurfaceNormal = dot( direction, surfaceNormal ) > 0.0;
+		bool aboveGeometryNormal = dot( direction, geometryNormal ) > 0.0;
+		return aboveSurfaceNormal == aboveGeometryNormal;
+
+	}
+
+	vec3 getHemisphereSample( vec3 n, vec2 uv ) {
+
+		// https://www.rorydriscoll.com/2009/01/07/better-sampling/
+		// https://graphics.pixar.com/library/OrthonormalB/paper.pdf
+		float sign = n.z == 0.0 ? 1.0 : sign( n.z );
+		float a = - 1.0 / ( sign + n.z );
+		float b = n.x * n.y * a;
+		vec3 b1 = vec3( 1.0 + sign * n.x * n.x * a, sign * b, - sign * n.x );
+		vec3 b2 = vec3( b, sign + n.y * n.y * a, - n.y );
+
+		float r = sqrt( uv.x );
+		float theta = 2.0 * PI * uv.y;
+		float x = r * cos( theta );
+		float y = r * sin( theta );
+		return x * b1 + y * b2 + sqrt( 1.0 - uv.x ) * n;
+
+	}
+
+	// https://www.shadertoy.com/view/wltcRS
+	uvec4 s0;
+
+	void rng_initialize(vec2 p, int frame) {
+
+		// white noise seed
+		s0 = uvec4( p, uint( frame ), uint( p.x ) + uint( p.y ) );
+
+	}
+
+	// https://www.pcg-random.org/
+	void pcg4d( inout uvec4 v ) {
+
+		v = v * 1664525u + 1013904223u;
+		v.x += v.y * v.w;
+		v.y += v.z * v.x;
+		v.z += v.x * v.y;
+		v.w += v.y * v.z;
+		v = v ^ ( v >> 16u );
+		v.x += v.y*v.w;
+		v.y += v.z*v.x;
+		v.z += v.x*v.y;
+		v.w += v.y*v.z;
+
+	}
+
+	// returns [ 0, 1 ]
+	float rand() {
+
+		pcg4d(s0);
+		return float( s0.x ) / float( 0xffffffffu );
+
+	}
+
+	vec2 rand2() {
+
+		pcg4d( s0 );
+		return vec2( s0.xy ) / float(0xffffffffu);
+
+	}
+
+	vec3 rand3() {
+
+		pcg4d(s0);
+		return vec3( s0.xyz ) / float( 0xffffffffu );
+
+	}
+
+	vec4 rand4() {
+
+		pcg4d(s0);
+		return vec4(s0)/float(0xffffffffu);
+
+	}
+
+	// https://github.com/mrdoob/three.js/blob/dev/src/math/Vector3.js#L724
+	vec3 randDirection() {
+
+		vec2 r = rand2();
+		float u = ( r.x - 0.5 ) * 2.0;
+		float t = r.y * PI * 2.0;
+		float f = sqrt( 1.0 - u * u );
+
+		return vec3( f * cos( t ), f * sin( t ), u );
+
+	}
+
+	vec2 triangleSample( vec2 a, vec2 b, vec2 c ) {
+
+		// get the edges of the triangle and the diagonal across the
+		// center of the parallelogram
+		vec2 e1 = a - b;
+		vec2 e2 = c - b;
+		vec2 diag = normalize( e1 + e2 );
+
+		// pick a random point in the parallelogram
+		vec2 r = rand2();
+		if ( r.x + r.y > 1.0 ) {
+
+			r = vec2( 1.0 ) - r;
+
+		}
+
+		return e1 * r.x + e2 * r.y;
+
+	}
+
+	// samples an aperture shape with the given number of sides. 0 means circle
+	vec2 sampleAperture( int blades ) {
+
+		if ( blades == 0 ) {
+
+			vec2 r = rand2();
+			float angle = 2.0 * PI * r.x;
+			float radius = sqrt( rand() );
+			return vec2( cos( angle ), sin( angle ) ) * radius;
+
+		} else {
+
+			blades = max( blades, 3 );
+
+			vec3 r = rand3();
+			float anglePerSegment = 2.0 * PI / float( blades );
+			float segment = floor( float( blades ) * r.x );
+
+			float angle1 = anglePerSegment * segment;
+			float angle2 = angle1 + anglePerSegment;
+			vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
+			vec2 b = vec2( 0.0, 0.0 );
+			vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
+
+			return triangleSample( a, b, c );
+
+		}
+
+	}
+
+	float colorToLuminance( vec3 color ) {
+
+		// https://en.wikipedia.org/wiki/Relative_luminance
+		return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
+
+	}
+
+	// ray sampling x and z are swapped to align with expected background view
+	vec2 equirectDirectionToUv( vec3 direction ) {
+
+		// from Spherical.setFromCartesianCoords
+		vec2 uv = vec2( atan( direction.z, direction.x ), acos( direction.y ) );
+		uv /= vec2( 2.0 * PI, PI );
+
+		// apply adjustments to get values in range [0, 1] and y right side up
+		uv.x += 0.5;
+		uv.y = 1.0 - uv.y;
+		return uv;
+
+	}
+
+	vec3 equirectUvToDirection( vec2 uv ) {
+
+		// undo above adjustments
+		uv.x -= 0.5;
+		uv.y = 1.0 - uv.y;
+
+		// from Vector3.setFromSphericalCoords
+		float theta = uv.x * 2.0 * PI;
+		float phi = uv.y * PI;
+
+		float sinPhi = sin( phi );
+
+		return vec3( sinPhi * cos( theta ), cos( phi ), sinPhi * sin( theta ) );
+
+	}
+
+	// Fast arccos approximation used to remove banding artifacts caused by numerical errors in acos.
+	// This is a cubic Lagrange interpolating polynomial for x = [-1, -1/2, 0, 1/2, 1].
+	// For more information see: https://github.com/gkjohnson/three-gpu-pathtracer/pull/171#issuecomment-1152275248
+	float acosApprox( float x ) {
+
+		x = clamp( x, -1.0, 1.0 );
+		return ( - 0.69813170079773212 * x * x - 0.87266462599716477 ) * x + 1.5707963267948966;
+
+	}
+
+	// An acos with input values bound to the range [-1, 1].
+	float acosSafe( float x ) {
+
+		return acos( clamp( x, -1.0, 1.0 ) );
+
+	}
+
+`;