super-three 0.163.0 → 0.165.0

package/examples/jsm/nodes/materials/MeshMatcapNodeMaterial.js

@@ -0,0 +1,52 @@
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+import { materialReference } from '../accessors/MaterialReferenceNode.js';
+import { diffuseColor } from '../core/PropertyNode.js';
+import { vec3 } from '../shadernode/ShaderNode.js';
+import { MeshMatcapMaterial } from 'three';
+import { mix } from '../math/MathNode.js';
+import { matcapUV } from '../utils/MatcapUVNode.js';
+
+const defaultValues = new MeshMatcapMaterial();
+
+class MeshMatcapNodeMaterial extends NodeMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshMatcapNodeMaterial = true;
+
+		this.lights = false;
+
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	setupVariants( builder ) {
+
+		const uv = matcapUV;
+
+		let matcapColor;
+
+		if ( builder.material.matcap ) {
+
+			matcapColor = materialReference( 'matcap', 'texture' ).context( { getUV: () => uv } );
+
+		} else {
+
+			matcapColor = vec3( mix( 0.2, 0.8, uv.y ) ); // default if matcap is missing
+
+		}
+
+		diffuseColor.rgb.mulAssign( matcapColor.rgb );
+
+	}
+
+}
+
+
+export default MeshMatcapNodeMaterial;
+
+addNodeMaterial( 'MeshMatcapNodeMaterial', MeshMatcapNodeMaterial );

package/examples/jsm/nodes/materials/MeshNormalNodeMaterial.js

