super-three 0.136.0 → 0.141.0

package/examples/jsm/nodes/display/ColorSpaceNode.js

@@ -0,0 +1,95 @@
+import TempNode from '../core/Node.js';
+import { ShaderNode, vec3, pow, mul, sub, mix, vec4, lessThanEqual } from '../shadernode/ShaderNodeBaseElements.js';
+
+import { LinearEncoding, sRGBEncoding } from 'three';
+
+export const LinearToLinear = new ShaderNode( ( inputs ) => {
+
+	return inputs.value;
+
+} );
+
+export const LinearTosRGB = new ShaderNode( ( inputs ) => {
+
+	const { value } = inputs;
+
+	const rgb = value.rgb;
+
+	const a = sub( mul( pow( value.rgb, vec3( 0.41666 ) ), 1.055 ), vec3( 0.055 ) );
+	const b = mul( rgb, 12.92 );
+	const factor = vec3( lessThanEqual( rgb, vec3( 0.0031308 ) ) );
+
+	const rgbResult = mix( a, b, factor );
+
+	return vec4( rgbResult, value.a );
+
+} );
+
+const EncodingLib = {
+	LinearToLinear,
+	LinearTosRGB
+};
+
+class ColorSpaceNode extends TempNode {
+
+	static LINEAR_TO_LINEAR = 'LinearToLinear';
+	static LINEAR_TO_SRGB = 'LinearTosRGB';
+
+	constructor( method, node ) {
+
+		super( 'vec4' );
+
+		this.method = method;
+
+		this.node = node;
+
+	}
+
+	fromEncoding( encoding ) {
+
+		let method = null;
+
+		if ( encoding === LinearEncoding ) {
+
+			method = 'Linear';
+
+		} else if ( encoding === sRGBEncoding ) {
+
+			method = 'sRGB';
+
+		}
+
+		this.method = 'LinearTo' + method;
+
+		return this;
+
+	}
+
+	construct() {
+
+		const method = this.method;
+		const node = this.node;
+
+		let outputNode = null;
+
+		if ( method !== ColorSpaceNode.LINEAR_TO_LINEAR ) {
+
+			const encodingFunctionNode = EncodingLib[ method ];
+
+			outputNode = encodingFunctionNode.call( {
+				value: node
+			} );
+
+		} else {
+
+			outputNode = node;
+
+		}
+
+		return outputNode;
+
+	}
+
+}
+
+export default ColorSpaceNode;

package/examples/jsm/nodes/display/FrontFacingNode.js

@@ -0,0 +1,21 @@
+import Node from '../core/Node.js';
+
+class FrontFacingNode extends Node {
+
+	constructor() {
+
+		super( 'bool' );
+
+		this.isFrontFacingNode = true;
+
+	}
+
+	generate( builder ) {
+
+		return builder.getFrontFacing();
+
+	}
+
+}
+
+export default FrontFacingNode;

package/examples/jsm/nodes/display/NormalMapNode.js

