@needle-tools/three 0.146.9 → 0.153.0

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

@@ -0,0 +1,67 @@
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+import { viewportTopLeft } from './ViewportNode.js';
+import { Vector2, FramebufferTexture } from 'three';
+
+const _size = new Vector2();
+
+class ViewportTextureNode extends TextureNode {
+
+	constructor( uv = viewportTopLeft, level = null ) {
+
+		super( null, uv, level );
+
+		this.isOutputTextureNode = true;
+
+		this.updateBeforeType = NodeUpdateType.FRAME;
+
+	}
+
+	constructFramebuffer( /*builder*/ ) {
+
+		return new FramebufferTexture();
+
+	}
+
+	construct( builder ) {
+
+		if ( this.value === null ) this.value = this.constructFramebuffer( builder );
+
+		return super.construct( builder );
+
+	}
+
+	updateBefore( frame ) {
+
+		const renderer = frame.renderer;
+		renderer.getDrawingBufferSize( _size );
+
+		//
+
+		const framebufferTexture = this.value;
+
+		if ( framebufferTexture.image.width !== _size.width || framebufferTexture.image.height !== _size.height ) {
+
+			framebufferTexture.image.width = _size.width;
+			framebufferTexture.image.height = _size.height;
+			framebufferTexture.needsUpdate = true;
+
+		}
+
+		//
+
+		renderer.copyFramebufferToTexture( framebufferTexture );
+
+	}
+
+}
+
+export default ViewportTextureNode;
+
+export const viewportTexture = nodeProxy( ViewportTextureNode );
+
+addNodeElement( 'viewportTexture', viewportTexture );
+
+addNodeClass( ViewportTextureNode );

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

@@ -0,0 +1,35 @@
+import FogNode from './FogNode.js';
+import { positionView } from '../accessors/PositionNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+class FogExp2Node extends FogNode {
+
+	constructor( colorNode, densityNode ) {
+
+		super( colorNode );
+
+		this.isFogExp2Node = true;
+
+		this.densityNode = densityNode;
+
+	}
+
+	construct() {
+
+		const depthNode = positionView.z.negate();
+		const densityNode = this.densityNode;
+
+		return densityNode.mul( densityNode, depthNode, depthNode ).negate().exp().oneMinus();
+
+	}
+
+}
+
+export default FogExp2Node;
+
+export const densityFog = nodeProxy( FogExp2Node );
+
+addNodeElement( 'densityFog', densityFog );
+
+addNodeClass( FogExp2Node );

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

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import MathNode from '../math/MathNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class FogNode extends Node {
 
@@ -14,18 +14,24 @@ class FogNode extends Node {
 
 	}
 
-	mix( outputNode ) {
+	mixAssign( outputNode ) {
 
-		return new MathNode( MathNode.MIX, outputNode, this.colorNode, this );
+		return this.mix( outputNode, this.colorNode );
 
 	}
 
-	generate( builder ) {
+	construct() {
 
-		return this.factorNode.build( builder, 'float' );
+		return this.factorNode;
 
 	}
 
 }
 
 export default FogNode;
+
+export const fog = nodeProxy( FogNode );
+
+addNodeElement( 'fog', fog );
+
+addNodeClass( FogNode );

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

@@ -1,5 +1,8 @@
 import FogNode from './FogNode.js';
-import { smoothstep, negate, positionView } from '../shadernode/ShaderNodeBaseElements.js';
+import { smoothstep } from '../math/MathNode.js';
+import { positionView } from '../accessors/PositionNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class FogRangeNode extends FogNode {
 
@@ -14,14 +17,18 @@ class FogRangeNode extends FogNode {
 
 	}
 
-	generate( builder ) {
+	construct() {
 
-		this.factorNode = smoothstep( this.nearNode, this.farNode, negate( positionView.z ) );
-
-		return super.generate( builder );
+		return smoothstep( this.nearNode, this.farNode, positionView.z.negate() );
 
 	}
 
 }
 
 export default FogRangeNode;
+
+export const rangeFog = nodeProxy( FogRangeNode );
+
+addNodeElement( 'rangeFog', rangeFog );
+
+addNodeClass( FogRangeNode );

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

@@ -0,0 +1,30 @@
+import F_Schlick from './F_Schlick.js';
+import { shininess, specularColor } from '../../core/PropertyNode.js';
+import { transformedNormalView } from '../../accessors/NormalNode.js';
+import { positionViewDirection } from '../../accessors/PositionNode.js';
+import { ShaderNode, float } from '../../shadernode/ShaderNode.js';
+
+const G_BlinnPhong_Implicit = () => float( 0.25 );
+
+const D_BlinnPhong = new ShaderNode( ( { dotNH } ) => {
+
+	return shininess.mul( 0.5 / Math.PI ).add( 1.0 ).mul( dotNH.pow( shininess ) );
+
+} );
+
+const BRDF_BlinnPhong = new ShaderNode( ( { lightDirection } ) => {
+
+	const halfDir = lightDirection.add( positionViewDirection ).normalize();
+
+	const dotNH = transformedNormalView.dot( halfDir ).clamp();
+	const dotVH = positionViewDirection.dot( halfDir ).clamp();
+
+	const F = F_Schlick.call( { f0: specularColor, f90: 1.0, dotVH } );
+	const G = G_BlinnPhong_Implicit();
+	const D = D_BlinnPhong.call( { dotNH } );
+
+	return F.mul( G ).mul( D );
+
+} );
+
+export default BRDF_BlinnPhong;

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

@@ -1,32 +1,29 @@
 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, clamp, dot, pow2, normalize,
-	transformedNormalView, positionViewDirection
-} from '../../shadernode/ShaderNodeBaseElements.js';
+import { transformedNormalView } from '../../accessors/NormalNode.js';
+import { positionViewDirection } from '../../accessors/PositionNode.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.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 alpha = roughness.pow2(); // UE4's roughness
 
