three-gpu-pathtracer 0.0.24 → 0.0.25

package/src/webgpu/nodes/sheen.wgsl.js

@@ -0,0 +1,148 @@
+import { wgslTagFn } from 'three-mesh-bvh/webgpu';
+import { surfaceRecordStruct } from './structs.wgsl.js';
+
+// TODO: LTC sheen (Zeltner et al. 2022, "Practical Multiple-Scattering Sheen Using Linearly
+// Transformed Cosines") is likely a better model and is what OpenPBR / Blender Cycles use to
+// support sheen BRDF importance sampling & energy conservation.
+
+// "Charlie" velvet, Estevez & Kulla, Imageworks 2017
+// http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+
+// See equation (2)
+const velvetDFunc = wgslTagFn/* wgsl */`
+
+	fn velvetD( cosThetaH: f32, roughness: f32 ) -> f32 {
+
+		var alpha = max( roughness, 0.07 );
+		alpha = alpha * alpha;
+
+		let invAlpha = 1.0 / alpha;
+		let sqrCosThetaH = cosThetaH * cosThetaH;
+		let sinThetaH = max( 1.0 - sqrCosThetaH, 0.001 );
+
+		return ( 2.0 + invAlpha ) * pow( sinThetaH, 0.5 * invAlpha ) / ( 2.0 * PI );
+
+	}
+
+`;
+
+const velvetParamsInterpolateFunc = wgslTagFn/* wgsl */`
+
+	fn velvetParamsInterpolate( i: i32, oneMinusAlphaSquared: f32 ) -> f32 {
+
+		let p0 = array<f32, 5>( 25.3245, 3.32435, 0.16801, - 1.27393, - 4.85967 );
+		let p1 = array<f32, 5>( 21.5473, 3.82987, 0.19823, - 1.97760, - 4.32054 );
+
+		return mix( p1[ i ], p0[ i ], oneMinusAlphaSquared );
+
+	}
+
+`;
+
+const velvetLFunc = wgslTagFn/* wgsl */`
+
+	fn velvetL( x: f32, alpha: f32 ) -> f32 {
+
+		let oneMinusAlpha = 1.0 - alpha;
+		let oneMinusAlphaSquared = oneMinusAlpha * oneMinusAlpha;
+
+		let a = ${ velvetParamsInterpolateFunc }( 0, oneMinusAlphaSquared );
+		let b = ${ velvetParamsInterpolateFunc }( 1, oneMinusAlphaSquared );
+		let c = ${ velvetParamsInterpolateFunc }( 2, oneMinusAlphaSquared );
+		let d = ${ velvetParamsInterpolateFunc }( 3, oneMinusAlphaSquared );
+		let e = ${ velvetParamsInterpolateFunc }( 4, oneMinusAlphaSquared );
+
+		return a / ( 1.0 + b * pow( abs( x ), c ) ) + d * x + e;
+
+	}
+
+`;
+
+// See equation (3)
+const velvetLambdaFunc = wgslTagFn/* wgsl */`
+
+	fn velvetLambda( cosTheta: f32, alpha: f32 ) -> f32 {
+
+		if ( abs( cosTheta ) < 0.5 ) {
+
+			return exp( ${ velvetLFunc }( cosTheta, alpha ) );
+
+		} else {
+
+			return exp( 2.0 * ${ velvetLFunc }( 0.5, alpha ) - ${ velvetLFunc }( 1.0 - cosTheta, alpha ) );
+
+		}
+
+	}
+
+`;
+
+// See Section 3, Shadowing Term
+const velvetGFunc = wgslTagFn/* wgsl */`
+
+	fn velvetG( cosThetaO: f32, cosThetaI: f32, roughness: f32 ) -> f32 {
+
+		var alpha = max( roughness, 0.07 );
+		alpha = alpha * alpha;
+
+		return 1.0 / ( 1.0 + ${ velvetLambdaFunc }( cosThetaO, alpha ) + ${ velvetLambdaFunc }( cosThetaI, alpha ) );
+
+	}
+
+`;
+
+// analytic directional albedo fit, used for energy compensation when layering ( Section 5 )
+const directionalAlbedoSheenFunc = wgslTagFn/* wgsl */`
+
+	fn directionalAlbedoSheen( cosThetaIn: f32, alpha: f32 ) -> f32 {
+
+		let cosTheta = saturate( cosThetaIn );
+		let c = 1.0 - cosTheta;
+		let c3 = c * c * c;
+
+		return 0.65584461 * c3 + 1.0 / ( 4.16526551 + exp( -7.97291361 * sqrt( alpha ) + 6.33516894 ) );
+
+	}
+
+`;
+
+// See Section 5, Layering - the factor the base lobes are attenuated by so the sheen layer
+// does not add energy on top of a fully reflective base
+export const sheenAlbedoScalingFunc = wgslTagFn/* wgsl */`
+
+	fn sheenAlbedoScaling( wo: vec3f, wi: vec3f, surf: ${ surfaceRecordStruct } ) -> f32 {
+
+		var alpha = max( surf.sheenRoughness, 0.07 );
+		alpha = alpha * alpha;
+
+		let maxSheenColor = max( max( surf.sheenColor.r, surf.sheenColor.g ), surf.sheenColor.b );
+
+		let eWo = ${ directionalAlbedoSheenFunc }( clamp( wo.z, 0.001, 1.0 ), alpha );
+		let eWi = ${ directionalAlbedoSheenFunc }( clamp( wi.z, 0.001, 1.0 ), alpha );
+
+		return min( 1.0 - maxSheenColor * eWo, 1.0 - maxSheenColor * eWi );
+
+	}
+
+`;
+
+export const sheenColorFunc = wgslTagFn/* wgsl */`
+
+	fn sheenColor( wo: vec3f, wi: vec3f, wh: vec3f, surf: ${ surfaceRecordStruct } ) -> vec3f {
+
+		let cosThetaO = clamp( wo.z, 0.001, 1.0 );
+		let cosThetaI = clamp( wi.z, 0.001, 1.0 );
+		let cosThetaH = wh.z;
+
+		let D = ${ velvetDFunc }( cosThetaH, surf.sheenRoughness );
+		let G = ${ velvetGFunc }( cosThetaO, cosThetaI, surf.sheenRoughness );
+
+		// See equation (1) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
+		var color = surf.sheenColor;
+		color *= D * G / ( 4.0 * abs( cosThetaO * cosThetaI ) );
+
+		return color;
+
+	}
+
+`;