@@ -0,0 +1,86 @@
+import TempNode from '../core/TempNode.js';
+import ModelNode from '../accessors/ModelNode.js';
+import { ShaderNode, positionView, normalView, uv, vec3, add, sub, mul, dFdx, dFdy, cross, max, dot, normalize, inversesqrt, faceDirection } from '../shadernode/ShaderNodeBaseElements.js';
+
+import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from 'three';
+
+// Normal Mapping Without Precomputed Tangents
+// http://www.thetenthplanet.de/archives/1180
+
+const perturbNormal2ArbNode = new ShaderNode( ( inputs ) => {
+
+	const { eye_pos, surf_norm, mapN, uv } = inputs;
+
+	const q0 = dFdx( eye_pos.xyz );
+	const q1 = dFdy( eye_pos.xyz );
+	const st0 = dFdx( uv.st );
+	const st1 = dFdy( uv.st );
+
+	const N = surf_norm; // normalized
+
+	const q1perp = cross( q1, N );
+	const q0perp = cross( N, q0 );
+
+	const T = add( mul( q1perp, st0.x ), mul( q0perp, st1.x ) );
+	const B = add( mul( q1perp, st0.y ), mul( q0perp, st1.y ) );
+
+	const det = max( dot( T, T ), dot( B, B ) );
+	const scale = mul( faceDirection, inversesqrt( det ) );
+
+	return normalize( add( mul( T, mul( mapN.x, scale ) ), mul( B, mul( mapN.y, scale ) ), mul( N, mapN.z ) ) );
+
+} );
+
+class NormalMapNode extends TempNode {
+
+	constructor( node, scaleNode = null ) {
+
+		super( 'vec3' );
+
+		this.node = node;
+		this.scaleNode = scaleNode;
+
+		this.normalMapType = TangentSpaceNormalMap;
+
+	}
+
+	construct() {
+
+		const { normalMapType, scaleNode } = this;
+
+		const normalOP = mul( this.node, 2.0 );
+		let normalMap = sub( normalOP, 1.0 );
+
+		if ( scaleNode !== null ) {
+
+			const normalMapScale = mul( normalMap.xy, scaleNode );
+			normalMap = vec3( normalMapScale, normalMap.z );
+
+		}
+
+		let outputNode = null;
+
+		if ( normalMapType === ObjectSpaceNormalMap ) {
+
+			const vertexNormalNode = mul( new ModelNode( ModelNode.NORMAL_MATRIX ), normalMap );
+
+			outputNode = normalize( vertexNormalNode );
+
+		} else if ( normalMapType === TangentSpaceNormalMap ) {
+
+			outputNode = perturbNormal2ArbNode.call( {
+				eye_pos: positionView,
+				surf_norm: normalView,
+				mapN: normalMap,
+				uv: uv()
+			} );
+
+		}
+
+		return outputNode;
+
+	}
+
+}
+
+export default NormalMapNode;

package/examples/jsm/nodes/display/ToneMappingNode.js

@@ -0,0 +1,51 @@
+import TempNode from '../core/Node.js';
+import { ShaderNode, mul, float } from '../shadernode/ShaderNodeBaseElements.js';
+
+import { LinearToneMapping } from 'three';
+
+// exposure only
+export const LinearToneMappingNode = new ShaderNode( ( { color, exposure } ) => {
+
+	return mul( color, exposure );
+
+} );
+
+class ToneMappingNode extends TempNode {
+
+	constructor( toneMapping, exposureNode = float( 1 ), colorNode = null ) {
+
+		super( 'vec3' );
+
+		this.toneMapping = toneMapping;
+
+		this.exposureNode = exposureNode;
+		this.colorNode = colorNode;
+
+	}
+
+	construct( builder ) {
+
+		const colorNode = this.color || builder.context.color;
+
+		const toneMapping = this.toneMapping;
+		const toneMappingParams = { exposure: this.exposureNode, color: colorNode };
+
+		let outputNode = null;
+
+		if ( toneMapping === LinearToneMapping ) {
+
+			outputNode = LinearToneMappingNode.call( toneMappingParams );
+
+		} else {
+
+			outputNode = this.colorNode;
+
+		}
+
+		return outputNode;
+
+	}
+
+}
+
+export default ToneMappingNode;

package/examples/jsm/nodes/fog/FogNode.js

@@ -0,0 +1,31 @@
+import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+
+class FogNode extends Node {
+
+	constructor( colorNode, factorNode ) {
+
+		super( 'float' );
+
+		this.isFogNode = true;
+
+		this.colorNode = colorNode;
+		this.factorNode = factorNode;
+
+	}
+
+	mix( outputNode ) {
+
+		return new MathNode( MathNode.MIX, outputNode, this.colorNode, this );
+
+	}
+
+	generate( builder ) {
+
+		return this.factorNode.build( builder, 'float' );
+
+	}
+
+}
+
+export default FogNode;