-	const halfDir = normalize( add( lightDirection, positionViewDirection ) );
+	const halfDir = lightDirection.add( positionViewDirection ).normalize();
 
-	const dotNL = clamp( dot( transformedNormalView, lightDirection ) );
-	//const dotNV = clamp( dot( transformedNormalView, positionViewDirection ) );
-	const dotNH = clamp( dot( transformedNormalView, halfDir ) );
-	const dotVH = clamp( dot( positionViewDirection, halfDir ) );
+	const dotNL = transformedNormalView.dot( lightDirection ).clamp();
+	const dotNV = transformedNormalView.dot( positionViewDirection ).clamp();
+	const dotNH = transformedNormalView.dot( halfDir ).clamp();
+	const dotVH = positionViewDirection.dot( halfDir ).clamp();
 
 	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 ) );
+	return F.mul( V ).mul( D );
 
 } ); // validated
 

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

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

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

@@ -1,6 +1,6 @@
-import {
-	ShaderNode, dotNV, vec2, vec4, add, mul, min, exp2
-} from '../../shadernode/ShaderNodeElements.js';
+import { transformedNormalView } from '../../accessors/NormalNode.js';
+import { positionViewDirection } from '../../accessors/PositionNode.js';
+import { ShaderNode, vec2, vec4 } from '../../shadernode/ShaderNode.js';
 
 // Analytical approximation of the DFG LUT, one half of the
 // split-sum approximation used in indirect specular lighting.
@@ -14,11 +14,13 @@ const DFGApprox = new ShaderNode( ( inputs ) => {
 
 	const c1 = vec4( 1, 0.0425, 1.04, - 0.04 );
 
-	const r = add( mul( roughness, c0 ), c1 );
+	const r = roughness.mul( c0 ).add( c1 );
 
-	const a004 = add( mul( min( mul( r.x, r.x ), exp2( mul( - 9.28, dotNV ) ) ), r.x ), r.y );
+	const dotNV = transformedNormalView.dot( positionViewDirection ).clamp();
 
-	const fab = add( mul( vec2( - 1.04, 1.04 ), a004 ), r.zw );
+	const a004 = r.x.mul( r.x ).min( dotNV.mul( - 9.28 ).exp2() ).mul( r.x ).add( r.y );
+
+	const fab = vec2( - 1.04, 1.04 ).mul( a004 ).add( r.zw );
 
 	return fab;
 

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

@@ -1,4 +1,4 @@
-import { ShaderNode, add, sub, mul, div, pow2 } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)
 // http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
@@ -7,11 +7,11 @@ const D_GGX = new ShaderNode( ( inputs ) => {
 
 	const { alpha, dotNH } = inputs;
 
-	const a2 = pow2( alpha );
+	const a2 = alpha.pow2();
 
-	const denom = add( mul( pow2( dotNH ), sub( a2, 1.0 ) ), 1.0 ); // avoid alpha = 0 with dotNH = 1
+	const denom = dotNH.pow2().mul( a2.oneMinus() ).oneMinus(); // avoid alpha = 0 with dotNH = 1
 
-	return mul( 1 / Math.PI, div( a2, pow2( denom ) ) );
+	return a2.div( denom.pow2() ).mul( 1 / Math.PI );
 
 } ); // validated
 

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

@@ -1,4 +1,4 @@
-import { ShaderNode, add, sub, mul, exp2 } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 
 const F_Schlick = new ShaderNode( ( inputs ) => {
 
@@ -9,9 +9,9 @@ const F_Schlick = new ShaderNode( ( inputs ) => {
 
 	// 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 ) );
+	const fresnel = dotVH.mul( - 5.55473 ).sub( 6.98316 ).mul( dotVH ).exp2();
 
-	return add( mul( f0, sub( 1.0, fresnel ) ), mul( f90, fresnel ) );
+	return f0.mul( fresnel.oneMinus() ).add( f90.mul( fresnel ) );
 
 } ); // validated
 

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

@@ -1,4 +1,6 @@
-import { ShaderNode, add, sub, mul, div, pow2, max, sqrt, EPSILON } from '../../shadernode/ShaderNodeBaseElements.js';
+import { div } from '../../math/OperatorNode.js';
+import { EPSILON } from '../../math/MathNode.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.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
@@ -6,12 +8,12 @@ const V_GGX_SmithCorrelated = new ShaderNode( ( inputs ) => {
 
 	const { alpha, dotNL, dotNV } = inputs;
 
-	const a2 = pow2( alpha );
+	const a2 = alpha.pow2();
 
-	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 ) ) ) ) );
+	const gv = dotNL.mul( a2.add( a2.oneMinus().mul( dotNV.pow2() ) ).sqrt() );
+	const gl = dotNV.mul( a2.add( a2.oneMinus().mul( dotNL.pow2() ) ).sqrt() );
 