package/src/webgpu/nodes/structs.wgsl.js

@@ -0,0 +1,272 @@
+import { wgsl } from 'three/tsl';
+import { StructTypeNode } from 'three/webgpu';
+
+// TODO: Move to node-based constants that are embedded with wgslTagFn
+export const constants = wgsl( /* wgsl */ `
+
+	const PI: f32 = 3.141592653589793;
+	const EPSILON: f32 = 1e-5;
+	const MIN_ROUGHNESS: f32 = 1e-3;
+	const MIN_INCIDENT_COS: f32 = 1e-3;
+
+` );
+
+export const scatterRecordStruct = new StructTypeNode( {
+	color: 'vec3f',
+	isTransmissive: 'bool',
+	direction: 'vec3f',
+	pdf: 'float',
+}, 'ScatterRecord' );
+
+export const transmissionFresnelStruct = new StructTypeNode( {
+	reflectance: 'vec3f',
+	transmittance: 'vec3f',
+	reflectProbability: 'float',
+}, 'TransmissionFresnel' );
+
+// NOTE: all "*Map" fields are bit-packed integers of texture index & settings:
+// bits 0-22: texture index
+// bits 23-25: uv channel
+// bits 26-27: wrapS setting
+// bits 28-29: wrapT setting
+// bit 30: filter setting
+// bit 31: negative bit used for indicating unused texture
+export const materialStruct = new StructTypeNode( {
+	// offset 0
+	color: 'vec3',
+	map: 'int',
+
+	// offset 4 floats
+	metalness: 'float',
+	metalnessMap: 'int',
+
+	roughness: 'float',
+	roughnessMap: 'int',
+
+	// offset 8 floats
+	ior: 'float',
+	transmission: 'float',
+	transmissionMap: 'int',
+
+	emissiveIntensity: 'float',
+	// offset 12 floats
+	emissive: 'vec3',
+	emissiveMap: 'int',
+
+	// offset 16 floats
+	normalMap: 'int',
+	normalScale: 'vec2',
+
+	// offset 20 floats
+	clearcoat: 'float',
+	clearcoatMap: 'int',
+	clearcoatNormalMap: 'int',
+	// offset 24 floats
+	clearcoatNormalScale: 'vec2',
+	clearcoatRoughness: 'float',
+	clearcoatRoughnessMap: 'int',
+
+	// offset 28 floats
+	iridescenceMap: 'int',
+	iridescenceThicknessMap: 'int',
+	iridescence: 'float',
+	iridescenceIor: 'float',
+	// offset 32 floats
+	iridescenceThicknessMinimum: 'float',
+	iridescenceThicknessMaximum: 'float',
+	diffuseRoughness: 'float',
+	dispersion: 'float',
+
+	// offset 36 floats
+	specularColor: 'vec3',
+	specularColorMap: 'int',
+
+	// offset 40 floats
+	specularIntensity: 'float',
+	specularIntensityMap: 'int',
+	thinWall: 'int', // actually a boolean
+
+	// offset 44 floats
+	attenuationColor: 'vec3',
+	attenuationDistance: 'float',
+
+	// offset 48 floats
+	alphaMap: 'int',
+
+	castShadow: 'int', // actually a boolean
+	opacity: 'float',
+	alphaTest: 'float',
+
+	// offset 52 floats
+	side: 'float',
+	matte: 'int', // actually a boolean
+
+	sheen: 'float',
+	// offset 56 floats
+	sheenColor: 'vec3',
+	sheenColorMap: 'int',
+	// offset 60 floats
+	sheenRoughness: 'float',
+	sheenRoughnessMap: 'int',
+
+	// All those are booleans
+	vertexColors: 'int',
+	flatShading: 'int',
+	// offset 64 floats
+	transparent: 'int',
+	fogVolume: 'int',
+	// offset 66 floats
+	anisotropy: 'float',
+	anisotropyRotation: 'float',
+	// offset 68 floats
+	anisotropyMap: 'int',
+
+	// offset 72 floats
+	mapTransform: 'mat3',
+	// offset 84 floats
+	metalnessMapTransform: 'mat3',
+	// offset 96 floats
+	roughnessMapTransform: 'mat3',
+	// offset 108 floats
+	transmissionMapTransform: 'mat3',
+	// offset 120 floats
+	emissiveMapTransform: 'mat3',
+	// offset 132 floats
+	normalMapTransform: 'mat3',
+	// offset 144 floats
+	clearcoatMapTransform: 'mat3',
+	// offset 156 floats
+	clearcoatNormalMapTransform: 'mat3',
+	// offset 168 floats
+	clearcoatRoughnessMapTransform: 'mat3',
+	// offset 180 floats
+	sheenColorMapTransform: 'mat3',
+	// offset 192 floats
+	sheenRoughnessMapTransform: 'mat3',
+	// offset 204 floats
+	iridescenceMapTransform: 'mat3',
+	// offset 216 floats
+	iridescenceThicknessMapTransform: 'mat3',
+	// offset 228 floats
+	specularColorMapTransform: 'mat3',
+	// offset 240 floats
+	specularIntensityMapTransform: 'mat3',
+	// offset 252 floats
+	alphaMapTransform: 'mat3',
+
+	// offset 264 floats
+	anisotropyMapTransform: 'mat3',
+	// total size = 276
+}, 'Material' );
+
+export const surfaceRecordStruct = new StructTypeNode( {
+	// surface type
+	volumeParticle: 'bool',
+
+	// geometry
+	faceNormal: 'vec3f',
+	frontFace: 'bool',
+	normal: 'vec3f',
+	normalBasis: 'mat3x3f',
+	normalInvBasis: 'mat3x3f',
+
+	// cached properties
+	eta: 'f32',
+	f0: 'f32',
+
+	// material
+	roughness: 'f32',
+	diffuseRoughness: 'f32',
+	metalness: 'f32',
+	anisotropy: 'f32',
+	color: 'vec3f',
+	emission: 'vec3f',
+	opacity: 'f32',
+
+	// transmission
+	ior: 'f32',
+	transmission: 'f32',
+	thinWall: 'bool',
+	attenuationColor: 'vec3f',
+	attenuationDistance: ' f32',
+
+	// clearcoat
+	clearcoatNormal: 'vec3f',
+	clearcoatBasis: 'mat3x3f',
+	clearcoatInvBasis: 'mat3x3f',
+	clearcoat: 'f32',
+	clearcoatRoughness: 'f32',
+
+	// sheen
+	sheen: 'f32',
+	sheenColor: 'vec3f',
+	sheenRoughness: 'f32',
+
+	// iridescence
+	iridescence: 'f32',
+	iridescenceIor: 'f32',
+	iridescenceThickness: 'f32',
+
+	// specular
+	specularColor: 'vec3f',
+	specularIntensity: 'f32',
+}, 'SurfaceRecord' );
+
+export const environmentInfoStruct = new StructTypeNode( {
+	rotation: 'mat3x3f',
+	intensity: 'float',
+	blur: 'float',
+	totalSum: 'float',
+}, 'EnvironmentInfo' );
+
+// Result of importance-sampling the environment map: a world-space direction,
+// its radiance, and the pdf (in solid-angle measure) of having sampled it.
+export const environmentSampleStruct = new StructTypeNode( {
+	color: 'vec3f',
+	direction: 'vec3f',
+	pdf: 'float',
+}, 'EnvironmentSample' );
+
+// A single scene light unpacked from the lights data texture.
+export const lightStruct = new StructTypeNode( {
+	position: 'vec3f',
+	lightType: 'int',
+	color: 'vec3f',
+	intensity: 'float',
+	u: 'vec3f',
+	v: 'vec3f',
+	area: 'float',
+	radius: 'float',
+	decay: 'float',
+	distance: 'float',
+	coneCos: 'float',
+	penumbraCos: 'float',
+	iesProfile: 'int',
+}, 'Light' );
+
+// Result of sampling (or intersecting) a light: a world-space direction toward the light,
+// the distance to it, its emitted radiance, and the pdf (solid-angle measure) of the sample.
+export const lightRecordStruct = new StructTypeNode( {
+	dist: 'float',
+	direction: 'vec3f',
+	pdf: 'float',
+	emission: 'vec3f',
+	lightType: 'int',
+}, 'LightRecord' );
+
+export const lobeWeightsStruct = new StructTypeNode( {
+	diffuse: 'float',
+	specular: 'float',
+	transmission: 'float',
+	clearcoat: 'float',
+}, 'LobeWeights' );
+
+export const bxdfContextStruct = new StructTypeNode( {
+
+	V: 'vec3f', // view dir
+	L: 'vec3f', // light dir
+	H: 'vec3f', // half dir
+
+	VdotH: 'float',
+
+}, 'BxDFContext' );