package/examples/jsm/nodes/fog/FogRangeNode.js

@@ -0,0 +1,27 @@
+import FogNode from './FogNode.js';
+import { smoothstep, negate, positionView } from '../shadernode/ShaderNodeBaseElements.js';
+
+class FogRangeNode extends FogNode {
+
+	constructor( colorNode, nearNode, farNode ) {
+
+		super( colorNode );
+
+		this.isFogRangeNode = true;
+
+		this.nearNode = nearNode;
+		this.farNode = farNode;
+
+	}
+
+	generate( builder ) {
+
+		this.factorNode = smoothstep( this.nearNode, this.farNode, negate( positionView.z ) );
+
+		return super.generate( builder );
+
+	}
+
+}
+
+export default FogRangeNode;

package/examples/jsm/nodes/functions/BSDF/BRDF_GGX.js

@@ -0,0 +1,33 @@
+import F_Schlick from './F_Schlick.js';
+import V_GGX_SmithCorrelated from './V_GGX_SmithCorrelated.js';
+import D_GGX from './D_GGX.js';
+import {
+	ShaderNode, dotNV, add, mul, saturate, dot, pow2, normalize,
+	transformedNormalView, positionViewDirection
+} from '../../shadernode/ShaderNodeBaseElements.js';
+
+// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
+const BRDF_GGX = new ShaderNode( ( inputs ) => {
+
+	const { lightDirection, f0, f90, roughness } = inputs;
+
+	const alpha = pow2( roughness ); // UE4's roughness
+
+	const halfDir = normalize( add( lightDirection, positionViewDirection ) );
+
+	const dotNL = saturate( dot( transformedNormalView, lightDirection ) );
+	//const dotNV = saturate( dot( transformedNormalView, positionViewDirection ) );
+	const dotNH = saturate( dot( transformedNormalView, halfDir ) );
+	const dotVH = saturate( dot( positionViewDirection, halfDir ) );
+
+	const F = F_Schlick.call( { f0, f90, dotVH } );
+
+	const V = V_GGX_SmithCorrelated.call( { alpha, dotNL, dotNV } );
+
+	const D = D_GGX.call( { alpha, dotNH } );
+
+	return mul( F, mul( V, D ) );
+
+} ); // validated
+
+export default BRDF_GGX;

package/examples/jsm/nodes/functions/BSDF/BRDF_Lambert.js

@@ -0,0 +1,9 @@
+import { ShaderNode, mul } from '../../shadernode/ShaderNodeBaseElements.js';
+
+const BRDF_Lambert = new ShaderNode( ( inputs ) => {
+
+	return mul( 1 / Math.PI, inputs.diffuseColor ); // punctual light
+
+} ); // validated
+
+export default BRDF_Lambert;

package/examples/jsm/nodes/functions/BSDF/DFGApprox.js

@@ -0,0 +1,27 @@
+import {
+	ShaderNode, dotNV, vec2, vec4, add, mul, min, exp2
+} from '../../shadernode/ShaderNodeElements.js';
+
+// Analytical approximation of the DFG LUT, one half of the
+// split-sum approximation used in indirect specular lighting.
+// via 'environmentBRDF' from "Physically Based Shading on Mobile"
+// https://www.unrealengine.com/blog/physically-based-shading-on-mobile
+const DFGApprox = new ShaderNode( ( inputs ) => {
+
+	const { roughness } = inputs;
+
+	const c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );
+
+	const c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
+
+	const r = add( mul( roughness, c0 ), c1 );
+
+	const a004 = add( mul( min( mul( r.x, r.x ), exp2( mul( - 9.28, dotNV ) ) ), r.x ), r.y );
+
+	const fab = add( mul( vec2( - 1.04, 1.04 ), a004 ), r.zw );
+
+	return fab;
+
+} );
+
+export default DFGApprox;