-	return div( 0.5, max( add( gv, gl ), EPSILON ) );
+	return div( 0.5, gv.add( gl ).max( EPSILON ) );
 
 } ); // validated
 

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

@@ -0,0 +1,28 @@
+import BRDF_Lambert from './BSDF/BRDF_Lambert.js';
+import BRDF_BlinnPhong from './BSDF/BRDF_BlinnPhong.js';
+import { lightingModel } from '../core/LightingModel.js';
+import { diffuseColor } from '../core/PropertyNode.js';
+import { materialReflectivity } from '../accessors/MaterialNode.js';
+import { transformedNormalView } from '../accessors/NormalNode.js';
+import { ShaderNode } from '../shadernode/ShaderNode.js';
+
+const RE_Direct_BlinnPhong = new ShaderNode( ( { lightDirection, lightColor, reflectedLight } ) => {
+
+	const dotNL = transformedNormalView.dot( lightDirection ).clamp();
+	const irradiance = dotNL.mul( lightColor );
+
+	reflectedLight.directDiffuse.addAssign( irradiance.mul( BRDF_Lambert.call( { diffuseColor: diffuseColor.rgb } ) ) );
+
+	reflectedLight.directSpecular.addAssign( irradiance.mul( BRDF_BlinnPhong.call( { lightDirection } ) ).mul( materialReflectivity ) );
+
+} );
+
+const RE_IndirectDiffuse_BlinnPhong = new ShaderNode( ( { irradiance, reflectedLight } ) => {
+
+	reflectedLight.indirectDiffuse.addAssign( irradiance.mul( BRDF_Lambert.call( { diffuseColor } ) ) );
+
+} );
+
+const phongLightingModel = lightingModel( RE_Direct_BlinnPhong, RE_IndirectDiffuse_BlinnPhong );
+
+export default phongLightingModel;

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

@@ -1,30 +1,30 @@
 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, clamp, add, sub, dot, div, transformedNormalView,
-	pow, exp2, dotNV,
-	diffuseColor, specularColor, roughness, temp
-} from '../shadernode/ShaderNodeElements.js';
+import { lightingModel } from '../core/LightingModel.js';
+import { temp } from '../core/VarNode.js';
+import { diffuseColor, specularColor, roughness } from '../core/PropertyNode.js';
+import { transformedNormalView } from '../accessors/NormalNode.js';
+import { positionViewDirection } from '../accessors/PositionNode.js';
+import { ShaderNode, float, vec3 } from '../shadernode/ShaderNode.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 computeMultiscattering = ( singleScatter, multiScatter, specularF90 = float( 1 ) ) => {
 
 	const fab = DFGApprox.call( { roughness } );
 
-	const FssEss = add( mul( specularColor, fab.x ), mul( specularF90, fab.y ) );
+	const FssEss = specularColor.mul( fab.x ).add( specularF90.mul( fab.y ) );
 
-	const Ess = add( fab.x, fab.y );
-	const Ems = sub( 1.0, Ess );
+	const Ess = fab.x.add( fab.y );
+	const Ems = Ess.oneMinus();
 
-	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 ) ) );
+	const Favg = specularColor.add( specularColor.oneMinus().mul( 0.047619 ) ); // 1/21
+	const Fms = FssEss.mul( Favg ).div( Ems.mul( Favg ).oneMinus() );
 
-	singleScatter.add( FssEss );
-	multiScatter.add( mul( Fms, Ems ) );
+	singleScatter.addAssign( FssEss );
+	multiScatter.addAssign( Fms.mul( Ems ) );
 
 };
 