@@ -17,8 +17,6 @@ class MeshNormalNodeMaterial extends NodeMaterial {
 
 		this.isMeshNormalNodeMaterial = true;
 
-		this.colorSpaced = false;
-
 		this.setDefaultValues( defaultValues );
 
 		this.setValues( parameters );

package/examples/jsm/nodes/materials/MeshPhongNodeMaterial.js

@@ -1,6 +1,6 @@
 import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
 import { shininess, specularColor } from '../core/PropertyNode.js';
-import { materialShininess, materialSpecularColor } from '../accessors/MaterialNode.js';
+import { materialShininess, materialSpecular } from '../accessors/MaterialNode.js';
 import { float } from '../shadernode/ShaderNode.js';
 import PhongLightingModel from '../functions/PhongLightingModel.js';
 
@@ -43,7 +43,7 @@ class MeshPhongNodeMaterial extends NodeMaterial {
 
 		// SPECULAR COLOR
 
-		const specularNode = this.specularNode || materialSpecularColor;
+		const specularNode = this.specularNode || materialSpecular;
 
 		specularColor.assign( specularNode );
 

package/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.js

@@ -1,11 +1,13 @@
 import { addNodeMaterial } from './NodeMaterial.js';
 import { transformedClearcoatNormalView } from '../accessors/NormalNode.js';
-import { clearcoat, clearcoatRoughness, sheen, sheenRoughness, iridescence, iridescenceIOR, iridescenceThickness } from '../core/PropertyNode.js';
-import { materialClearcoat, materialClearcoatRoughness, materialClearcoatNormal, materialSheen, materialSheenRoughness, materialIridescence, materialIridescenceIOR, materialIridescenceThickness } from '../accessors/MaterialNode.js';
-import { float, vec3 } from '../shadernode/ShaderNode.js';
+import { clearcoat, clearcoatRoughness, sheen, sheenRoughness, iridescence, iridescenceIOR, iridescenceThickness, specularColor, specularF90, diffuseColor, metalness, roughness, anisotropy, alphaT, anisotropyT, anisotropyB, ior, transmission, thickness, attenuationDistance, attenuationColor, dispersion } from '../core/PropertyNode.js';
+import { materialClearcoat, materialClearcoatRoughness, materialClearcoatNormal, materialSheen, materialSheenRoughness, materialIridescence, materialIridescenceIOR, materialIridescenceThickness, materialSpecularIntensity, materialSpecularColor, materialAnisotropy, materialIOR, materialTransmission, materialThickness, materialAttenuationDistance, materialAttenuationColor, materialDispersion } from '../accessors/MaterialNode.js';
+import { float, vec2, vec3, If } from '../shadernode/ShaderNode.js';
+import getRoughness from '../functions/material/getRoughness.js';
+import { TBNViewMatrix } from '../accessors/AccessorsUtils.js';
 import PhysicalLightingModel from '../functions/PhysicalLightingModel.js';
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
-
+import { mix, pow2, min } from '../math/MathNode.js';
 import { MeshPhysicalMaterial } from 'three';
 
 const defaultValues = new MeshPhysicalMaterial();
@@ -32,10 +34,14 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 		this.specularIntensityNode = null;
 		this.specularColorNode = null;
 
+		this.iorNode = null;
 		this.transmissionNode = null;
 		this.thicknessNode = null;
 		this.attenuationDistanceNode = null;
 		this.attenuationColorNode = null;
+		this.dispersionNode = null;
+
+		this.anisotropyNode = null;
 
 		this.setDefaultValues( defaultValues );
 
@@ -61,9 +67,37 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 
 	}
 
+	get useAnisotropy() {
+
+		return this.anisotropy > 0 || this.anisotropyNode !== null;
+
+	}
+
+	get useTransmission() {
+
+		return this.transmission > 0 || this.transmissionNode !== null;
+
+	}
+
+	get useDispersion() {
+
+		return this.dispersion > 0 || this.dispersionNode !== null;
+
+	}
+
+	setupSpecular() {
+
+		const iorNode = this.iorNode ? float( this.iorNode ) : materialIOR;
+
+		ior.assign( iorNode );
+		specularColor.assign( mix( min( pow2( ior.sub( 1.0 ).div( ior.add( 1.0 ) ) ).mul( materialSpecularColor ), vec3( 1.0 ) ).mul( materialSpecularIntensity ), diffuseColor.rgb, metalness ) );
+		specularF90.assign( mix( materialSpecularIntensity, 1.0, metalness ) );
+
+	}
+
 	setupLightingModel( /*builder*/ ) {
 
-		return new PhysicalLightingModel( this.useClearcoat, this.useSheen, this.useIridescence );
+		return new PhysicalLightingModel( this.useClearcoat, this.useSheen, this.useIridescence, this.useAnisotropy, this.useTransmission, this.useDispersion );
 
 	}
 
@@ -79,7 +113,7 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 			const clearcoatRoughnessNode = this.clearcoatRoughnessNode ? float( this.clearcoatRoughnessNode ) : materialClearcoatRoughness;
 
 			clearcoat.assign( clearcoatNode );
-			clearcoatRoughness.assign( clearcoatRoughnessNode );
+			clearcoatRoughness.assign( getRoughness( { roughness: clearcoatRoughnessNode } ) );
 
 		}
 
@@ -109,6 +143,57 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 
 		}
 
