mrdoob approves

examples/jsm/renderers/nodes/core/InputNode.js

@@ -3,54 +3,54 @@ import Node from './Node.js';
 class InputNode extends Node {
 
 	constructor( type ) {
-		
+
 		super( type );
 
 		this.constant = false;
-		
+
 		Object.defineProperty( this, 'isInputNode', { value: true } );
-		
+
 	}
-	
+
 	setConst( value ) {
-		
+
 		this.constant = value;
-		
+
 		return this;
-		
+
 	}
-	
+
 	getConst() {
-		
+
 		return this.constant;
-		
+
 	}
-	
+
 	generateConst( /*builder*/ ) {
-		
-		console.warn("Abstract function");
-		
+
+		console.warn( "Abstract function" );
+
 	}
-	
+
 	generate( builder, output ) {
-		
+
 		const type = this.getType( builder );
-		
+
 		if ( this.constant === true ) {
-		
+
 			return builder.format( this.generateConst( builder ), type, output );
-			
+
 		} else {
-			
+
 			const nodeUniform = builder.getUniformFromNode( this, builder.shaderStage, this.getType( builder ) );
 			const nsName = builder.getUniformNSName( nodeUniform );
-			
+
 			return builder.format( nsName, type, output );
-			
+
 		}
-		
+
 	}
-	
+
 }
 
 export default InputNode;

examples/jsm/renderers/nodes/core/Node.js

@@ -1,31 +1,31 @@
 class Node {
 
 	constructor( type ) {
-		
+
 		this.type = type;
-		
+
 		Object.defineProperty( this, 'isNode', { value: true } );
-		
+
 	}
-	
+
 	getType( /*builder*/ ) {
-		
+
 		return this.type;
-		
+
 	}
-	
+
 	generate( /*builder, output*/ ) {
-		
-		console.warn("Abstract function");
-		
+
+		console.warn( "Abstract function" );
+
 	}
-	
+
 	build( builder, output ) {
-		
+
 		return this.generate( builder, output );
-		
+
 	}
-	
+
 }
 
 export default Node;

examples/jsm/renderers/nodes/core/NodeBuilder.js