package/examples/jsm/nodes/functions/BSDF/D_GGX.js

@@ -0,0 +1,18 @@
+import { ShaderNode, add, sub, mul, div, pow2 } from '../../shadernode/ShaderNodeBaseElements.js';
+
+// Microfacet Models for Refraction through Rough Surfaces - equation (33)
+// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
+// alpha is "roughness squared" in Disney’s reparameterization
+const D_GGX = new ShaderNode( ( inputs ) => {
+
+	const { alpha, dotNH } = inputs;
+
+	const a2 = pow2( alpha );
+
+	const denom = add( mul( pow2( dotNH ), sub( a2, 1.0 ) ), 1.0 ); // avoid alpha = 0 with dotNH = 1
+
+	return mul( 1 / Math.PI, div( a2, pow2( denom ) ) );
+
+} ); // validated
+
+export default D_GGX;

package/examples/jsm/nodes/functions/BSDF/F_Schlick.js

@@ -0,0 +1,18 @@
+import { ShaderNode, add, sub, mul, exp2 } from '../../shadernode/ShaderNodeBaseElements.js';
+
+const F_Schlick = new ShaderNode( ( inputs ) => {
+
+	const { f0, f90, dotVH } = inputs;
+
+	// Original approximation by Christophe Schlick '94
+	// float fresnel = pow( 1.0 - dotVH, 5.0 );
+
+	// Optimized variant (presented by Epic at SIGGRAPH '13)
+	// https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
+	const fresnel = exp2( mul( sub( mul( - 5.55473, dotVH ), 6.98316 ), dotVH ) );
+
+	return add( mul( f0, sub( 1.0, fresnel ) ), mul( f90, fresnel ) );
+
+} ); // validated
+
+export default F_Schlick;

package/examples/jsm/nodes/functions/BSDF/V_GGX_SmithCorrelated.js

@@ -0,0 +1,18 @@
+import { ShaderNode, add, sub, mul, div, pow2, max, sqrt, EPSILON } from '../../shadernode/ShaderNodeBaseElements.js';
+
+// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2
+// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+const V_GGX_SmithCorrelated = new ShaderNode( ( inputs ) => {
+
+	const { alpha, dotNL, dotNV } = inputs;
+
+	const a2 = pow2( alpha );
+
+	const gv = mul( dotNL, sqrt( add( a2, mul( sub( 1.0, a2 ), pow2( dotNV ) ) ) ) );
+	const gl = mul( dotNV, sqrt( add( a2, mul( sub( 1.0, a2 ), pow2( dotNL ) ) ) ) );
+
+	return div( 0.5, max( add( gv, gl ), EPSILON ) );
+
+} ); // validated
+
+export default V_GGX_SmithCorrelated;

package/examples/jsm/nodes/functions/PhysicalLightingModel.js