+		// ANISOTROPY
+
+		if ( this.useAnisotropy ) {
+
+			const anisotropyV = ( this.anisotropyNode ? vec2( this.anisotropyNode ) : materialAnisotropy ).toVar();
+
+			anisotropy.assign( anisotropyV.length() );
+
+			If( anisotropy.equal( 0.0 ), () => {
+
+				anisotropyV.assign( vec2( 1.0, 0.0 ) );
+
+			} ).else( () => {
+
+				anisotropyV.divAssign( anisotropy );
+				anisotropy.assign( anisotropy.saturate() );
+
+			} );
+
+			// Roughness along the anisotropy bitangent is the material roughness, while the tangent roughness increases with anisotropy.
+			alphaT.assign( anisotropy.pow2().mix( roughness.pow2(), 1.0 ) );
+
+			anisotropyT.assign( TBNViewMatrix[ 0 ].mul( anisotropyV.x ).add( TBNViewMatrix[ 1 ].mul( anisotropyV.y ) ) );
+			anisotropyB.assign( TBNViewMatrix[ 1 ].mul( anisotropyV.x ).sub( TBNViewMatrix[ 0 ].mul( anisotropyV.y ) ) );
+
+		}
+
+		// TRANSMISSION
+
+		if ( this.useTransmission ) {
+
+			const transmissionNode = this.transmissionNode ? float( this.transmissionNode ) : materialTransmission;
+			const thicknessNode = this.thicknessNode ? float( this.thicknessNode ) : materialThickness;
+			const attenuationDistanceNode = this.attenuationDistanceNode ? float( this.attenuationDistanceNode ) : materialAttenuationDistance;
+			const attenuationColorNode = this.attenuationColorNode ? vec3( this.attenuationColorNode ) : materialAttenuationColor;
+
+			transmission.assign( transmissionNode );
+			thickness.assign( thicknessNode );
+			attenuationDistance.assign( attenuationDistanceNode );
+			attenuationColor.assign( attenuationColorNode );
+
+			if ( this.useDispersion ) {
+
+				const dispersionNode = this.dispersionNode ? float( this.dispersionNode ) : materialDispersion;
+
+				dispersion.assign( dispersionNode );
+
+			}
+
+		}
+
 	}
 
 	setupNormal( builder ) {
@@ -143,6 +228,9 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 		this.thicknessNode = source.thicknessNode;
 		this.attenuationDistanceNode = source.attenuationDistanceNode;
 		this.attenuationColorNode = source.attenuationColorNode;
+		this.dispersionNode = source.dispersionNode;
+
+		this.anisotropyNode = source.anisotropyNode;
 
 		return super.copy( source );
 

package/examples/jsm/nodes/materials/MeshStandardNodeMaterial.js

@@ -1,5 +1,5 @@
 import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
-import { diffuseColor, metalness, roughness, specularColor } from '../core/PropertyNode.js';
+import { diffuseColor, metalness, roughness, specularColor, specularF90 } from '../core/PropertyNode.js';
 import { mix } from '../math/MathNode.js';
 import { materialRoughness, materialMetalness } from '../accessors/MaterialNode.js';
 import getRoughness from '../functions/material/getRoughness.js';
@@ -35,6 +35,15 @@ class MeshStandardNodeMaterial extends NodeMaterial {
 
 	}
 
+	setupSpecular() {
+
+		const specularColorNode = mix( vec3( 0.04 ), diffuseColor.rgb, metalness );
+
+		specularColor.assign( specularColorNode );
+		specularF90.assign( 1.0 );
+
+	}
+
 	setupVariants() {
 
 		// METALNESS
@@ -52,9 +61,7 @@ class MeshStandardNodeMaterial extends NodeMaterial {
 
 		// SPECULAR COLOR
 
-		const specularColorNode = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessNode );
-
-		specularColor.assign( specularColorNode );
+		this.setupSpecular();
 
 		// DIFFUSE COLOR
 

package/examples/jsm/nodes/materials/MeshToonNodeMaterial.js

@@ -0,0 +1,34 @@
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+import ToonLightingModel from '../functions/ToonLightingModel.js';
+
+import { MeshToonMaterial } from 'three';
+
+const defaultValues = new MeshToonMaterial();
+
+class MeshToonNodeMaterial extends NodeMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isMeshToonNodeMaterial = true;
+
+		this.lights = true;
+
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	setupLightingModel( /*builder*/ ) {
+
+		return new ToonLightingModel();
+
+	}
+
+}
+
+export default MeshToonNodeMaterial;
+
+addNodeMaterial( 'MeshToonNodeMaterial', MeshToonNodeMaterial );

package/examples/jsm/nodes/materials/NodeMaterial.js

@@ -1,13 +1,13 @@
-import { Material, ShaderMaterial, NoColorSpace, LinearSRGBColorSpace } from 'three';
+import { Material } from 'three';
 import { getNodeChildren, getCacheKey } from '../core/NodeUtils.js';
 import { attribute } from '../core/AttributeNode.js';
 import { output, diffuseColor, varyingProperty } from '../core/PropertyNode.js';
 import { materialAlphaTest, materialColor, materialOpacity, materialEmissive, materialNormal } from '../accessors/MaterialNode.js';
 import { modelViewProjection } from '../accessors/ModelViewProjectionNode.js';
-import { transformedNormalView } from '../accessors/NormalNode.js';
+import { transformedNormalView, normalLocal } from '../accessors/NormalNode.js';
 import { instance } from '../accessors/InstanceNode.js';
 import { batch } from '../accessors/BatchNode.js';
-
+import { materialReference } from '../accessors/MaterialReferenceNode.js';
 import { positionLocal, positionView } from '../accessors/PositionNode.js';
 import { skinningReference } from '../accessors/SkinningNode.js';
 import { morphReference } from '../accessors/MorphNode.js';
@@ -19,6 +19,7 @@ import { float, vec3, vec4 } from '../shadernode/ShaderNode.js';
 import AONode from '../lighting/AONode.js';
 import { lightingContext } from '../lighting/LightingContextNode.js';
 import EnvironmentNode from '../lighting/EnvironmentNode.js';
+import IrradianceNode from '../lighting/IrradianceNode.js';
 import { depthPixel } from '../display/ViewportDepthNode.js';
 import { cameraLogDepth } from '../accessors/CameraNode.js';
 import { clipping, clippingAlpha } from '../accessors/ClippingNode.js';
@@ -26,7 +27,7 @@ import { faceDirection } from '../display/FrontFacingNode.js';
 
 const NodeMaterials = new Map();
 
-class NodeMaterial extends ShaderMaterial {
+class NodeMaterial extends Material {
 
 	constructor() {
 
@@ -42,10 +43,9 @@ class NodeMaterial extends ShaderMaterial {
 		this.lights = true;
 		this.normals = true;
 
-		this.colorSpaced = true;
-
 		this.lightsNode = null;
 		this.envNode = null;
+		this.aoNode = null;
 
 		this.colorNode = null;
 		this.normalNode = null;
@@ -58,6 +58,7 @@ class NodeMaterial extends ShaderMaterial {
 
 		this.depthNode = null;
 		this.shadowNode = null;
+		this.shadowPositionNode = null;
 
 		this.outputNode = null;
 
@@ -96,9 +97,9 @@ class NodeMaterial extends ShaderMaterial {
 
 		const clippingNode = this.setupClipping( builder );
 
-		if ( this.fragmentNode === null ) {
+		if ( this.depthWrite === true ) this.setupDepth( builder );
 
-			if ( this.depthWrite === true ) this.setupDepth( builder );
+		if ( this.fragmentNode === null ) {
 
 			if ( this.normals === true ) this.setupNormal( builder );
 
@@ -125,7 +126,15 @@ class NodeMaterial extends ShaderMaterial {
 
 		} else {
 
-			resultNode = this.setupOutput( builder, this.fragmentNode );
+			let fragmentNode = this.fragmentNode;
+
+			if ( fragmentNode.isOutputStructNode !== true ) {
+
+				fragmentNode = vec4( fragmentNode );
+
+			}
+
+			resultNode = this.setupOutput( builder, fragmentNode );
 
 		}
 
@@ -137,6 +146,8 @@ class NodeMaterial extends ShaderMaterial {
 
 	setupClipping( builder ) {
 
+		if ( builder.clippingContext === null ) return null;
+
 		const { globalClippingCount, localClippingCount } = builder.clippingContext;
 
 		let result = null;
@@ -205,6 +216,16 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
+		if ( this.displacementMap ) {
+
+			const displacementMap = materialReference( 'displacementMap', 'texture' );
+			const displacementScale = materialReference( 'displacementScale', 'float' );
+			const displacementBias = materialReference( 'displacementBias', 'float' );
+
+			positionLocal.addAssign( normalLocal.normalize().mul( ( displacementMap.x.mul( displacementScale ).add( displacementBias ) ) ) );
+
+		}
+
 		if ( object.isBatchedMesh ) {
 
 			batch( object ).append();
@@ -337,9 +358,17 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
-		if ( builder.material.aoMap ) {
+		if ( builder.material.lightMap ) {
+
+			materialLightsNode.push( new IrradianceNode( materialReference( 'lightMap', 'texture' ) ) );
+
+		}
+
+		if ( this.aoNode !== null || builder.material.aoMap ) {
+
+			const aoNode = this.aoNode !== null ? this.aoNode : texture( builder.material.aoMap );
 
-			materialLightsNode.push( new AONode( texture( builder.material.aoMap ) ) );
+			materialLightsNode.push( new AONode( aoNode ) );
 
 		}
 
@@ -400,41 +429,11 @@ class NodeMaterial extends ShaderMaterial {
 
 	setupOutput( builder, outputNode ) {
 
-		const renderer = builder.renderer;
-
 		// FOG
 
-		if ( this.fog === true ) {
-
-			const fogNode = builder.fogNode;
-
-			if ( fogNode ) outputNode = vec4( fogNode.mix( outputNode.rgb, fogNode.colorNode ), outputNode.a );
-
-		}
-
-		// TONE MAPPING
-
-		const toneMappingNode = builder.toneMappingNode;
-
-		if ( this.toneMapped === true && toneMappingNode ) {
-
-			outputNode = vec4( toneMappingNode.context( { color: outputNode.rgb } ), outputNode.a );
-
-		}
-
-		// ENCODING
-
-		if ( this.colorSpaced === true ) {
-
-			const outputColorSpace = renderer.currentColorSpace;
-
-			if ( outputColorSpace !== LinearSRGBColorSpace && outputColorSpace !== NoColorSpace ) {
+		const fogNode = builder.fogNode;
 
-				outputNode = outputNode.linearToColorSpace( outputColorSpace );
-
-			}
-
-		}
+		if ( fogNode ) outputNode = vec4( fogNode.mix( outputNode.rgb, fogNode.colorNode ), outputNode.a );
 
 		return outputNode;
 
@@ -459,8 +458,6 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
-		Object.assign( this.defines, material.defines );
-
 		const descriptors = Object.getOwnPropertyDescriptors( material.constructor.prototype );
 
 		for ( const key in descriptors ) {
@@ -551,6 +548,7 @@ class NodeMaterial extends ShaderMaterial {
 
 		this.depthNode = source.depthNode;
 		this.shadowNode = source.shadowNode;
+		this.shadowPositionNode = source.shadowPositionNode;
 
 		this.outputNode = source.outputNode;
 

package/examples/jsm/nodes/materials/ShadowNodeMaterial.js

@@ -0,0 +1,34 @@
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+import ShadowMaskModel from '../functions/ShadowMaskModel.js';
+
+import { ShadowMaterial } from 'three';
+
+const defaultValues = new ShadowMaterial();
+
+class ShadowNodeMaterial extends NodeMaterial {
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isShadowNodeMaterial = true;
+
+		this.lights = true;
+
+		this.setDefaultValues( defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	setupLightingModel( /*builder*/ ) {
+
+		return new ShadowMaskModel();
+
+	}
+
+}
+
+export default ShadowNodeMaterial;
+
+addNodeMaterial( 'ShadowNodeMaterial', ShadowNodeMaterial );

package/examples/jsm/nodes/materials/VolumeNodeMaterial.js

@@ -0,0 +1,106 @@
+import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+import { varying } from '../core/VaryingNode.js';
+import { property } from '../core/PropertyNode.js';
+import { materialReference } from '../accessors/MaterialReferenceNode.js';
+import { modelWorldMatrixInverse } from '../accessors/ModelNode.js';
+import { cameraPosition } from '../accessors/CameraNode.js';
+import { positionGeometry } from '../accessors/PositionNode.js';
+import { tslFn, vec2, vec3, vec4 } from '../shadernode/ShaderNode.js';
+import { min, max } from '../math/MathNode.js';
+import { loop, Break } from '../utils/LoopNode.js';
+import { texture3D } from '../accessors/Texture3DNode.js';
+
+class VolumeNodeMaterial extends NodeMaterial {
+
+	constructor( params = {} ) {
+
+		super();
+
+		this.normals = false;
+		this.lights = false;
+		this.isVolumeNodeMaterial = true;
+		this.testNode = null;
+
+		this.setValues( params );
+
+	}
+
+	setup( builder ) {
+
+		const map = texture3D( this.map, null, 0 );
+
+		const hitBox = tslFn( ( { orig, dir } ) => {
+
+			const box_min = vec3( - 0.5 );
+			const box_max = vec3( 0.5 );
+
+			const inv_dir = dir.reciprocal();
+
+			const tmin_tmp = box_min.sub( orig ).mul( inv_dir );
+			const tmax_tmp = box_max.sub( orig ).mul( inv_dir );
+
+			const tmin = min( tmin_tmp, tmax_tmp );
+			const tmax = max( tmin_tmp, tmax_tmp );
+
+			const t0 = max( tmin.x, max( tmin.y, tmin.z ) );
+			const t1 = min( tmax.x, min( tmax.y, tmax.z ) );
+
+			return vec2( t0, t1 );
+
+		} );
+
+		this.fragmentNode = tslFn( () => {
+
+			const vOrigin = varying( vec3( modelWorldMatrixInverse.mul( vec4( cameraPosition, 1.0 ) ) ) );
+			const vDirection = varying( positionGeometry.sub( vOrigin ) );
+
+			const rayDir = vDirection.normalize();
+			const bounds = property( 'vec2', 'bounds' ).assign( hitBox( { orig: vOrigin, dir: rayDir } ) );
+
+			bounds.x.greaterThan( bounds.y ).discard();
+
+			bounds.assign( vec2( max( bounds.x, 0.0 ), bounds.y ) );
+
+			const p = property( 'vec3', 'p' ).assign( vOrigin.add( bounds.x.mul( rayDir ) ) );
+			const inc = property( 'vec3', 'inc' ).assign( vec3( rayDir.abs().reciprocal() ) );
+			const delta = property( 'float', 'delta' ).assign( min( inc.x, min( inc.y, inc.z ) ) );
+
+			delta.divAssign( materialReference( 'steps', 'float' ) );
+
+			const ac = property( 'vec4', 'ac' ).assign( vec4( materialReference( 'base', 'color' ), 0.0 ) );
+
+			loop( { type: 'float', start: bounds.x, end: bounds.y, update: '+= delta' }, () => {
+
+				const d = property( 'float', 'd' ).assign( map.uv( p.add( 0.5 ) ).r );
+
+				if ( this.testNode !== null ) {
+
+					this.testNode( { map: map, mapValue: d, probe: p, finalColor: ac } ).append();
+
+				} else {
+
+					// default to show surface of mesh
+					ac.a.assign( 1 );
+					Break();
+
+				}
+
+				p.addAssign( rayDir.mul( delta ) );
+
+			} );
+
+			ac.a.equal( 0 ).discard();
+
+			return vec4( ac );
+
+		} )();
+
+		super.setup( builder );
+
+	}
+
+}
+
+export default VolumeNodeMaterial;
+
+addNodeMaterial( 'VolumeNodeMaterial', VolumeNodeMaterial );

package/examples/jsm/nodes/math/HashNode.js

@@ -15,11 +15,11 @@ class HashNode extends Node {
 
 		// Taken from https://www.shadertoy.com/view/XlGcRh, originally from pcg-random.org
 
-		const state = this.seedNode.uint().mul( 747796405 ).add( 2891336453 );
+		const state = this.seedNode.toUint().mul( 747796405 ).add( 2891336453 );
 		const word = state.shiftRight( state.shiftRight( 28 ).add( 4 ) ).bitXor( state ).mul( 277803737 );
 		const result = word.shiftRight( 22 ).bitXor( word );
 
-		return result.float().mul( 1 / 2 ** 32 ); // Convert to range [0, 1)
+		return result.toFloat().mul( 1 / 2 ** 32 ); // Convert to range [0, 1)
 
 	}
 

package/examples/jsm/nodes/pmrem/PMREMUtils.js

@@ -237,7 +237,7 @@ const bilinearCubeUV = tslFn( ( [ envMap, direction_immutable, mipInt_immutable,
 	uv.x.mulAssign( CUBEUV_TEXEL_WIDTH );
 	uv.y.mulAssign( CUBEUV_TEXEL_HEIGHT );
 
-	return envMap.uv( uv );
+	return envMap.uv( uv ).grad( vec2(), vec2() ); // disable anisotropic filtering
 
 } );