@@ -5,62 +5,62 @@ const VERSION = '1';
 class NodeBuilder {
 
 	constructor( material, renderer ) {
-		
+
 		this.material = material;
 		this.renderer = renderer;
-		
+
 		this.slots = { vertex: [], fragment: [] };
 		this.defines = { vertex: {}, fragment: {} };
 		this.uniforms = { vertex: [], fragment: [] };
-		
+
 		this.nodesData = new WeakMap();
-		
+
 		this.shaderStage = null;
-		
+
 	}
-	
+
 	addSlot( shader, slot ) {
-		
+
 		this.slots[ shader ].push( slot );
-		
+
 	}
-	
+
 	define( shader, name, value = '' ) {
-		
+
 		this.defines[ shader ][ name ] = value;
-		
+
 	}
-	
+
 	generateVec2( x, y ) {
-		
+
 		return `vec2( ${x}, ${y})`;
-		
+
 	}
-	
+
 	generateVec3( x, y, z ) {
-		
+
 		return `vec3( ${x}, ${y}, ${z} )`;
-		
+
 	}
-	
+
 	generateVec4( x, y, z, w ) {
-		
+
 		return `vec4( ${x}, ${y}, ${z}, ${w} )`;
-		
+
 	}
-	
+
 	generateFloat( value ) {
-		
+
 		return value + ( value % 1 ? '' : '.0' );
-		
+
 	}
-	
+
 	getUniformNSName( nodeUniform ) {
-		
+
 		return nodeUniform.name;
-		
+
 	}
-	
+
 	getTypeLength( type ) {
 
 		if ( type === 'float' ) return 1;
@@ -71,121 +71,121 @@ class NodeBuilder {
 		return 0;
 
 	}
-	
+
 	getDataFromNode( node, shaderStage = null ) {
-		
+
 		let nodeData = this.nodesData.get( node );
-		
+
 		if ( nodeData === undefined ) {
-			
+
 			nodeData = { vertex: {}, fragment: {} };
-			
+
 			this.nodesData.set( node, nodeData );
-			
+
 		}
-		
+
 		return shaderStage ? nodeData[ shaderStage ] : nodeData;
-		
+
 	}
-	
+
 	getUniformFromNode( node, shaderStage, type ) {
-		
+
 		const nodeData = this.getDataFromNode( node, shaderStage );
-		
+
 		let nodeUniform = nodeData.uniform;
-		
+
 		if ( nodeUniform === undefined ) {
-			
-			const uniforms = this.uniforms[shaderStage];
+
+			const uniforms = this.uniforms[ shaderStage ];
 			const index = uniforms.length;
-			
+
 			nodeUniform = new NodeUniform( 'nodeU' + index, type, node );
-			
+
 			uniforms.push( nodeUniform );
-			
+
 			nodeData.uniform = nodeUniform;
-			
+
 		}
-		
+
 		return nodeUniform;
-		
+
 	}
-	
+
 	/*
 	analyzeNode( node ) {
-		
-		
+
+
 	}
 	*/
-	
+
 	flowNode( node, output ) {
-		
+
 		let flowData = {};
 		flowData.result = node.build( this, output );
-		
+
 		return flowData;
-		
+
 	}
-	
+
 	buildDefines( shader ) {
-		
+
 		const defines = this.defines[ shader ];
-		
+
 		let code = '';
-		
+
 		for ( let name in defines ) {
-			
-			code += `#define ${name} ${defines[name]}\n`;
-			
+
+			code += `#define ${name} ${defines[ name ]}\n`;
+
 		}
-		
+
 		return code;
-		
+
 	}
-	
+
 	build( shaderStage ) {
-		
+
 		this.shaderStage = shaderStage;
-		
+
 		const slots = this.slots[ shaderStage ];
 		const uniforms = this.uniforms[ shaderStage ];
-		
+
 		if ( slots.length ) {
-			
+
 			this.define( shaderStage, 'NODE', VERSION );
-			
-			for( let i = 0; i < slots.length; i++) {
-			
-				let slot = slots[i];
-				
+
+			for ( let i = 0; i < slots.length; i ++ ) {
+
+				let slot = slots[ i ];
+
 				let flowData = this.flowNode( slot.node, slot.output );
-				
+
 				this.define( shaderStage, `NODE_${slot.name}`, flowData.result );
-				
+
 			}
-			
+
 			let uniformsCode = '';
-			
-			for( let i = 0; i < uniforms.length; i++) {
-				
-				let uniform = uniforms[i];
-				
+
+			for ( let i = 0; i < uniforms.length; i ++ ) {
+
+				let uniform = uniforms[ i ];
+
 				uniformsCode += `${uniform.type} ${uniform.name}; `;
-				
+
 			}
-			
+
 			this.define( shaderStage, 'NODE_UNIFORMS', uniformsCode );
-			
+
 		}
-		
+
 		let defines = this.buildDefines( shaderStage );
-		
+
 		return {
 			defines
 		};
-		
+
 	}
-	
+
 	format( code, fromType, toType ) {
 
 		const typeToType = `${fromType} -> ${toType}`;
@@ -193,7 +193,7 @@ class NodeBuilder {
 		switch ( typeToType ) {
 
 			case 'float -> vec3' : return `vec3( ${code} )`;
-			
+
 			case 'vec3 -> float' : return `${code}.x`;
 
 		}
@@ -201,7 +201,7 @@ class NodeBuilder {
 		return code;
 
 	}
-	
+
 }
 
 export default NodeBuilder;

examples/jsm/renderers/nodes/core/NodeSlot.js

@@ -1,13 +1,13 @@
 class NodeSlot {
 
 	constructor( node, name, output ) {
-		
+
 		this.node = node;
 		this.name = name;
 		this.output = output;
-		
+
 	}
-	
+
 }
 
 export default NodeSlot;

examples/jsm/renderers/nodes/core/NodeUniform.js

@@ -10,15 +10,15 @@ class NodeUniform {
 	}
 
 	get value() {
-		
+
 		return this.node.value;
-		
+
 	}
-	
+
 	set value( val ) {
-		
+
 		this.node.value = val;
-		
+
 	}
 
 }

examples/jsm/renderers/nodes/math/OperatorNode.js

@@ -1,23 +1,23 @@
 import Node from '../core/Node.js';
 
- class OperatorNode extends Node {
+class OperatorNode extends Node {
 
 	constructor( op, a, b ) {
 
 		super();
 
 		this.op = op;
-		
+
 		this.a = a;
 		this.b = b;
-		
+
 	}
 
 	getType( builder ) {
-		
+
 		const typeA = this.a.getType( builder );
 		const typeB = this.b.getType( builder );
-		
+
 		if ( builder.getTypeLength( typeB ) > builder.getTypeLength( typeA ) ) {
 
 			// use the greater length vector
@@ -27,7 +27,7 @@ import Node from '../core/Node.js';
 		}
 
 		return typeA;
-		
+
 	}
 
 	generate( builder, output ) {
@@ -40,7 +40,7 @@ import Node from '../core/Node.js';
 		return builder.format( '( ' + a + ' ' + this.op + ' ' + b + ' )', type, output );
 
 	}
-		
- }
+
+}
 
 export default OperatorNode;

examples/jsm/renderers/webgpu/WebGPUNodeBuilder.js

@@ -5,28 +5,29 @@ import NodeSlot from '../nodes/core/NodeSlot.js';
 import NodeBuilder from '../nodes/core/NodeBuilder.js';
 
 class WebGPUNodeUniformsGroup extends WebGPUUniformsGroup {
-	
+
 	constructor( shaderStage ) {
 
 		super( 'nodeUniforms' );
-		
+
 		let shaderStageVisibility;
-		
+
 		if ( shaderStage === 'vertex' ) shaderStageVisibility = GPUShaderStage.VERTEX;
 		else if ( shaderStage === 'fragment' ) shaderStageVisibility = GPUShaderStage.FRAGMENT;
-			
+
 		this.setVisibility( shaderStageVisibility );
-		
+
 		//this.setOnBeforeUpdate( this._onBeforeUpdate );
-		
+
 	}
 	/*
 	_onBeforeUpdate( object, camera ) {
-		
+
 		const material = object.material;
-		
+
 	}
 	*/
+
 }
 
 class WebGPUNodeBuilder extends NodeBuilder {
@@ -34,117 +35,117 @@ class WebGPUNodeBuilder extends NodeBuilder {
 	constructor( material, renderer ) {
 
 		super( material, renderer );
-		
+
 		this.uniformsGroup = {};
-		
+
 		this._parseMaterial();
-		
+
 	}
-	
+
 	_parseMaterial() {
-		
+
 		const material = this.material;
-		
+
 		if ( material.isMeshBasicMaterial || material.isPointsMaterial ) {
-			
+
 			if ( material.colorNode !== undefined ) {
-				
+
 				this.addSlot( 'fragment', new NodeSlot( material.colorNode, 'COLOR', 'vec3' ) );
-				
+
 			}
-			
+
 			if ( material.opacityNode !== undefined ) {
-				
+
 				this.addSlot( 'fragment', new NodeSlot( material.opacityNode, 'OPACITY', 'float' ) );
-				
+
 			}
-			
+
 		}
-		
+
 	}
-	
+
 	getUniformNSName( nodeUniform ) {
-		
+
 		return `nodeUniforms.${nodeUniform.name}`;
-		
+
 	}
-	
+
 	getBindings() {
-		
+
 		const bindings = [];
-		
+
 		const uniformsVertexGroup = this.uniformsGroup[ 'vertex' ];
 		const uniformsFragmentGroup = this.uniformsGroup[ 'fragment' ];
-		
+
 		if ( uniformsVertexGroup ) bindings.push( uniformsVertexGroup );
 		if ( uniformsFragmentGroup ) bindings.push( uniformsFragmentGroup );
-		
+
 		return bindings;
-		
+
 	}
-	
+
 	getUniformFromNode( node, shaderStage, type ) {
-		
-		const uniformNode = super.getUniformFromNode( node, shaderStage, type ) 
+
+		const uniformNode = super.getUniformFromNode( node, shaderStage, type );
 		const nodeData = this.getDataFromNode( node, shaderStage );
-		
+
 		if ( nodeData.uniformGroup === undefined ) {
-			
-			let uniformsGroup = this.uniformsGroup[shaderStage];
-			
-			if (uniformsGroup === undefined) {
-				
+
+			let uniformsGroup = this.uniformsGroup[ shaderStage ];
+
+			if ( uniformsGroup === undefined ) {
+
 				uniformsGroup = new WebGPUNodeUniformsGroup( shaderStage );
-				
-				this.uniformsGroup[shaderStage] = uniformsGroup;
-				
+
+				this.uniformsGroup[ shaderStage ] = uniformsGroup;
+
 			}
-			
+
 			let uniformGroup;
-			
+
 			if ( type === 'float' ) {
-				
+
 				uniformGroup = new FloatUniform( uniformNode.name, uniformNode.value );
-				
+
 			} else if ( type === 'vec3' ) {
-				
+
 				uniformGroup = new Vector3Uniform( uniformNode.name, uniformNode.value );
-				
+
 			} else {
-				
+
 				console.error( `Uniform "${type}" not declared.` );
-				
+
 			}
-			
+
 			uniformsGroup.addUniform( uniformGroup );
-			
+
 			nodeData.uniformGroup = uniformGroup;
-			
+
 		}
-		
+
 		return uniformNode;
-		
+
 	}
-	
+
 	buildShader( shaderStage, code ) {
-		
+
 		// use regex maybe for security?
-		const versionStrIndex = code.indexOf("\n");
-		
+		const versionStrIndex = code.indexOf( "\n" );
+
 		let finalCode = code.substr( 0, versionStrIndex ) + "\n\n";
 
 		const shaderCodes = this.build( shaderStage );
-		
+
 		finalCode += shaderCodes.defines;
 
 		finalCode += code.substr( versionStrIndex );
 
 		return finalCode;
-		
+
 	}
-	
+
 	parse( vertexShader, fragmentShader ) {
-		
+
 		vertexShader = this.buildShader( 'vertex', vertexShader );
 		fragmentShader = this.buildShader( 'fragment', fragmentShader );
 
@@ -152,7 +153,7 @@ class WebGPUNodeBuilder extends NodeBuilder {
 			vertexShader,
 			fragmentShader
 		};
-		
+
 	}
 
 }