@@ -0,0 +1,94 @@
+import BRDF_Lambert from './BSDF/BRDF_Lambert.js';
+import BRDF_GGX from './BSDF/BRDF_GGX.js';
+import DFGApprox from './BSDF/DFGApprox.js';
+import {
+	ShaderNode,
+	vec3, mul, saturate, add, sub, dot, div, transformedNormalView,
+	pow, exp2, dotNV,
+	diffuseColor, specularColor, roughness, temp
+} from '../shadernode/ShaderNodeElements.js';
+
+// Fdez-Agüera's "Multiple-Scattering Microfacet Model for Real-Time Image Based Lighting"
+// Approximates multiscattering in order to preserve energy.
+// http://www.jcgt.org/published/0008/01/03/
+const computeMultiscattering = ( singleScatter, multiScatter, specularF90 = 1 ) => {
+
+	const fab = DFGApprox.call( { roughness } );
+
+	const FssEss = add( mul( specularColor, fab.x ), mul( specularF90, fab.y ) );
+
+	const Ess = add( fab.x, fab.y );
+	const Ems = sub( 1.0, Ess );
+
+	const Favg = add( specularColor, mul( sub( 1.0, specularColor ), 0.047619 ) ); // 1/21
+	const Fms = div( mul( FssEss, Favg ), sub( 1.0, mul( Ems, Favg ) ) );
+
+	singleScatter.add( FssEss );
+	multiScatter.add( mul( Fms, Ems ) );
+
+};
+
+const RE_IndirectSpecular_Physical = new ShaderNode( ( inputs ) => {
+
+	const { radiance, iblIrradiance, reflectedLight } = inputs;
+
+	// Both indirect specular and indirect diffuse light accumulate here
+
+	const singleScattering = temp( vec3() );
+	const multiScattering = temp( vec3() );
+	const cosineWeightedIrradiance = mul( iblIrradiance, 1 / Math.PI );
+
+	computeMultiscattering( singleScattering, multiScattering );
+
+	const diffuse = mul( diffuseColor, sub( 1.0, add( singleScattering, multiScattering ) ) );
+
+	reflectedLight.indirectSpecular.add( mul( radiance, singleScattering ) );
+	reflectedLight.indirectSpecular.add( mul( multiScattering, cosineWeightedIrradiance ) );
+
+	reflectedLight.indirectDiffuse.add( mul( diffuse, cosineWeightedIrradiance ) );
+
+} );
+
+const RE_IndirectDiffuse_Physical = new ShaderNode( ( inputs ) => {
+
+	const { irradiance, reflectedLight } = inputs;
+
+	reflectedLight.indirectDiffuse.add( mul( irradiance, BRDF_Lambert.call( { diffuseColor } ) ) );
+
+} );
+
+const RE_Direct_Physical = new ShaderNode( ( inputs ) => {
+
+	const { lightDirection, lightColor, reflectedLight } = inputs;
+
+	const dotNL = saturate( dot( transformedNormalView, lightDirection ) );
+	const irradiance = mul( dotNL, lightColor );
+
+	reflectedLight.directDiffuse.add( mul( irradiance, BRDF_Lambert.call( { diffuseColor: diffuseColor.rgb } ) ) );
+
+	reflectedLight.directSpecular.add( mul( irradiance, BRDF_GGX.call( { lightDirection, f0: specularColor, f90: 1, roughness } ) ) );
+
+} );
+
+const RE_AmbientOcclusion_Physical = new ShaderNode( ( { ambientOcclusion, reflectedLight } ) => {
+
+	const aoNV = add( dotNV, ambientOcclusion );
+	const aoExp = exp2( sub( mul( - 16.0, roughness ), 1.0 ) );
+
+	const aoNode = saturate( add( sub( pow( aoNV, aoExp ), 1.0 ), ambientOcclusion ) );
+
+	reflectedLight.indirectDiffuse.mul( ambientOcclusion );
+
+	reflectedLight.indirectSpecular.mul( aoNode );
+
+
+} );
+
+const PhysicalLightingModel = {
+	direct: RE_Direct_Physical,
+	indirectDiffuse: RE_IndirectDiffuse_Physical,
+	indirectSpecular: RE_IndirectSpecular_Physical,
+	ambientOcclusion: RE_AmbientOcclusion_Physical
+};
+
+export default PhysicalLightingModel;

package/examples/jsm/nodes/functions/light/getDistanceAttenuation.js

@@ -0,0 +1,22 @@
+import {
+	ShaderNode, div, max, sub, mul, saturate, pow, pow2, pow4, cond, greaterThan
+} from '../../shadernode/ShaderNodeBaseElements.js';
+
+const getDistanceAttenuation = new ShaderNode( ( inputs ) => {
+
+	const { lightDistance, cutoffDistance, decayExponent } = inputs;
+
+	// based upon Frostbite 3 Moving to Physically-based Rendering
+	// page 32, equation 26: E[window1]
+	// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
+	const distanceFalloff = div( 1.0, max( pow( lightDistance, decayExponent ), 0.01 ) );
+
+	return cond(
+		greaterThan( cutoffDistance, 0 ),
+		mul( distanceFalloff, pow2( saturate( sub( 1.0, pow4( div( lightDistance, cutoffDistance ) ) ) ) ) ),
+		distanceFalloff
+	);
+
+} ); // validated
+
+export default getDistanceAttenuation;