@@ -36,16 +36,18 @@ const RE_IndirectSpecular_Physical = new ShaderNode( ( inputs ) => {
 
 	const singleScattering = temp( vec3() );
 	const multiScattering = temp( vec3() );
-	const cosineWeightedIrradiance = mul( iblIrradiance, 1 / Math.PI );
+	const cosineWeightedIrradiance = iblIrradiance.mul( 1 / Math.PI );
 
 	computeMultiscattering( singleScattering, multiScattering );
 
-	const diffuse = mul( diffuseColor, sub( 1.0, add( singleScattering, multiScattering ) ) );
+	const totalScattering = singleScattering.add( multiScattering );
 
-	reflectedLight.indirectSpecular.add( mul( radiance, singleScattering ) );
-	reflectedLight.indirectSpecular.add( mul( multiScattering, cosineWeightedIrradiance ) );
+	const diffuse = diffuseColor.mul( totalScattering.r.max( totalScattering.g ).max( totalScattering.b ).oneMinus() );
 
-	reflectedLight.indirectDiffuse.add( mul( diffuse, cosineWeightedIrradiance ) );
+	reflectedLight.indirectSpecular.addAssign( radiance.mul( singleScattering ) );
+	reflectedLight.indirectSpecular.addAssign( multiScattering.mul( cosineWeightedIrradiance ) );
+
+	reflectedLight.indirectDiffuse.addAssign( diffuse.mul( cosineWeightedIrradiance ) );
 
 } );
 
@@ -53,7 +55,7 @@ const RE_IndirectDiffuse_Physical = new ShaderNode( ( inputs ) => {
 
 	const { irradiance, reflectedLight } = inputs;
 
-	reflectedLight.indirectDiffuse.add( mul( irradiance, BRDF_Lambert.call( { diffuseColor } ) ) );
+	reflectedLight.indirectDiffuse.addAssign( irradiance.mul( BRDF_Lambert.call( { diffuseColor } ) ) );
 
 } );
 
@@ -61,34 +63,31 @@ const RE_Direct_Physical = new ShaderNode( ( inputs ) => {
 
 	const { lightDirection, lightColor, reflectedLight } = inputs;
 
-	const dotNL = clamp( dot( transformedNormalView, lightDirection ) );
-	const irradiance = mul( dotNL, lightColor );
+	const dotNL = transformedNormalView.dot( lightDirection ).clamp();
+	const irradiance = dotNL.mul( lightColor );
 
-	reflectedLight.directDiffuse.add( mul( irradiance, BRDF_Lambert.call( { diffuseColor: diffuseColor.rgb } ) ) );
+	reflectedLight.directDiffuse.addAssign( irradiance.mul( BRDF_Lambert.call( { diffuseColor: diffuseColor.rgb } ) ) );
 
-	reflectedLight.directSpecular.add( mul( irradiance, BRDF_GGX.call( { lightDirection, f0: specularColor, f90: 1, roughness } ) ) );
+	reflectedLight.directSpecular.addAssign( irradiance.mul( 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 dotNV = transformedNormalView.dot( positionViewDirection ).clamp();
+
+	const aoNV = dotNV.add( ambientOcclusion );
+	const aoExp = roughness.mul( - 16.0 ).oneMinus().negate().exp2();
 
-	const aoNode = clamp( add( sub( pow( aoNV, aoExp ), 1.0 ), ambientOcclusion ) );
+	const aoNode = ambientOcclusion.sub( aoNV.pow( aoExp ).oneMinus() ).clamp();
 
-	reflectedLight.indirectDiffuse.mul( ambientOcclusion );
+	reflectedLight.indirectDiffuse.mulAssign( ambientOcclusion );
 
-	reflectedLight.indirectSpecular.mul( aoNode );
+	reflectedLight.indirectSpecular.mulAssign( aoNode );
 
 
 } );
 
-const PhysicalLightingModel = {
-	direct: RE_Direct_Physical,
-	indirectDiffuse: RE_IndirectDiffuse_Physical,
-	indirectSpecular: RE_IndirectSpecular_Physical,
-	ambientOcclusion: RE_AmbientOcclusion_Physical
-};
+const physicalLightingModel = lightingModel( RE_Direct_Physical, RE_IndirectDiffuse_Physical, RE_IndirectSpecular_Physical, RE_AmbientOcclusion_Physical );
 
-export default PhysicalLightingModel;
+export default physicalLightingModel;

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

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

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

@@ -1,5 +1,5 @@
 import getGeometryRoughness from './getGeometryRoughness.js';
-import { ShaderNode, add, max, min } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 
 const getRoughness = new ShaderNode( ( inputs ) => {
 
@@ -7,9 +7,9 @@ const getRoughness = new ShaderNode( ( 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 );
+	let roughnessFactor = roughness.max( 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.
+	roughnessFactor = roughnessFactor.add( geometryRoughness );
+	roughnessFactor = roughnessFactor.min( 1.0 );
 
 	return roughnessFactor;