super-three 0.137.0 → 0.141.0

package/examples/jsm/renderers/Projector.js

@@ -473,125 +473,113 @@ class Projector {
 
 				if ( object.isMesh ) {
 
-					if ( geometry.isBufferGeometry ) {
+					let material = object.material;
 
-						let material = object.material;
+					const isMultiMaterial = Array.isArray( material );
 
-						const isMultiMaterial = Array.isArray( material );
+					const attributes = geometry.attributes;
+					const groups = geometry.groups;
 
-						const attributes = geometry.attributes;
-						const groups = geometry.groups;
+					if ( attributes.position === undefined ) continue;
 
-						if ( attributes.position === undefined ) continue;
+					const positions = attributes.position.array;
 
-						const positions = attributes.position.array;
-
-						for ( let i = 0, l = positions.length; i < l; i += 3 ) {
-
-							let x = positions[ i ];
-							let y = positions[ i + 1 ];
-							let z = positions[ i + 2 ];
+					for ( let i = 0, l = positions.length; i < l; i += 3 ) {
 
-							const morphTargets = geometry.morphAttributes.position;
+						let x = positions[ i ];
+						let y = positions[ i + 1 ];
+						let z = positions[ i + 2 ];
 
-							if ( morphTargets !== undefined ) {
+						const morphTargets = geometry.morphAttributes.position;
 
-								const morphTargetsRelative = geometry.morphTargetsRelative;
-								const morphInfluences = object.morphTargetInfluences;
+						if ( morphTargets !== undefined ) {
 
-								for ( let t = 0, tl = morphTargets.length; t < tl; t ++ ) {
+							const morphTargetsRelative = geometry.morphTargetsRelative;
+							const morphInfluences = object.morphTargetInfluences;
 
-									const influence = morphInfluences[ t ];
+							for ( let t = 0, tl = morphTargets.length; t < tl; t ++ ) {
 
-									if ( influence === 0 ) continue;
+								const influence = morphInfluences[ t ];
 
-									const target = morphTargets[ t ];
+								if ( influence === 0 ) continue;
 
-									if ( morphTargetsRelative ) {
+								const target = morphTargets[ t ];
 
-										x += target.getX( i / 3 ) * influence;
-										y += target.getY( i / 3 ) * influence;
-										z += target.getZ( i / 3 ) * influence;
+								if ( morphTargetsRelative ) {
 
-									} else {
+									x += target.getX( i / 3 ) * influence;
+									y += target.getY( i / 3 ) * influence;
+									z += target.getZ( i / 3 ) * influence;
 
-										x += ( target.getX( i / 3 ) - positions[ i ] ) * influence;
-										y += ( target.getY( i / 3 ) - positions[ i + 1 ] ) * influence;
-										z += ( target.getZ( i / 3 ) - positions[ i + 2 ] ) * influence;
+								} else {
 
-									}
+									x += ( target.getX( i / 3 ) - positions[ i ] ) * influence;
+									y += ( target.getY( i / 3 ) - positions[ i + 1 ] ) * influence;
+									z += ( target.getZ( i / 3 ) - positions[ i + 2 ] ) * influence;
 
 								}
 
 							}
 
-							renderList.pushVertex( x, y, z );
-
 						}
 
-						if ( attributes.normal !== undefined ) {
+						renderList.pushVertex( x, y, z );
+
+					}
 
-							const normals = attributes.normal.array;
+					if ( attributes.normal !== undefined ) {
 
-							for ( let i = 0, l = normals.length; i < l; i += 3 ) {
+						const normals = attributes.normal.array;
 
-								renderList.pushNormal( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] );
+						for ( let i = 0, l = normals.length; i < l; i += 3 ) {
 
-							}
+							renderList.pushNormal( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] );
 
 						}
 
-						if ( attributes.color !== undefined ) {
+					}
 
-							const colors = attributes.color.array;
+					if ( attributes.color !== undefined ) {
 
-							for ( let i = 0, l = colors.length; i < l; i += 3 ) {
+						const colors = attributes.color.array;
 
-								renderList.pushColor( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] );
+						for ( let i = 0, l = colors.length; i < l; i += 3 ) {
 
-							}
+							renderList.pushColor( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] );
 
 						}
 
-						if ( attributes.uv !== undefined ) {
+					}
 
-							const uvs = attributes.uv.array;
+					if ( attributes.uv !== undefined ) {
 
-							for ( let i = 0, l = uvs.length; i < l; i += 2 ) {
+						const uvs = attributes.uv.array;
 
-								renderList.pushUv( uvs[ i ], uvs[ i + 1 ] );
+						for ( let i = 0, l = uvs.length; i < l; i += 2 ) {
 
-							}
+							renderList.pushUv( uvs[ i ], uvs[ i + 1 ] );
 
 						}
 
-						if ( geometry.index !== null ) {
-
-							const indices = geometry.index.array;
-
-							if ( groups.length > 0 ) {
-
-								for ( let g = 0; g < groups.length; g ++ ) {
+					}
 
-									const group = groups[ g ];
+					if ( geometry.index !== null ) {
 
-									material = isMultiMaterial === true
-										 ? object.material[ group.materialIndex ]
-										 : object.material;
+						const indices = geometry.index.array;
 
-									if ( material === undefined ) continue;
+						if ( groups.length > 0 ) {
 
-									for ( let i = group.start, l = group.start + group.count; i < l; i += 3 ) {
+							for ( let g = 0; g < groups.length; g ++ ) {
 
-										renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ], material );
+								const group = groups[ g ];
 
-									}
+								material = isMultiMaterial === true
+									 ? object.material[ group.materialIndex ]
+									 : object.material;
 
-								}
+								if ( material === undefined ) continue;
 
-							} else {
-
-								for ( let i = 0, l = indices.length; i < l; i += 3 ) {
+								for ( let i = group.start, l = group.start + group.count; i < l; i += 3 ) {
 
 									renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ], material );
 
@@ -601,29 +589,29 @@ class Projector {
 
 						} else {
 
-							if ( groups.length > 0 ) {
+							for ( let i = 0, l = indices.length; i < l; i += 3 ) {
 
-								for ( let g = 0; g < groups.length; g ++ ) {
+								renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ], material );
 
-									const group = groups[ g ];
+							}
 
-									material = isMultiMaterial === true
-										 ? object.material[ group.materialIndex ]
-										 : object.material;
+						}
 
-									if ( material === undefined ) continue;
+					} else {
 
-									for ( let i = group.start, l = group.start + group.count; i < l; i += 3 ) {
+						if ( groups.length > 0 ) {
 
-										renderList.pushTriangle( i, i + 1, i + 2, material );
+							for ( let g = 0; g < groups.length; g ++ ) {
 
-									}
+								const group = groups[ g ];
 
-								}
+								material = isMultiMaterial === true
+									 ? object.material[ group.materialIndex ]
+									 : object.material;
 
-							} else {
+								if ( material === undefined ) continue;
 
-								for ( let i = 0, l = positions.length / 3; i < l; i += 3 ) {
+								for ( let i = group.start, l = group.start + group.count; i < l; i += 3 ) {
 
 									renderList.pushTriangle( i, i + 1, i + 2, material );
 
@@ -631,12 +619,15 @@ class Projector {
 
 							}
 
-						}
+						} else {
+
+							for ( let i = 0, l = positions.length / 3; i < l; i += 3 ) {
 
-					} else if ( geometry.isGeometry ) {
+								renderList.pushTriangle( i, i + 1, i + 2, material );
 
-						console.error( 'THREE.Projector no longer supports Geometry. Use THREE.BufferGeometry instead.' );
-						return;
+							}
+
+						}
 
 					}
 
@@ -644,88 +635,70 @@ class Projector {
 
 					_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
 
-					if ( geometry.isBufferGeometry ) {
-
-						const attributes = geometry.attributes;
+					const attributes = geometry.attributes;
 
-						if ( attributes.position !== undefined ) {
+					if ( attributes.position !== undefined ) {
 
-							const positions = attributes.position.array;
-
-							for ( let i = 0, l = positions.length; i < l; i += 3 ) {
+						const positions = attributes.position.array;
 
-								renderList.pushVertex( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] );
+						for ( let i = 0, l = positions.length; i < l; i += 3 ) {
 
-							}
+							renderList.pushVertex( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] );
 
-							if ( attributes.color !== undefined ) {
+						}
 
-								const colors = attributes.color.array;
+						if ( attributes.color !== undefined ) {
 
-								for ( let i = 0, l = colors.length; i < l; i += 3 ) {
+							const colors = attributes.color.array;
 
-									renderList.pushColor( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] );
+							for ( let i = 0, l = colors.length; i < l; i += 3 ) {
 
-								}
+								renderList.pushColor( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] );
 
 							}
 
-							if ( geometry.index !== null ) {
+						}
 
-								const indices = geometry.index.array;
+						if ( geometry.index !== null ) {
 
-								for ( let i = 0, l = indices.length; i < l; i += 2 ) {
+							const indices = geometry.index.array;
 
-									renderList.pushLine( indices[ i ], indices[ i + 1 ] );
+							for ( let i = 0, l = indices.length; i < l; i += 2 ) {
 
-								}
+								renderList.pushLine( indices[ i ], indices[ i + 1 ] );
 
-							} else {
+							}
 
-								const step = object.isLineSegments ? 2 : 1;
+						} else {
 
-								for ( let i = 0, l = ( positions.length / 3 ) - 1; i < l; i += step ) {
+							const step = object.isLineSegments ? 2 : 1;
 
-									renderList.pushLine( i, i + 1 );
+							for ( let i = 0, l = ( positions.length / 3 ) - 1; i < l; i += step ) {
 
-								}
+								renderList.pushLine( i, i + 1 );
 
 							}
 
 						}
 
-					} else if ( geometry.isGeometry ) {
-
-						console.error( 'THREE.Projector no longer supports Geometry. Use THREE.BufferGeometry instead.' );
-						return;
-
 					}
 
 				} else if ( object.isPoints ) {
 
 					_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
 
-					if ( geometry.isGeometry ) {
+					const attributes = geometry.attributes;
 
-						console.error( 'THREE.Projector no longer supports Geometry. Use THREE.BufferGeometry instead.' );
-						return;
+					if ( attributes.position !== undefined ) {
 
-					} else if ( geometry.isBufferGeometry ) {
-
-						const attributes = geometry.attributes;
-
-						if ( attributes.position !== undefined ) {
-
-							const positions = attributes.position.array;
-
-							for ( let i = 0, l = positions.length; i < l; i += 3 ) {
+						const positions = attributes.position.array;
 
-								_vector4.set( positions[ i ], positions[ i + 1 ], positions[ i + 2 ], 1 );
-								_vector4.applyMatrix4( _modelViewProjectionMatrix );
+						for ( let i = 0, l = positions.length; i < l; i += 3 ) {
 
-								pushPoint( _vector4, object, camera );
+							_vector4.set( positions[ i ], positions[ i + 1 ], positions[ i + 2 ], 1 );
+							_vector4.applyMatrix4( _modelViewProjectionMatrix );
 
-							}
+							pushPoint( _vector4, object, camera );
 
 						}
 

package/examples/jsm/renderers/SVGRenderer.js

@@ -18,14 +18,14 @@ class SVGObject extends Object3D {
 
 		super();
 
+		this.isSVGObject = true;
+
 		this.node = node;
 
 	}
 
 }
 
-SVGObject.prototype.isSVGObject = true;
-
 class SVGRenderer {
 
 	constructor() {
@@ -227,7 +227,7 @@ class SVGRenderer {
 
 					if ( _clipBox.intersectsBox( _elemBox ) === true ) {
 
-						renderLine( _v1, _v2, element, material );
+						renderLine( _v1, _v2, material );
 
 					}
 
@@ -397,7 +397,7 @@ class SVGRenderer {
 
 		}
 
-		function renderLine( v1, v2, element, material ) {
+		function renderLine( v1, v2, material ) {
 
 			const path = 'M' + convert( v1.positionScreen.x ) + ',' + convert( v1.positionScreen.y ) + 'L' + convert( v2.positionScreen.x ) + ',' + convert( v2.positionScreen.y );
 

package/examples/jsm/renderers/webgl/nodes/SlotNode.js

@@ -1,4 +1,4 @@
-import Node from '../../nodes/core/Node.js';
+import Node from 'three-nodes/core/Node.js';
 
 class SlotNode extends Node {
 

package/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.js

@@ -1,11 +1,21 @@
-import NodeBuilder from '../../nodes/core/NodeBuilder.js';
+import NodeBuilder, { defaultShaderStages } from 'three-nodes/core/NodeBuilder.js';
+import NodeFrame from 'three-nodes/core/NodeFrame.js';
 import SlotNode from './SlotNode.js';
-import GLSLNodeParser from '../../nodes/parsers/GLSLNodeParser.js';
+import GLSLNodeParser from 'three-nodes/parsers/GLSLNodeParser.js';
 import WebGLPhysicalContextNode from './WebGLPhysicalContextNode.js';
 
-import { ShaderChunk, LinearEncoding, RGBAFormat, UnsignedByteType, sRGBEncoding } from 'three';
+import { PerspectiveCamera, ShaderChunk, ShaderLib, UniformsUtils, UniformsLib,
+	LinearEncoding, RGBAFormat, UnsignedByteType, sRGBEncoding } from 'three';
 
-const shaderStages = [ 'vertex', 'fragment' ];
+const nodeFrame = new NodeFrame();
+nodeFrame.camera = new PerspectiveCamera();
+
+const nodeShaderLib = {
+	LineBasicNodeMaterial: ShaderLib.basic,
+	MeshBasicNodeMaterial: ShaderLib.basic,
+	PointsNodeMaterial: ShaderLib.points,
+	MeshStandardNodeMaterial: ShaderLib.standard
+};
 
 function getIncludeSnippet( name ) {
 
@@ -55,6 +65,31 @@ class WebGLNodeBuilder extends NodeBuilder {
 	_parseObject() {
 
 		const material = this.material;
+		let type = material.type;
+
+		// shader lib
+
+		if ( material.isMeshStandardNodeMaterial ) type = 'MeshStandardNodeMaterial';
+		else if ( material.isMeshBasicNodeMaterial ) type = 'MeshBasicNodeMaterial';
+		else if ( material.isPointsNodeMaterial ) type = 'PointsNodeMaterial';
+		else if ( material.isLineBasicNodeMaterial ) type = 'LineBasicNodeMaterial';
+
+		if ( nodeShaderLib[ type ] !== undefined ) {
+
+			const shaderLib = nodeShaderLib[ type ];
+			const shader = this.shader;
+
+			shader.vertexShader = shaderLib.vertexShader;
+			shader.fragmentShader = shaderLib.fragmentShader;
+			shader.uniforms = UniformsUtils.merge( [ shaderLib.uniforms, UniformsLib.lights ] );
+
+		}
+
+		if ( material.isMeshStandardNodeMaterial !== true ) {
+
+			this.replaceCode( 'fragment', getIncludeSnippet( 'tonemapping_fragment' ), '' );
+
+		}
 
 		// parse inputs
 
@@ -106,6 +141,24 @@ class WebGLNodeBuilder extends NodeBuilder {
 
 		}
 
+		if ( material.iridescenceNode && material.iridescenceNode.isNode ) {
+
+			this.addSlot( 'fragment', new SlotNode( material.iridescenceNode, 'IRIDESCENCE', 'float' ) );
+
+		}
+
+		if ( material.iridescenceIORNode && material.iridescenceIORNode.isNode ) {
+
+			this.addSlot( 'fragment', new SlotNode( material.iridescenceIORNode, 'IRIDESCENCE_IOR', 'float' ) );
+
+		}
+
+		if ( material.iridescenceThicknessNode && material.iridescenceThicknessNode.isNode ) {
+
+			this.addSlot( 'fragment', new SlotNode( material.iridescenceThicknessNode, 'IRIDESCENCE_THICKNESS', 'float' ) );
+
+		}
+
 		if ( material.envNode && material.envNode.isNode ) {
 
 			const envRadianceNode = new WebGLPhysicalContextNode( WebGLPhysicalContextNode.RADIANCE, material.envNode );
@@ -130,33 +183,31 @@ class WebGLNodeBuilder extends NodeBuilder {
 
 	}
 
-	getTexture( textureProperty, uvSnippet, biasSnippet = null ) {
+	getTexture( textureProperty, uvSnippet ) {
 
-		if ( biasSnippet !== null ) {
+		return `texture2D( ${textureProperty}, ${uvSnippet} )`;
 
-			return `texture2D( ${textureProperty}, ${uvSnippet}, ${biasSnippet} )`;
+	}
 
-		} else {
+	getTextureBias( textureProperty, uvSnippet, biasSnippet ) {
 
-			return `texture2D( ${textureProperty}, ${uvSnippet} )`;
+		if ( this.material.extensions !== undefined ) this.material.extensions.shaderTextureLOD = true;
 
-		}
+		return `textureLod( ${textureProperty}, ${uvSnippet}, ${biasSnippet} )`;
 
 	}
 
-	getCubeTexture( textureProperty, uvSnippet, biasSnippet = null ) {
+	getCubeTexture( textureProperty, uvSnippet ) {
 
-		const textureCube = 'textureCubeLodEXT'; // textureCubeLodEXT textureLod
+		return `textureCube( ${textureProperty}, ${uvSnippet} )`;
 
-		if ( biasSnippet !== null ) {
-
-			return `${textureCube}( ${textureProperty}, ${uvSnippet}, ${biasSnippet} )`;
+	}
 
-		} else {
+	getCubeTextureBias( textureProperty, uvSnippet, biasSnippet ) {
 
-			return `${textureCube}( ${textureProperty}, ${uvSnippet} )`;
+		if ( this.material.extensions !== undefined ) this.material.extensions.shaderTextureLOD = true;
 
-		}
+		return `textureLod( ${textureProperty}, ${uvSnippet}, ${biasSnippet} )`;
 
 	}
 
@@ -298,11 +349,17 @@ class WebGLNodeBuilder extends NodeBuilder {
 
 	}
 
+	getFrontFacing() {
+
+		return 'gl_FrontFacing';
+
+	}
+
 	buildCode() {
 
 		const shaderData = {};
 
-		for ( const shaderStage of shaderStages ) {
+		for ( const shaderStage of defaultShaderStages ) {
 
 			const uniforms = this.getUniforms( shaderStage );
 			const attributes = this.getAttributes( shaderStage );
@@ -338,7 +395,6 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 		this.vertexShader = shaderData.vertex;
 		this.fragmentShader = shaderData.fragment;
 
-
 	}
 
 	build() {
@@ -348,6 +404,8 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 		this._addSnippets();
 		this._addUniforms();
 
+		this._updateUniforms();
+
 		this.shader.vertexShader = this.vertexShader;
 		this.shader.fragmentShader = this.fragmentShader;
 
@@ -363,7 +421,7 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 
 			if ( node.name === name ) {
 
-				return this.getFlowData( shaderStage, node );
+				return this.getFlowData( node/*, shaderStage*/ );
 
 			}
 
@@ -383,6 +441,9 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 		const metalnessNode = this.getSlot( 'fragment', 'METALNESS' );
 		const clearcoatNode = this.getSlot( 'fragment', 'CLEARCOAT' );
 		const clearcoatRoughnessNode = this.getSlot( 'fragment', 'CLEARCOAT_ROUGHNESS' );
+		const iridescenceNode = this.getSlot( 'fragment', 'IRIDESCENCE' );
+		const iridescenceIORNode = this.getSlot( 'fragment', 'IRIDESCENCE_IOR' );
+		const iridescenceThicknessNode = this.getSlot( 'fragment', 'IRIDESCENCE_THICKNESS' );
 
 		const positionNode = this.getSlot( 'vertex', 'POSITION' );
 		const sizeNode = this.getSlot( 'vertex', 'SIZE' );
@@ -467,6 +528,36 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 
 		}
 
+		if ( iridescenceNode !== undefined ) {
+
+			this.addCodeAfterSnippet(
+				'fragment',
+				'iridescence_fragment',
+				`${iridescenceNode.code}\n\tmaterial.iridescence = ${iridescenceNode.result};`
+			);
+
+		}
+
+		if ( iridescenceIORNode !== undefined ) {
+
+			this.addCodeAfterSnippet(
+				'fragment',
+				'iridescence_fragment',
+				`${iridescenceIORNode.code}\n\tmaterial.iridescenceIOR = ${iridescenceIORNode.result};`
+			);
+
+		}
+
+		if ( iridescenceThicknessNode !== undefined ) {
+
+			this.addCodeAfterSnippet(
+				'fragment',
+				'iridescence_fragment',
+				`${iridescenceThicknessNode.code}\n\tmaterial.iridescenceThickness = ${iridescenceThicknessNode.result};`
+			);
+
+		}
+
 		if ( positionNode !== undefined ) {
 
 			this.addCodeAfterInclude(
@@ -487,7 +578,7 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 
 		}
 
-		for ( const shaderStage of shaderStages ) {
+		for ( const shaderStage of defaultShaderStages ) {
 
 			this.addCodeAfterSnippet(
 				shaderStage,
@@ -501,7 +592,7 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 
 	_addUniforms() {
 
-		for ( const shaderStage of shaderStages ) {
+		for ( const shaderStage of defaultShaderStages ) {
 
 			// uniforms
 
@@ -515,6 +606,19 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 
 	}
 
+	_updateUniforms() {
+
+		nodeFrame.object = this.object;
+		nodeFrame.renderer = this.renderer;
+
+		for ( const node of this.updateNodes ) {
+
+			nodeFrame.updateNode( node );
+
+		}
+
+	}
+
 }
 
 export { WebGLNodeBuilder };