package/examples/jsm/nodes/functions/material/getGeometryRoughness.js

@@ -0,0 +1,12 @@
+import { ShaderNode, max, abs, dFdx, dFdy, normalGeometry } from '../../shadernode/ShaderNodeBaseElements.js';
+
+const getGeometryRoughness = new ShaderNode( () => {
+
+	const dxy = max( abs( dFdx( normalGeometry ) ), abs( dFdy( normalGeometry ) ) );
+	const geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
+
+	return geometryRoughness;
+
+} );
+
+export default getGeometryRoughness;

package/examples/jsm/nodes/functions/material/getRoughness.js

@@ -0,0 +1,18 @@
+import getGeometryRoughness from './getGeometryRoughness.js';
+import { ShaderNode, add, max, min } from '../../shadernode/ShaderNodeBaseElements.js';
+
+const getRoughness = new ShaderNode( ( inputs ) => {
+
+	const { roughness } = inputs;
+
+	const geometryRoughness = getGeometryRoughness.call();
+
+	let roughnessFactor = max( roughness, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.
+	roughnessFactor = add( roughnessFactor, geometryRoughness );
+	roughnessFactor = min( roughnessFactor, 1.0 );
+
+	return roughnessFactor;
+
+} );
+
+export default getRoughness;

package/examples/jsm/nodes/gpgpu/ComputeNode.js

@@ -0,0 +1,63 @@
+import Node from '../core/Node.js';
+import { NodeUpdateType } from '../core/constants.js';
+
+class ComputeNode extends Node {
+
+	constructor( computeNode, count, workgroupSize = [ 64 ] ) {
+
+		super( 'void' );
+
+		this.isComputeNode = true;
+
+		this.computeNode = computeNode;
+
+		this.count = count;
+		this.workgroupSize = workgroupSize;
+		this.dispatchCount = 0;
+
+		this.updateType = NodeUpdateType.Object;
+
+		this.updateDispatchCount();
+
+	}
+
+	updateDispatchCount() {
+
+		const { count, workgroupSize } = this;
+
+		let size = workgroupSize[ 0 ];
+
+		for ( let i = 1; i < workgroupSize.length; i ++ )
+			size *= workgroupSize[ i ];
+
+		this.dispatchCount = Math.ceil( count / size );
+
+	}
+
+	update( { renderer } ) {
+
+		renderer.compute( this );
+
+	}
+
+	generate( builder ) {
+
+		const { shaderStage } = builder;
+
+		if ( shaderStage === 'compute' ) {
+
+			const snippet = this.computeNode.build( builder, 'void' );
+
+			if ( snippet !== '' ) {
+
+				builder.addFlowCode( snippet );
+
+			}
+
+		}
+
+	}
+
+}
+
+export default ComputeNode;

package/examples/jsm/nodes/lighting/AONode.js

@@ -0,0 +1,25 @@
+import LightingNode from './LightingNode.js';
+import { float, add, mul, sub } from '../shadernode/ShaderNodeElements.js';
+
+class AONode extends LightingNode {
+
+	constructor( aoNode = null ) {
+
+		super();
+
+		this.aoNode = aoNode;
+
+	}
+
+	construct( builder ) {
+
+		const aoIntensity = 1;
+		const aoNode = add( mul( sub( float( this.aoNode ), 1.0 ), aoIntensity ), 1.0 );
+
+		builder.context.ambientOcclusion.mul( aoNode );
+
+	}
+
+}
+
+export default AONode;