super-three 0.162.0 → 0.163.0

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

@@ -1,17 +1,14 @@
 import LightingNode from './LightingNode.js';
 import { cache } from '../core/CacheNode.js';
 import { context } from '../core/ContextNode.js';
-import { maxMipLevel } from '../utils/MaxMipLevelNode.js';
 import { roughness, clearcoatRoughness } from '../core/PropertyNode.js';
-import { equirectUV } from '../utils/EquirectUVNode.js';
-import { specularMIPLevel } from '../utils/SpecularMIPLevelNode.js';
 import { cameraViewMatrix } from '../accessors/CameraNode.js';
 import { transformedClearcoatNormalView, transformedNormalView, transformedNormalWorld } from '../accessors/NormalNode.js';
 import { positionViewDirection } from '../accessors/PositionNode.js';
 import { addNodeClass } from '../core/Node.js';
-import { vec2 } from '../shadernode/ShaderNode.js';
-import { cubeTexture } from '../accessors/CubeTextureNode.js';
+import { float } from '../shadernode/ShaderNode.js';
 import { reference } from '../accessors/ReferenceNode.js';
+import { pmremTexture } from '../pmrem/PMREMNode.js';
 
 const envNodeCache = new WeakMap();
 
@@ -29,19 +26,13 @@ class EnvironmentNode extends LightingNode {
 
 		let envNode = this.envNode;
 
-		if ( envNode.isTextureNode && envNode.value.isCubeTexture !== true ) {
+		if ( envNode.isTextureNode ) {
 
 			let cacheEnvNode = envNodeCache.get( envNode.value );
 
 			if ( cacheEnvNode === undefined ) {
 
-				const texture = envNode.value;
-				const renderer = builder.renderer;
-
-				// @TODO: Add dispose logic here
-				const cubeRTT = builder.getCubeRenderTarget( 512 ).fromEquirectangularTexture( renderer, texture );
-
-				cacheEnvNode = cubeTexture( cubeRTT.texture );
+				cacheEnvNode = pmremTexture( envNode.value );
 
 				envNodeCache.set( envNode.value, cacheEnvNode );
 
@@ -53,7 +44,8 @@ class EnvironmentNode extends LightingNode {
 
 		//
 
-		const intensity = reference( 'envMapIntensity', 'float', builder.material ); // @TODO: Add materialEnvIntensity in MaterialNode
+		const envMap = builder.material.envMap;
+		const intensity = envMap ? reference( 'envMapIntensity', 'float', builder.material ) : reference( 'environmentIntensity', 'float', builder.scene ); // @TODO: Add materialEnvIntensity in MaterialNode
 
 		const radiance = context( envNode, createRadianceContext( roughness, transformedNormalView ) ).mul( intensity );
 		const irradiance = context( envNode, createIrradianceContext( transformedNormalWorld ) ).mul( Math.PI ).mul( intensity );
@@ -86,12 +78,9 @@ class EnvironmentNode extends LightingNode {
 const createRadianceContext = ( roughnessNode, normalViewNode ) => {
 
 	let reflectVec = null;
-	let textureUVNode = null;
 
 	return {
-		getUV: ( textureNode ) => {
-
-			let node = null;
+		getUV: () => {
 
 			if ( reflectVec === null ) {
 
@@ -101,36 +90,13 @@ const createRadianceContext = ( roughnessNode, normalViewNode ) => {
 
 			}
 
-			if ( textureNode.isCubeTextureNode ) {
-
-				node = reflectVec;
-
-			} else if ( textureNode.isTextureNode ) {
-
-				if ( textureUVNode === null ) {
-
-					// @TODO: Needed PMREM
-
-					textureUVNode = equirectUV( reflectVec );
-
-				}
-
-				node = textureUVNode;
-
-			}
-
-			return node;
+			return reflectVec;
 
 		},
 		getTextureLevel: () => {
 
 			return roughnessNode;
 
-		},
-		getTextureLevelAlgorithm: ( textureNode, levelNode ) => {
-
-			return specularMIPLevel( textureNode, levelNode );
-
 		}
 	};
 
@@ -138,38 +104,15 @@ const createRadianceContext = ( roughnessNode, normalViewNode ) => {
 
 const createIrradianceContext = ( normalWorldNode ) => {
 
-	let textureUVNode = null;
-
 	return {
-		getUV: ( textureNode ) => {
-
-			let node = null;
-
-			if ( textureNode.isCubeTextureNode ) {
-
-				node = normalWorldNode;
-
-			} else if ( textureNode.isTextureNode ) {
-
-				if ( textureUVNode === null ) {
+		getUV: () => {
 
-					// @TODO: Needed PMREM
-
-					textureUVNode = equirectUV( normalWorldNode );
-					textureUVNode = vec2( textureUVNode.x, textureUVNode.y.oneMinus() );
-
-				}
-
-				node = textureUVNode;
-
-			}
-
-			return node;
+			return normalWorldNode;
 
 		},
-		getTextureLevel: ( textureNode ) => {
+		getTextureLevel: () => {
 
-			return maxMipLevel( textureNode );
+			return float( 1.0 );
 
 		}
 	};

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

@@ -1,11 +1,13 @@
 import { Material, ShaderMaterial, NoColorSpace, LinearSRGBColorSpace } from 'three';
 import { getNodeChildren, getCacheKey } from '../core/NodeUtils.js';
 import { attribute } from '../core/AttributeNode.js';
-import { output, diffuseColor } from '../core/PropertyNode.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 { instance } from '../accessors/InstanceNode.js';
+import { batch } from '../accessors/BatchNode.js';
+
 import { positionLocal, positionView } from '../accessors/PositionNode.js';
 import { skinningReference } from '../accessors/SkinningNode.js';
 import { morphReference } from '../accessors/MorphNode.js';
@@ -107,7 +109,11 @@ class NodeMaterial extends ShaderMaterial {
 
 			if ( clippingNode !== null ) builder.stack.add( clippingNode );
 
-			resultNode = this.setupOutput( builder, vec4( outgoingLightNode, diffuseColor.a ) );
+			// force unsigned floats - useful for RenderTargets
+
+			const basicOutput = vec4( outgoingLightNode, diffuseColor.a ).max( 0 );
+
+			resultNode = this.setupOutput( builder, basicOutput );
 
 			// OUTPUT NODE
 
@@ -199,6 +205,12 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
+		if ( object.isBatchedMesh ) {
+
+			batch( object ).append();
+
+		}
+
 		if ( ( object.instanceMatrix && object.instanceMatrix.isInstancedBufferAttribute === true ) && builder.isAvailable( 'instance' ) === true ) {
 
 			instance( object ).append();
@@ -220,7 +232,7 @@ class NodeMaterial extends ShaderMaterial {
 
 	}
 
-	setupDiffuseColor( { geometry } ) {
+	setupDiffuseColor( { object, geometry } ) {
 
 		let colorNode = this.colorNode ? vec4( this.colorNode ) : materialColor;
 
@@ -232,6 +244,16 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
+		// Instanced colors
+
+		if ( object.instanceColor ) {
+
+			const instanceColor = varyingProperty( 'vec3', 'vInstanceColor' );
+
+			colorNode = instanceColor.mul( colorNode );
+
+		}
+
 		// COLOR
 
 		diffuseColor.assign( colorNode );
@@ -380,23 +402,23 @@ class NodeMaterial extends ShaderMaterial {
 
 		const renderer = builder.renderer;
 
-		// TONE MAPPING
+		// FOG
 
-		const toneMappingNode = builder.toneMappingNode;
+		if ( this.fog === true ) {
 
-		if ( this.toneMapped === true && toneMappingNode ) {
+			const fogNode = builder.fogNode;
 
-			outputNode = vec4( toneMappingNode.context( { color: outputNode.rgb } ), outputNode.a );
+			if ( fogNode ) outputNode = vec4( fogNode.mix( outputNode.rgb, fogNode.colorNode ), outputNode.a );
 
 		}
 
-		// FOG
+		// TONE MAPPING
 
-		if ( this.fog === true ) {
+		const toneMappingNode = builder.toneMappingNode;
 
-			const fogNode = builder.fogNode;
+		if ( this.toneMapped === true && toneMappingNode ) {
 
-			if ( fogNode ) outputNode = vec4( fogNode.mixAssign( outputNode.rgb ), outputNode.a );
+			outputNode = vec4( toneMappingNode.context( { color: outputNode.rgb } ), outputNode.a );
 
 		}
 

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

@@ -0,0 +1,193 @@
+import TempNode from '../core/TempNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { texture } from '../accessors/TextureNode.js';
+import { textureCubeUV } from './PMREMUtils.js';
+import { uniform } from '../core/UniformNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import { nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
+import { WebGLCoordinateSystem } from 'three';
+
+let _generator = null;
+
+const _cache = new WeakMap();
+
+function _generateCubeUVSize( imageHeight ) {
+
+	const maxMip = Math.log2( imageHeight ) - 2;
+
+	const texelHeight = 1.0 / imageHeight;
+
+	const texelWidth = 1.0 / ( 3 * Math.max( Math.pow( 2, maxMip ), 7 * 16 ) );
+
+	return { texelWidth, texelHeight, maxMip };
+
+}
+
+function _getPMREMFromTexture( texture ) {
+
+	let cacheTexture = _cache.get( texture );
+
+	const pmremVersion = cacheTexture !== undefined ? cacheTexture.pmremVersion : - 1;
+
+	if ( pmremVersion !== texture.pmremVersion ) {
+
+		if ( texture.isCubeTexture ) {
+
+			if ( texture.source.data.some( ( texture ) => texture === undefined ) ) {
+
+				throw new Error( 'PMREMNode: Undefined texture in CubeTexture. Use onLoad callback or async loader' );
+
+			}
+
+			cacheTexture = _generator.fromCubemap( texture, cacheTexture );
+
+		} else {
+
+			if ( texture.image === undefined ) {
+
+				throw new Error( 'PMREMNode: Undefined image in Texture. Use onLoad callback or async loader' );
+
+			}
+
+			cacheTexture = _generator.fromEquirectangular( texture, cacheTexture );
+
+		}
+
+		cacheTexture.pmremVersion = texture.pmremVersion;
+
+		_cache.set( texture, cacheTexture );
+
+	}
+
+	return cacheTexture.texture;
+
+}
+
+class PMREMNode extends TempNode {
+
+	constructor( value, uvNode = null, levelNode = null ) {
+
+		super( 'vec3' );
+
+		this._value = value;
+		this._pmrem = null;
+
+		this.uvNode = uvNode;
+		this.levelNode = levelNode;
+
+		this._generator = null;
+		this._texture = texture( null );
+		this._width = uniform( 0 );
+		this._height = uniform( 0 );
+		this._maxMip = uniform( 0 );
+
+		this.updateBeforeType = NodeUpdateType.RENDER;
+
+	}
+
+	set value( value ) {
+
+		this._value = value;
+		this._pmrem = null;
+
+	}
+
+	get value() {
+
+		return this._value;
+
+	}
+
+	updateFromTexture( texture ) {
+
+		const cubeUVSize = _generateCubeUVSize( texture.image.height );
+
+		this._texture.value = texture;
+		this._width.value = cubeUVSize.texelWidth;
+		this._height.value = cubeUVSize.texelHeight;
+		this._maxMip.value = cubeUVSize.maxMip;
+
+	}
+
+	updateBefore() {
+
+		let pmrem = this._pmrem;
+
+		const pmremVersion = pmrem ? pmrem.pmremVersion : - 1;
+		const texture = this._value;
+
+		if ( pmremVersion !== texture.pmremVersion ) {
+
+			if ( texture.isPMREMTexture === true ) {
+
+				pmrem = texture;
+
+			} else {
+
+				pmrem = _getPMREMFromTexture( texture );
+
+			}
+
+			this._pmrem = pmrem;
+
+			this.updateFromTexture( pmrem );
+
+		}
+
+	}
+
+	setup( builder ) {
+
+		if ( _generator === null ) {
+
+			_generator = builder.createPMREMGenerator();
+
+		}
+
+		//
+
+		this.updateBefore( builder );
+
+		//
+
+		let uvNode = this.uvNode;
+
+		if ( uvNode === null && builder.context.getUV ) {
+
+			uvNode = builder.context.getUV( this );
+
+		}
+
+		//
+
+		const texture = this.value;
+
+		if ( builder.renderer.coordinateSystem === WebGLCoordinateSystem && texture.isPMREMTexture !== true && texture.isRenderTargetTexture === true ) {
+
+			uvNode = vec3( uvNode.x.negate(), uvNode.yz );
+
+		}
+
+		//
+
+		let levelNode = this.levelNode;
+
+		if ( levelNode === null && builder.context.getTextureLevel ) {
+
+			levelNode = builder.context.getTextureLevel( this );
+
+		}
+
+		//
+
+		return textureCubeUV( this._texture, uvNode, levelNode, this._width, this._height, this._maxMip );
+
+	}
+
+}
+
+export const pmremTexture = nodeProxy( PMREMNode );
+
+addNodeClass( 'PMREMNode', PMREMNode );
+
+export default PMREMNode;